refactor/internal (#1216)

* refactor: update import paths in gateway handlers

* refactor: remove obsolete devtools Makefile and README

* build: optimize build process for improved efficiency

* refactor: remove obsolete pkl files related to Matrix and Sonr network configurations

* refactor: move embed code to x/dwn/types

internal/crypto/ucan/attns/UCAN.pkl.go

@@ -0,0 +1,36 @@
+// Code generated from Pkl module `sonr.orm.UCAN`. DO NOT EDIT.
+package attns
+
+import (
+	"context"
+
+	"github.com/apple/pkl-go/pkl"
+)
+
+type UCAN struct {
+}
+
+// LoadFromPath loads the pkl module at the given path and evaluates it into a UCAN
+func LoadFromPath(ctx context.Context, path string) (ret *UCAN, err error) {
+	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		cerr := evaluator.Close()
+		if err == nil {
+			err = cerr
+		}
+	}()
+	ret, err = Load(ctx, evaluator, pkl.FileSource(path))
+	return ret, err
+}
+
+// Load loads the pkl module at the given source and evaluates it with the given evaluator into a UCAN
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*UCAN, error) {
+	var ret UCAN
+	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
+		return nil, err
+	}
+	return &ret, nil
+}

internal/crypto/ucan/attns/capaccount/CapAccount.pkl.go

@@ -0,0 +1,49 @@
+// Code generated from Pkl module `sonr.orm.UCAN`. DO NOT EDIT.
+package capaccount
+
+import (
+	"encoding"
+	"fmt"
+)
+
+type CapAccount string
+
+const (
+	ExecBroadcast CapAccount = "exec/broadcast"
+	ExecQuery     CapAccount = "exec/query"
+	ExecSimulate  CapAccount = "exec/simulate"
+	ExecVote      CapAccount = "exec/vote"
+	ExecDelegate  CapAccount = "exec/delegate"
+	ExecInvoke    CapAccount = "exec/invoke"
+	ExecSend      CapAccount = "exec/send"
+)
+
+// String returns the string representation of CapAccount
+func (rcv CapAccount) String() string {
+	return string(rcv)
+}
+
+var _ encoding.BinaryUnmarshaler = new(CapAccount)
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler for CapAccount.
+func (rcv *CapAccount) UnmarshalBinary(data []byte) error {
+	switch str := string(data); str {
+	case "exec/broadcast":
+		*rcv = ExecBroadcast
+	case "exec/query":
+		*rcv = ExecQuery
+	case "exec/simulate":
+		*rcv = ExecSimulate
+	case "exec/vote":
+		*rcv = ExecVote
+	case "exec/delegate":
+		*rcv = ExecDelegate
+	case "exec/invoke":
+		*rcv = ExecInvoke
+	case "exec/send":
+		*rcv = ExecSend
+	default:
+		return fmt.Errorf(`illegal: "%s" is not a valid CapAccount`, str)
+	}
+	return nil
+}

internal/crypto/ucan/attns/capaccount/caps.go

@@ -0,0 +1,11 @@
+package capaccount
+
+import "github.com/onsonr/sonr/internal/crypto/ucan"
+
+func NewCap(ty CapAccount) ucan.Capability {
+	return ucan.Capability(ty)
+}
+
+func (c CapAccount) Contains(b ucan.Capability) bool {
+	return c.String() == b.String()
+}

internal/crypto/ucan/attns/capinterchain/CapInterchain.pkl.go

