127 lines
3.1 KiB
Go
127 lines
3.1 KiB
Go
package client
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"iter"
|
|
|
|
"code.sonr.org/go/did-it"
|
|
"code.sonr.org/go/did-it/crypto"
|
|
"github.com/ipfs/go-cid"
|
|
|
|
"code.sonr.org/go/ucan/pkg/command"
|
|
"code.sonr.org/go/ucan/pkg/container"
|
|
"code.sonr.org/go/ucan/pkg/policy"
|
|
"code.sonr.org/go/ucan/token/delegation"
|
|
"code.sonr.org/go/ucan/token/invocation"
|
|
)
|
|
|
|
type Client struct {
|
|
did did.DID
|
|
privKey crypto.PrivateKeySigningBytes
|
|
|
|
pool *Pool
|
|
requester DelegationRequester
|
|
}
|
|
|
|
func NewClient(privKey crypto.PrivateKeySigningBytes, d did.DID, requester DelegationRequester) (*Client, error) {
|
|
return &Client{
|
|
did: d,
|
|
privKey: privKey,
|
|
pool: NewPool(),
|
|
requester: requester,
|
|
}, nil
|
|
}
|
|
|
|
// AddBundle adds a delegation.Bundle to the client's pool.
|
|
func (c *Client) AddBundle(bundle *delegation.Bundle) {
|
|
c.pool.AddBundle(bundle)
|
|
}
|
|
|
|
// AddBundles adds a sequence of delegation.Bundles to the client's pool.
|
|
func (c *Client) AddBundles(bundles iter.Seq[*delegation.Bundle]) {
|
|
c.pool.AddBundles(bundles)
|
|
}
|
|
|
|
// PrepareInvoke returns an invocation, bundled in a container.Writer with the necessary proofs.
|
|
func (c *Client) PrepareInvoke(ctx context.Context, cmd command.Command, subject did.DID, opts ...invocation.Option) (container.Writer, error) {
|
|
proof, err := c.findProof(ctx, cmd, subject)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
inv, err := invocation.New(c.did, cmd, subject, proof, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
invSealed, _, err := inv.ToSealed(c.privKey)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
cont := container.NewWriter()
|
|
cont.AddSealed(invSealed)
|
|
for bundle, err := range c.pool.GetBundles(proof) {
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
cont.AddSealed(bundle.Sealed)
|
|
}
|
|
|
|
return cont, nil
|
|
}
|
|
|
|
// PrepareDelegation returns a new delegation for a third party DID, bundled in a container.Writer with the necessary proofs.
|
|
func (c *Client) PrepareDelegation(ctx context.Context, aud did.DID, cmd command.Command, subject did.DID, policies policy.Policy, opts ...delegation.Option) (container.Writer, error) {
|
|
proof, err := c.findProof(ctx, cmd, subject)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
dlg, err := delegation.New(c.did, aud, cmd, policies, subject, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
dlgSealed, _, err := dlg.ToSealed(c.privKey)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
cont := container.NewWriter()
|
|
cont.AddSealed(dlgSealed)
|
|
for bundle, err := range c.pool.GetBundles(proof) {
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
cont.AddSealed(bundle.Sealed)
|
|
}
|
|
|
|
return cont, nil
|
|
}
|
|
|
|
func (c *Client) findProof(ctx context.Context, cmd command.Command, subject did.DID) ([]cid.Cid, error) {
|
|
var proof []cid.Cid
|
|
|
|
// do we already have a valid proof?
|
|
if proof = c.pool.FindProof(c.did, cmd, subject); len(proof) == 0 {
|
|
// we need to request a new proof
|
|
proofBundles, err := c.requester.RequestDelegation(ctx, c.did, cmd, subject)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("requesting delegation: %w", err)
|
|
}
|
|
|
|
// cache the new proofs
|
|
for bundle, err := range proofBundles {
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
proof = append(proof, bundle.Cid)
|
|
c.pool.AddBundle(bundle)
|
|
}
|
|
}
|
|
|
|
return proof, nil
|
|
}
|