feature/1220 origin handle exists method (#1241)

* feat: add docs and CI workflow for publishing to onsonr.dev

* (refactor): Move hway,motr executables to their own repos

* feat: simplify devnet and testnet configurations

* refactor: update import path for didcrypto package

* docs(networks): Add README with project overview, architecture, and community links

* refactor: Move network configurations to deploy directory

* build: update golang version to 1.23

* refactor: move logger interface to appropriate package

* refactor: Move devnet configuration to networks/devnet

* chore: improve release process with date variable

* (chore): Move Crypto Library

* refactor: improve code structure and readability in DID module

* feat: integrate Trunk CI checks

* ci: optimize CI workflow by removing redundant build jobs

---------

Co-authored-by: Darp Alakun <i@prad.nu>

crypto/keys/didkey.go

@@ -0,0 +1,162 @@
+package keys
+
+import (
+	"crypto/ed25519"
+	"crypto/rsa"
+	"crypto/x509"
+	"fmt"
+	"strings"
+
+	"github.com/libp2p/go-libp2p/core/crypto"
+	mb "github.com/multiformats/go-multibase"
+	varint "github.com/multiformats/go-varint"
+)
+
+const (
+	// KeyPrefix indicates a decentralized identifier that uses the key method
+	KeyPrefix = "did:key"
+	// MulticodecKindRSAPubKey rsa-x509-pub https://github.com/multiformats/multicodec/pull/226
+	MulticodecKindRSAPubKey = 0x1205
+	// MulticodecKindEd25519PubKey ed25519-pub
+	MulticodecKindEd25519PubKey = 0xed
+	// MulticodecKindSecp256k1PubKey secp256k1-pub
+	MulticodecKindSecp256k1PubKey = 0x1206
+)
+
+// DID is a DID:key identifier
+type DID struct {
+	crypto.PubKey
+}
+
+// NewDID constructs an Identifier from a public key
+func NewDID(pub crypto.PubKey) (DID, error) {
+	switch pub.Type() {
+	case crypto.Ed25519, crypto.RSA, crypto.Secp256k1:
+		return DID{PubKey: pub}, nil
+	default:
+		return DID{}, fmt.Errorf("unsupported key type: %s", pub.Type())
+	}
+}
+
+// NewFromPubKey constructs an Identifier from a public key
+func NewFromPubKey(pub PubKey) DID {
+	return DID{PubKey: pub}
+}
+
+// MulticodecType indicates the type for this multicodec
+func (id DID) MulticodecType() uint64 {
+	switch id.Type() {
+	case crypto.RSA:
+		return MulticodecKindRSAPubKey
+	case crypto.Ed25519:
+		return MulticodecKindEd25519PubKey
+	case crypto.Secp256k1:
+		return MulticodecKindSecp256k1PubKey
+	default:
+		panic("unexpected crypto type")
+	}
+}
+
+// String returns this did:key formatted as a string
+func (id DID) String() string {
+	raw, err := id.Raw()
+	if err != nil {
+		return ""
+	}
+
+	t := id.MulticodecType()
+	size := varint.UvarintSize(t)
+	data := make([]byte, size+len(raw))
+	n := varint.PutUvarint(data, t)
+	copy(data[n:], raw)
+
+	b58BKeyStr, err := mb.Encode(mb.Base58BTC, data)
+	if err != nil {
+		return ""
+	}
+
+	return fmt.Sprintf("%s:%s", KeyPrefix, b58BKeyStr)
+}
+
+// VerifyKey returns the backing implementation for a public key, one of:
+// *rsa.PublicKey, ed25519.PublicKey
+func (id DID) VerifyKey() (interface{}, error) {
+	rawPubBytes, err := id.Raw()
+	if err != nil {
+		return nil, err
+	}
+	switch id.Type() {
+	case crypto.RSA:
+		verifyKeyiface, err := x509.ParsePKIXPublicKey(rawPubBytes)
+		if err != nil {
+			return nil, err
+		}
+		verifyKey, ok := verifyKeyiface.(*rsa.PublicKey)
+		if !ok {
+			return nil, fmt.Errorf("public key is not an RSA key. got type: %T", verifyKeyiface)
+		}
+		return verifyKey, nil
+	case crypto.Ed25519:
+		return ed25519.PublicKey(rawPubBytes), nil
+	case crypto.Secp256k1:
+		// Handle both compressed and uncompressed Secp256k1 public keys
+		if len(rawPubBytes) == 65 || len(rawPubBytes) == 33 {
+			return rawPubBytes, nil
+		}
+		return nil, fmt.Errorf("invalid Secp256k1 public key length: %d", len(rawPubBytes))
+	default:
+		return nil, fmt.Errorf("unrecognized Public Key type: %s", id.Type())
+	}
+}
+
+// Parse turns a string into a key method ID
+func Parse(keystr string) (DID, error) {
+	var id DID
+	if !strings.HasPrefix(keystr, KeyPrefix) {
+		return id, fmt.Errorf("decentralized identifier is not a 'key' type")
+	}
+
+	keystr = strings.TrimPrefix(keystr, KeyPrefix+":")
+
+	enc, data, err := mb.Decode(keystr)
+	if err != nil {
+		return id, fmt.Errorf("decoding multibase: %w", err)
+	}
+
+	if enc != mb.Base58BTC {
+		return id, fmt.Errorf("unexpected multibase encoding: %s", mb.EncodingToStr[enc])
+	}
+
+	keyType, n, err := varint.FromUvarint(data)
+	if err != nil {
+		return id, err
+	}
+
+	switch keyType {
+	case MulticodecKindRSAPubKey:
+		pub, err := crypto.UnmarshalRsaPublicKey(data[n:])
+		if err != nil {
+			return id, err
+		}
+		return DID{pub}, nil
+	case MulticodecKindEd25519PubKey:
+		pub, err := crypto.UnmarshalEd25519PublicKey(data[n:])
+		if err != nil {
+			return id, err
+		}
+		return DID{pub}, nil
+	case MulticodecKindSecp256k1PubKey:
+		// Handle both compressed and uncompressed formats
+		keyData := data[n:]
+		if len(keyData) != 33 && len(keyData) != 65 {
+			return id, fmt.Errorf("invalid Secp256k1 public key length: %d", len(keyData))
+		}
+		pub, err := crypto.UnmarshalSecp256k1PublicKey(keyData)
+		if err != nil {
+			return id, fmt.Errorf("failed to unmarshal Secp256k1 key: %w", err)
+		}
+		return DID{pub}, nil
+	}
+
+	return id, fmt.Errorf("unrecognized key type multicodec prefix: %x", data[0])
+}

crypto/keys/methods.go

@@ -0,0 +1,17 @@
+package keys
+
+type DIDMethod string
+
+const (
+	DIDMethodKey      DIDMethod = "key"
+	DIDMethodSonr     DIDMethod = "sonr"
+	DIDMehthodBitcoin DIDMethod = "btcr"
+	DIDMethodEthereum DIDMethod = "ethr"
+	DIDMethodCbor     DIDMethod = "cbor"
+	DIDMethodCID      DIDMethod = "cid"
+	DIDMethodIPFS     DIDMethod = "ipfs"
+)
+
+func (d DIDMethod) String() string {
+	return string(d)
+}

crypto/keys/parsers/btc_parser.go

@@ -0,0 +1 @@
+package parsers

crypto/keys/parsers/cosmos_parser.go

@@ -0,0 +1,12 @@
+package parsers
+
+type CosmosPrefix string
+
+const (
+	ATOMPrefix   CosmosPrefix = "cosmos"
+	AXELARPrefix CosmosPrefix = "axelar"
+	EVMOSPrefix  CosmosPrefix = "evmos"
+	OSMOPrefix   CosmosPrefix = "osmo"
+	SONRPrefix   CosmosPrefix = "idx"
+	STARSPrefix  CosmosPrefix = "stars"
+)

crypto/keys/parsers/eth_parser.go

@@ -0,0 +1 @@
+package parsers

crypto/keys/parsers/fil_parser.go

@@ -0,0 +1 @@
+package parsers

crypto/keys/parsers/key_parser.go

@@ -0,0 +1,157 @@
+package parsers
+
+import (
+	"crypto/ed25519"
+	"crypto/rsa"
+	"crypto/x509"
+	"fmt"
+	"strings"
+
+	"github.com/libp2p/go-libp2p/core/crypto"
+	mb "github.com/multiformats/go-multibase"
+	varint "github.com/multiformats/go-varint"
+)
+
+const (
+	// KeyPrefix indicates a decentralized identifier that uses the key method
+	KeyPrefix = "did:key"
+	// MulticodecKindRSAPubKey rsa-x509-pub https://github.com/multiformats/multicodec/pull/226
+	MulticodecKindRSAPubKey = 0x1205
+	// MulticodecKindEd25519PubKey ed25519-pub
+	MulticodecKindEd25519PubKey = 0xed
+	// MulticodecKindSecp256k1PubKey secp256k1-pub
+	MulticodecKindSecp256k1PubKey = 0x1206
+)
+
+// DIDKey is a DID:key identifier
+type DIDKey struct {
+	crypto.PubKey
+}
+
+// NewKeyDID constructs an Identifier from a public key
+func NewKeyDID(pub crypto.PubKey) (DIDKey, error) {
+	switch pub.Type() {
+	case crypto.Ed25519, crypto.RSA, crypto.Secp256k1:
+		return DIDKey{PubKey: pub}, nil
+	default:
+		return DIDKey{}, fmt.Errorf("unsupported key type: %s", pub.Type())
+	}
+}
+
+// MulticodecType indicates the type for this multicodec
+func (id DIDKey) MulticodecType() uint64 {
+	switch id.Type() {
+	case crypto.RSA:
+		return MulticodecKindRSAPubKey
+	case crypto.Ed25519:
+		return MulticodecKindEd25519PubKey
+	case crypto.Secp256k1:
+		return MulticodecKindSecp256k1PubKey
+	default:
+		panic("unexpected crypto type")
+	}
+}
+
+// String returns this did:key formatted as a string
+func (id DIDKey) String() string {
+	raw, err := id.Raw()
+	if err != nil {
+		return ""
+	}
+
+	t := id.MulticodecType()
+	size := varint.UvarintSize(t)
+	data := make([]byte, size+len(raw))
+	n := varint.PutUvarint(data, t)
+	copy(data[n:], raw)
+
+	b58BKeyStr, err := mb.Encode(mb.Base58BTC, data)
+	if err != nil {
+		return ""
+	}
+
+	return fmt.Sprintf("%s:%s", KeyPrefix, b58BKeyStr)
+}
+
+// VerifyKey returns the backing implementation for a public key, one of:
+// *rsa.PublicKey, ed25519.PublicKey
+func (id DIDKey) VerifyKey() (interface{}, error) {
+	rawPubBytes, err := id.PubKey.Raw()
+	if err != nil {
+		return nil, err
+	}
+	switch id.PubKey.Type() {
+	case crypto.RSA:
+		verifyKeyiface, err := x509.ParsePKIXPublicKey(rawPubBytes)
+		if err != nil {
+			return nil, err
+		}
+		verifyKey, ok := verifyKeyiface.(*rsa.PublicKey)
+		if !ok {
+			return nil, fmt.Errorf("public key is not an RSA key. got type: %T", verifyKeyiface)
+		}
+		return verifyKey, nil
+	case crypto.Ed25519:
+		return ed25519.PublicKey(rawPubBytes), nil
+	case crypto.Secp256k1:
+		// Handle both compressed and uncompressed Secp256k1 public keys
+		if len(rawPubBytes) == 65 || len(rawPubBytes) == 33 {
+			return rawPubBytes, nil
+		}
+		return nil, fmt.Errorf("invalid Secp256k1 public key length: %d", len(rawPubBytes))
+	default:
+		return nil, fmt.Errorf("unrecognized Public Key type: %s", id.Type())
+	}
+}
+
+// Parse turns a string into a key method ID
+func Parse(keystr string) (DIDKey, error) {
+	var id DIDKey
+	if !strings.HasPrefix(keystr, KeyPrefix) {
+		return id, fmt.Errorf("decentralized identifier is not a 'key' type")
+	}
+
+	keystr = strings.TrimPrefix(keystr, KeyPrefix+":")
+
+	enc, data, err := mb.Decode(keystr)
+	if err != nil {
+		return id, fmt.Errorf("decoding multibase: %w", err)
+	}
+
+	if enc != mb.Base58BTC {
+		return id, fmt.Errorf("unexpected multibase encoding: %s", mb.EncodingToStr[enc])
+	}
+
+	keyType, n, err := varint.FromUvarint(data)
+	if err != nil {
+		return id, err
+	}
+
+	switch keyType {
+	case MulticodecKindRSAPubKey:
+		pub, err := crypto.UnmarshalRsaPublicKey(data[n:])
+		if err != nil {
+			return id, err
+		}
+		return DIDKey{pub}, nil
+	case MulticodecKindEd25519PubKey:
+		pub, err := crypto.UnmarshalEd25519PublicKey(data[n:])
+		if err != nil {
+			return id, err
+		}
+		return DIDKey{pub}, nil
+	case MulticodecKindSecp256k1PubKey:
+		// Handle both compressed and uncompressed formats
+		keyData := data[n:]
+		if len(keyData) != 33 && len(keyData) != 65 {
+			return id, fmt.Errorf("invalid Secp256k1 public key length: %d", len(keyData))
+		}
+		pub, err := crypto.UnmarshalSecp256k1PublicKey(keyData)
+		if err != nil {
+			return id, fmt.Errorf("failed to unmarshal Secp256k1 key: %w", err)
+		}
+		return DIDKey{pub}, nil
+	}
+
+	return id, fmt.Errorf("unrecognized key type multicodec prefix: %x", data[0])
+}

crypto/keys/parsers/sol_parser.go

@@ -0,0 +1 @@
+package parsers

crypto/keys/parsers/ton_parser.go

@@ -0,0 +1 @@
+package parsers

crypto/keys/pubkey.go

@@ -0,0 +1,86 @@
+package keys
+
+import (
+	"bytes"
+	"crypto/ecdsa"
+	"encoding/hex"
+
+	p2pcrypto "github.com/libp2p/go-libp2p/core/crypto"
+	p2ppb "github.com/libp2p/go-libp2p/core/crypto/pb"
+	"github.com/onsonr/sonr/crypto/core/curves"
+	"golang.org/x/crypto/sha3"
+)
+
+type PubKey interface {
+	Bytes() []byte
+	Raw() ([]byte, error)
+	Equals(b p2pcrypto.Key) bool
+	Type() p2ppb.KeyType
+	Hex() string
+	Verify(msg []byte, sig []byte) (bool, error)
+}
+
+type pubKey struct {
+	publicPoint curves.Point
+	method      string
+}
+
+func NewPubKey(pk curves.Point) PubKey {
+	return &pubKey{
+		publicPoint: pk,
+	}
+}
+
+func (p pubKey) Bytes() []byte {
+	return p.publicPoint.ToAffineCompressed()
+}
+
+func (p pubKey) Raw() ([]byte, error) {
+	return p.publicPoint.ToAffineCompressed(), nil
+}
+
+func (p pubKey) Equals(b p2pcrypto.Key) bool {
+	if b == nil {
+		return false
+	}
+	apbz, err := b.Raw()
+	if err != nil {
+		return false
+	}
+	bbz, err := p.Raw()
+	if err != nil {
+		return false
+	}
+	return bytes.Equal(apbz, bbz)
+}
+
+func (p pubKey) Hex() string {
+	return hex.EncodeToString(p.publicPoint.ToAffineCompressed())
+}
+
+func (p pubKey) Type() p2ppb.KeyType {
+	return p2ppb.KeyType_Secp256k1
+}
+
+func (p pubKey) Verify(data []byte, sigBz []byte) (bool, error) {
+	sig, err := deserializeSignature(sigBz)
+	if err != nil {
+		return false, err
+	}
+	pp, err := getEcdsaPoint(p.Bytes())
+	if err != nil {
+		return false, err
+	}
+	pk := &ecdsa.PublicKey{
+		Curve: pp.Curve,
+		X:     pp.X,
+		Y:     pp.Y,
+	}
+
+	// Hash the message using SHA3-256
+	hash := sha3.New256()
+	hash.Write(data)
+	digest := hash.Sum(nil)
+
+	return ecdsa.Verify(pk, digest, sig.R, sig.S), nil
+}

crypto/keys/utils.go

@@ -0,0 +1,46 @@
+package keys
+
+import (
+	"errors"
+	"fmt"
+	"math/big"
+
+	"github.com/onsonr/sonr/crypto/core/curves"
+)
+
+// getEcdsaPoint builds an elliptic curve point from a compressed byte slice
+func getEcdsaPoint(pubKey []byte) (*curves.EcPoint, error) {
+	crv := curves.K256()
+	x := new(big.Int).SetBytes(pubKey[1:33])
+	y := new(big.Int).SetBytes(pubKey[33:])
+	ecCurve, err := crv.ToEllipticCurve()
+	if err != nil {
+		return nil, fmt.Errorf("error converting curve: %v", err)
+	}
+	return &curves.EcPoint{X: x, Y: y, Curve: ecCurve}, nil
+}
+
+// SerializeSecp256k1Signature serializes an ECDSA signature into a byte slice
+func serializeSignature(sig *curves.EcdsaSignature) ([]byte, error) {
+	rBytes := sig.R.Bytes()
+	sBytes := sig.S.Bytes()
+
+	sigBytes := make([]byte, 66) // V (1 byte) + R (32 bytes) + S (32 bytes)
+	sigBytes[0] = byte(sig.V)
+	copy(sigBytes[33-len(rBytes):33], rBytes)
+	copy(sigBytes[66-len(sBytes):66], sBytes)
+	return sigBytes, nil
+}
+
+// DeserializeSecp256k1Signature deserializes an ECDSA signature from a byte slice
+func deserializeSignature(sigBytes []byte) (*curves.EcdsaSignature, error) {
+	if len(sigBytes) != 66 {
+		return nil, errors.New("malformed signature: not the correct size")
+	}
+	sig := &curves.EcdsaSignature{
+		V: int(sigBytes[0]),
+		R: new(big.Int).SetBytes(sigBytes[1:33]),
+		S: new(big.Int).SetBytes(sigBytes[33:66]),
+	}
+	return sig, nil
+}