@@ -0,0 +1,43 @@
+// Code generated from Pkl module `sonr.orm.UCAN`. DO NOT EDIT.
+package capinterchain
+
+import (
+	"encoding"
+	"fmt"
+)
+
+type CapInterchain string
+
+const (
+	TransferSwap   CapInterchain = "transfer/swap"
+	TransferSend   CapInterchain = "transfer/send"
+	TransferAtomic CapInterchain = "transfer/atomic"
+	TransferBatch  CapInterchain = "transfer/batch"
+	TransferP2p    CapInterchain = "transfer/p2p"
+)
+
+// String returns the string representation of CapInterchain
+func (rcv CapInterchain) String() string {
+	return string(rcv)
+}
+
+var _ encoding.BinaryUnmarshaler = new(CapInterchain)
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler for CapInterchain.
+func (rcv *CapInterchain) UnmarshalBinary(data []byte) error {
+	switch str := string(data); str {
+	case "transfer/swap":
+		*rcv = TransferSwap
+	case "transfer/send":
+		*rcv = TransferSend
+	case "transfer/atomic":
+		*rcv = TransferAtomic
+	case "transfer/batch":
+		*rcv = TransferBatch
+	case "transfer/p2p":
+		*rcv = TransferP2p
+	default:
+		return fmt.Errorf(`illegal: "%s" is not a valid CapInterchain`, str)
+	}
+	return nil
+}

internal/crypto/ucan/attns/capinterchain/caps.go

@@ -0,0 +1,11 @@
+package capinterchain
+
+import "github.com/onsonr/sonr/internal/crypto/ucan"
+
+func NewCap(ty CapInterchain) ucan.Capability {
+	return ucan.Capability(ty)
+}
+
+func (c CapInterchain) Contains(b ucan.Capability) bool {
+	return c.String() == b.String()
+}

internal/crypto/ucan/attns/capvault/CapVault.pkl.go

@@ -0,0 +1,49 @@
+// Code generated from Pkl module `sonr.orm.UCAN`. DO NOT EDIT.
+package capvault
+
+import (
+	"encoding"
+	"fmt"
+)
+
+type CapVault string
+
+const (
+	CrudAsset      CapVault = "crud/asset"
+	CrudAuthzgrant CapVault = "crud/authzgrant"
+	CrudProfile    CapVault = "crud/profile"
+	CrudRecord     CapVault = "crud/record"
+	UseRecovery    CapVault = "use/recovery"
+	UseSync        CapVault = "use/sync"
+	UseSigner      CapVault = "use/signer"
+)
+
+// String returns the string representation of CapVault
+func (rcv CapVault) String() string {
+	return string(rcv)
+}
+
+var _ encoding.BinaryUnmarshaler = new(CapVault)
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler for CapVault.
+func (rcv *CapVault) UnmarshalBinary(data []byte) error {
+	switch str := string(data); str {
+	case "crud/asset":
+		*rcv = CrudAsset
+	case "crud/authzgrant":
+		*rcv = CrudAuthzgrant
+	case "crud/profile":
+		*rcv = CrudProfile
+	case "crud/record":
+		*rcv = CrudRecord
+	case "use/recovery":
+		*rcv = UseRecovery
+	case "use/sync":
+		*rcv = UseSync
+	case "use/signer":
+		*rcv = UseSigner
+	default:
+		return fmt.Errorf(`illegal: "%s" is not a valid CapVault`, str)
+	}
+	return nil
+}

internal/crypto/ucan/attns/capvault/caps.go

@@ -0,0 +1,11 @@
+package capvault
+
+import "github.com/onsonr/sonr/internal/crypto/ucan"
+
+func NewCap(ty CapVault) ucan.Capability {
+	return ucan.Capability(ty)
+}
+
+func (c CapVault) Contains(b ucan.Capability) bool {
+	return c.String() == b.String()
+}

internal/crypto/ucan/attns/exports.go

