core

Documentation

Index

• type DID
• type DIDDoc
• type Destination
• type DidComm
• type Doc
• type Factor
• type In
• type Method
• type MyDID
• type Out
• type Pairwise
• type PairwiseMeta
• type Pipe
• type Resolver
• type TheirDID

Types

type DID

type DID interface {
	DOC() DIDDoc
	NewDoc(ae service.Addr) DIDDoc

	KID() string // same as Did() TODO: get rid of another

	// Did is method specific function. Old methods like 'did:sov:' return plain
	// old did string. NOTE! If they need whole stuff they must use URI.
	// NOTE! New method versions can use this or URI the result is same.
	Did() string // this is alias for KID() TODO: remove when done with ssi.DID

	StartEndp(storageH managed.Wallet, connectionID string)
	Store(mgdWallet, mgdStorage managed.Wallet)
	SavePairwiseForDID(mStorage managed.Wallet, theirDID DID, pw PairwiseMeta)
	StoreResult() error
	AEndp() (ae service.Addr, err error)
	SetAEndp(ae service.Addr)

	Route() []string         // this useful for new did methods as well
	RecipientKeys() []string // this useful for new did methods as well

	String() string // Implementation (key, peer,...) specific behaviour
	SignKey() any
	Packager() api.Packager

	// TODO: this is mainly for indy but could be merged with SignKey?
	VerKey() string

	Storage() managed.Wallet

	URI() string // real URI, currently used in did doc

}

type DIDDoc

type DIDDoc interface {
	json.Marshaler
	json.Unmarshaler
}

type Destination

type Destination struct {
}

type DidComm

type DidComm interface {
	Did() string
}

type Doc

type Doc interface {
	json.Marshaler
	json.Unmarshaler

	NeededOhterFunctions()
}

Doc is DIDDoc interface used as a field in DIDComm messages and by its own.

type Factor

type Factor interface {
}

type In

type In interface {
	Out

	// TODO: these seem to be found from did doc
	Wallet() int
}

type Method

type Method interface {
}

type MyDID

type MyDID interface {
	DID

	// this won't work because wen can be both: receiver and sender
	Pack(d []byte) ([]byte, error)
}

type Out

type Out interface {
	DidComm

	// TODO: these seem to be found from did doc
	VerKey() string
	Route() []string
	Endpoint() string
}

type Pairwise

type Pairwise interface {
	ID() string // DID? Could this be a DID?

	TheirDID() TheirDID
	MyDID() MyDID
}

type PairwiseMeta

type PairwiseMeta struct {
	Name  string
	Route []string
}

type Pipe

type Pipe interface {
	Pack(src []byte) (dst []byte, vk string, err error)
	Unpack(src []byte) (dst []byte, vk string, err error)

	// TODO: do we really need this? propably not when we start to use interface,
	// this was for value object (struct)
	IsNull() bool
}

type Resolver

type Resolver interface {
	Resolve(id DID) DIDDoc
}

type TheirDID

type TheirDID interface {
	DID

	// this won't work because wen can be both: receiver and sender
	Unpack(d []byte) ([]byte, error)

	// these things could work, all everything with cryptos could
	Verify() error
}