@@ -0,0 +1,114 @@
+// Package attns implements the UCAN resource and capability types
+package attns
+
+import (
+	"github.com/onsonr/sonr/internal/crypto/ucan"
+	"github.com/onsonr/sonr/internal/crypto/ucan/attns/capaccount"
+	"github.com/onsonr/sonr/internal/crypto/ucan/attns/capinterchain"
+	"github.com/onsonr/sonr/internal/crypto/ucan/attns/capvault"
+	"github.com/onsonr/sonr/internal/crypto/ucan/attns/resaccount"
+	"github.com/onsonr/sonr/internal/crypto/ucan/attns/resinterchain"
+	"github.com/onsonr/sonr/internal/crypto/ucan/attns/resvault"
+)
+
+// Capability hierarchy for sonr network
+// -------------------------------------
+// VAULT (DWN)
+//
+//	└─ CRUD/ASSET
+//	└─ CRUD/AUTHZGRANT
+//	└─ CRUD/PROFILE
+//	└─ CRUD/RECORD
+//	└─ USE/RECOVERY
+//	└─ USE/SYNC
+//	└─ USE/SIGNER
+//
+// ACCOUNT (DID)
+//
+//	└─ EXEC/BROADCAST
+//	└─ EXEC/QUERY
+//	└─ EXEC/SIMULATE
+//	└─ EXEC/VOTE
+//	└─ EXEC/DELEGATE
+//	└─ EXEC/INVOKE
+//	└─ EXEC/SEND
+//
+// INTERCHAIN
+//
+//	└─ TRANSFER/SWAP
+//	└─ TRANSFER/SEND
+//	└─ TRANSFER/ATOMIC
+//	└─ TRANSFER/BATCH
+//	└─ TRANSFER/P2P
+//	└─ TRANSFER/SEND
+
+type Capability string
+
+const (
+	CapExecBroadcast = capaccount.ExecBroadcast
+	CapExecQuery     = capaccount.ExecQuery
+	CapExecSimulate  = capaccount.ExecSimulate
+	CapExecVote      = capaccount.ExecVote
+	CapExecDelegate  = capaccount.ExecDelegate
+	CapExecInvoke    = capaccount.ExecInvoke
+	CapExecSend      = capaccount.ExecSend
+
+	CapTransferSwap   = capinterchain.TransferSwap
+	CapTransferSend   = capinterchain.TransferSend
+	CapTransferAtomic = capinterchain.TransferAtomic
+	CapTransferBatch  = capinterchain.TransferBatch
+	CapTransferP2P    = capinterchain.TransferP2p
+
+	CapCrudAsset      = capvault.CrudAsset
+	CapCrudAuthzgrant = capvault.CrudAuthzgrant
+	CapCrudProfile    = capvault.CrudProfile
+	CapCrudRecord     = capvault.CrudRecord
+	CapUseRecovery    = capvault.UseRecovery
+	CapUseSync        = capvault.UseSync
+	CapUseSigner      = capvault.UseSigner
+)
+
+type NewCapFunc func(string) ucan.Capability
+
+type BuildResourceFunc func(string, string) ucan.Resource
+
+func CreateArray(attns ...ucan.Attenuation) ucan.Attenuations {
+	return ucan.Attenuations(attns)
+}
+
+func New(cap ucan.Capability, rsc ucan.Resource) ucan.Attenuation {
+	return ucan.Attenuation{
+		Cap: cap,
+		Rsc: rsc,
+	}
+}
+
+// NewAccountCap creates a new account capability
+func NewAccountCap(ty capaccount.CapAccount) ucan.Capability {
+	return capaccount.NewCap(ty)
+}
+
+// NewInterchainCap creates a new interchain capability
+func NewInterchainCap(ty capinterchain.CapInterchain) ucan.Capability {
+	return capinterchain.NewCap(ty)
+}
+
+// NewVaultCap creates a new vault capability
+func NewVaultCap(ty capvault.CapVault) ucan.Capability {
+	return capvault.NewCap(ty)
+}
+
+// BuildAccountResource creates a new account resource
+func BuildAccountResource(ty resaccount.ResAccount, value string) ucan.Resource {
+	return resaccount.Build(ty, value)
+}
+
+// BuildInterchainResource creates a new interchain resource
+func BuildInterchainResource(ty resinterchain.ResInterchain, value string) ucan.Resource {
+	return resinterchain.Build(ty, value)
+}
+
+// BuildVaultResource creates a new vault resource
+func BuildVaultResource(ty resvault.ResVault, value string) ucan.Resource {
+	return resvault.Build(ty, value)
+}

internal/crypto/ucan/attns/init.pkl.go

@@ -0,0 +1,8 @@
+// Code generated from Pkl module `sonr.orm.UCAN`. DO NOT EDIT.
+package attns
+
+import "github.com/apple/pkl-go/pkl"
+
+func init() {
+	pkl.RegisterMapping("sonr.orm.UCAN", UCAN{})
+}

internal/crypto/ucan/attns/resaccount/ResAccount.pkl.go

@@ -0,0 +1,43 @@
+// Code generated from Pkl module `sonr.orm.UCAN`. DO NOT EDIT.
+package resaccount
+
+import (
+	"encoding"
+	"fmt"
+)
+
+type ResAccount string
+
+const (
+	AccSequence ResAccount = "acc/sequence"
+	AccNumber   ResAccount = "acc/number"
+	ChainId     ResAccount = "chain/id"
+	AssetCode   ResAccount = "asset/code"
+	AuthzGrant  ResAccount = "authz/grant"
+)
+
+// String returns the string representation of ResAccount
+func (rcv ResAccount) String() string {
+	return string(rcv)
+}
+
+var _ encoding.BinaryUnmarshaler = new(ResAccount)
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler for ResAccount.
+func (rcv *ResAccount) UnmarshalBinary(data []byte) error {
+	switch str := string(data); str {
+	case "acc/sequence":
+		*rcv = AccSequence
+	case "acc/number":
+		*rcv = AccNumber
+	case "chain/id":
+		*rcv = ChainId
+	case "asset/code":
+		*rcv = AssetCode
+	case "authz/grant":
+		*rcv = AuthzGrant
+	default:
+		return fmt.Errorf(`illegal: "%s" is not a valid ResAccount`, str)
+	}
+	return nil
+}

internal/crypto/ucan/attns/resaccount/resource.go

@@ -0,0 +1,33 @@
+package resaccount
+
+import "github.com/onsonr/sonr/internal/crypto/ucan"
+
+func Build(ty ResAccount, value string) ucan.Resource {
+	return newStringLengthResource(ty.String(), value)
+}
+
+type stringLengthRsc struct {
+	t string
+	v string
+}
+
+// NewStringLengthResource is a silly implementation of resource to use while
+// I figure out what an OR filter on strings is. Don't use this.
+func newStringLengthResource(typ, val string) ucan.Resource {
+	return stringLengthRsc{
+		t: typ,
+		v: val,
+	}
+}
+
+func (r stringLengthRsc) Type() string {
+	return r.t
+}
+
+func (r stringLengthRsc) Value() string {
+	return r.v
+}
+
+func (r stringLengthRsc) Contains(b ucan.Resource) bool {
+	return r.Type() == b.Type() && len(r.Value()) <= len(b.Value())
+}

internal/crypto/ucan/attns/resinterchain/ResInterchain.pkl.go

@@ -0,0 +1,43 @@
+// Code generated from Pkl module `sonr.orm.UCAN`. DO NOT EDIT.
+package resinterchain
+
+import (
+	"encoding"
+	"fmt"
+)
+
+type ResInterchain string
+
+const (
+	ChannnelPort  ResInterchain = "channnel/port"
+	ChainId       ResInterchain = "chain/id"
+	ChainName     ResInterchain = "chain/name"
+	AccHost       ResInterchain = "acc/host"
+	AccController ResInterchain = "acc/controller"
+)
+
+// String returns the string representation of ResInterchain
+func (rcv ResInterchain) String() string {
+	return string(rcv)
+}
+
+var _ encoding.BinaryUnmarshaler = new(ResInterchain)
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler for ResInterchain.
+func (rcv *ResInterchain) UnmarshalBinary(data []byte) error {
+	switch str := string(data); str {
+	case "channnel/port":
+		*rcv = ChannnelPort
+	case "chain/id":
+		*rcv = ChainId
+	case "chain/name":
+		*rcv = ChainName
+	case "acc/host":
+		*rcv = AccHost
+	case "acc/controller":
+		*rcv = AccController
+	default:
+		return fmt.Errorf(`illegal: "%s" is not a valid ResInterchain`, str)
+	}
+	return nil
+}

internal/crypto/ucan/attns/resinterchain/resource.go

@@ -0,0 +1,33 @@
+package resinterchain
+
+import "github.com/onsonr/sonr/internal/crypto/ucan"
+
+func Build(ty ResInterchain, value string) ucan.Resource {
+	return newStringLengthResource(ty.String(), value)
+}
+
+type stringLengthRsc struct {
+	t string
+	v string
+}
+
+// NewStringLengthResource is a silly implementation of resource to use while
+// I figure out what an OR filter on strings is. Don't use this.
+func newStringLengthResource(typ, val string) ucan.Resource {
+	return stringLengthRsc{
+		t: typ,
+		v: val,
+	}
+}
+
+func (r stringLengthRsc) Type() string {
+	return r.t
+}
+
+func (r stringLengthRsc) Value() string {
+	return r.v
+}
+
+func (r stringLengthRsc) Contains(b ucan.Resource) bool {
+	return r.Type() == b.Type() && len(r.Value()) <= len(b.Value())
+}

internal/crypto/ucan/attns/resvault/ResVault.pkl.go

@@ -0,0 +1,46 @@
+// Code generated from Pkl module `sonr.orm.UCAN`. DO NOT EDIT.
+package resvault
+
+import (
+	"encoding"
+	"fmt"
+)
+
+type ResVault string
+
+const (
+	KsEnclave ResVault = "ks/enclave"
+	LocCid    ResVault = "loc/cid"
+	LocEntity ResVault = "loc/entity"
+	LocIpns   ResVault = "loc/ipns"
+	AddrSonr  ResVault = "addr/sonr"
+	ChainCode ResVault = "chain/code"
+)
+
+// String returns the string representation of ResVault
+func (rcv ResVault) String() string {
+	return string(rcv)
+}
+
+var _ encoding.BinaryUnmarshaler = new(ResVault)
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler for ResVault.
+func (rcv *ResVault) UnmarshalBinary(data []byte) error {
+	switch str := string(data); str {
+	case "ks/enclave":
+		*rcv = KsEnclave
+	case "loc/cid":
+		*rcv = LocCid
+	case "loc/entity":
+		*rcv = LocEntity
+	case "loc/ipns":
+		*rcv = LocIpns
+	case "addr/sonr":
+		*rcv = AddrSonr
+	case "chain/code":
+		*rcv = ChainCode
+	default:
+		return fmt.Errorf(`illegal: "%s" is not a valid ResVault`, str)
+	}
+	return nil
+}

internal/crypto/ucan/attns/resvault/resource.go

@@ -0,0 +1,33 @@
+package resvault
+
+import "github.com/onsonr/sonr/internal/crypto/ucan"
+
+func Build(ty ResVault, value string) ucan.Resource {
+	return newStringLengthResource(ty.String(), value)
+}
+
+type stringLengthRsc struct {
+	t string
+	v string
+}
+
+// NewStringLengthResource is a silly implementation of resource to use while
+// I figure out what an OR filter on strings is. Don't use this.
+func newStringLengthResource(typ, val string) ucan.Resource {
+	return stringLengthRsc{
+		t: typ,
+		v: val,
+	}
+}
+
+func (r stringLengthRsc) Type() string {
+	return r.t
+}
+
+func (r stringLengthRsc) Value() string {
+	return r.v
+}
+
+func (r stringLengthRsc) Contains(b ucan.Resource) bool {
+	return r.Type() == b.Type() && len(r.Value()) <= len(b.Value())
+}