Merge pull request #1554 from lightninglabs/wip/1534-ignore-tree/1534-add-ignoreasset-rpc

RPC: Add Ignore Tree Endpoints

Author: Roasbeef

asset/asset.go

@@ -55,6 +55,22 @@ const (
 // compressed, 33-byte form.
 type SerializedKey [33]byte
 
+// NewSerializedKeyFromBytes creates a new SerializedKey from the given byte
+// slice.
+func NewSerializedKeyFromBytes(key []byte) (SerializedKey, error) {
+	var zero SerializedKey
+
+	// Ensure that the key is a valid public key.
+	if _, err := btcec.ParsePubKey(key); err != nil {
+		return zero, fmt.Errorf("invalid public key: %w", err)
+	}
+
+	var serialized SerializedKey
+	copy(serialized[:], key)
+
+	return serialized, nil
+}
+
 // ToPubKey returns the public key parsed from the serialized key.
 func (s SerializedKey) ToPubKey() (*btcec.PublicKey, error) {
 	return btcec.ParsePubKey(s[:])
@@ -74,6 +90,11 @@ func (s SerializedKey) CopyBytes() []byte {
 	return c
 }
 
+// String returns the hex-encoded string representation of the serialized key.
+func (s SerializedKey) String() string {
+	return hex.EncodeToString(s[:])
+}
+
 // ToSerialized serializes a public key in its 33-byte compressed form.
 func ToSerialized(pubKey *btcec.PublicKey) SerializedKey {
 	var serialized SerializedKey
@@ -330,6 +351,23 @@ func (g Genesis) TagHash() [sha256.Size]byte {
 //	  outputIndex || assetType)
 type ID [sha256.Size]byte
 
+// NewIDFromBytes creates a new ID from the given byte slice. The byte slice
+// must be exactly 32 bytes long, otherwise an error is returned.
+func NewIDFromBytes(id []byte) (ID, error) {
+	var zero ID
+
+	// Basic sanity check to ensure the ID is the correct length.
+	if len(id) != sha256.Size {
+		return zero, fmt.Errorf("invalid ID length: %d", len(id))
+	}
+
+	// Copy the byte slice into a new ID instance.
+	var assetID ID
+	copy(assetID[:], id)
+
+	return assetID, nil
+}
+
 // String returns the hex-encoded string representation of the ID.
 func (i ID) String() string {
 	return hex.EncodeToString(i[:])
@@ -731,6 +769,10 @@ func (id PrevID) Hash() [sha256.Size]byte {
 	return *(*[sha256.Size]byte)(h.Sum(nil))
 }
 
+// AnchorPoint is a type alias for an asset anchor outpoint. It relates the
+// on-chain anchor outpoint (txid:vout) to the corresponding committed asset.
+type AnchorPoint = PrevID
+
 // SplitCommitment represents the asset witness for an asset split.
 type SplitCommitment struct {
 	// Proof is the proof for a particular asset split resulting from a

cmd/commands/universe.go

@@ -9,6 +9,7 @@ import (
 	tap "github.com/lightninglabs/taproot-assets"
 	"github.com/lightninglabs/taproot-assets/fn"
 	"github.com/lightninglabs/taproot-assets/proof"
+	"github.com/lightninglabs/taproot-assets/taprpc"
 	unirpc "github.com/lightninglabs/taproot-assets/taprpc/universerpc"
 	"github.com/lightninglabs/taproot-assets/universe"
 	"github.com/lightningnetwork/lnd/lncfg"
@@ -48,6 +49,7 @@ var universeCommands = []cli.Command{
 			universeFederationCommand,
 			universeInfoCommand,
 			universeStatsCommand,
+			universeSupplyCommitCommand,
 		},
 	},
 }
@@ -1503,3 +1505,212 @@ func universeEventStatsQueryCommand(ctx *cli.Context) error {
 	printRespJSON(resp)
 	return nil
 }
+
+var universeSupplyCommitCommand = cli.Command{
+	Name:      "supplycommit",
+	ShortName: "sc",
+	Usage:     "manage the supply commitment for a Universe",
+	Description: `
+	Manage the supply commitment for a Universe. The supply commitment
+	is a cryptographic commitment to the total supply of assets in a
+	Universe.
+	`,
+	Subcommands: []cli.Command{
+		ignoreAssetOutPointCmd,
+		updateSupplyCommitCmd,
+		fetchSupplyCommitCmd,
+	},
+}
+
+var ignoreAssetOutPointCmd = cli.Command{
+	Name:  "ignore",
+	Usage: "ignores an asset outpoint when committing to the asset supply",
+	Description: "This command allows us to ignore a specific asset UTXO " +
+		"when creating a new supply commitment. This is useful if " +
+		"an otherwise valid asset should not be counted towards the " +
+		"total asset group supply.",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name: "asset_anchor_point",
+			Usage: "the asset anchor point to ignore, specified " +
+				"as txid:vout",
+			Required: true,
+		},
+		&cli.StringFlag{
+			Name:     assetIDName,
+			Usage:    "the asset ID of the asset to ignore",
+			Required: true,
+		},
+		&cli.StringFlag{
+			Name:     scriptKeyName,
+			Usage:    "the script key of the asset to ignore",
+			Required: true,
+		},
+		&cli.Uint64Flag{
+			Name: "amount",
+			Usage: "the amount of the asset at the anchor " +
+				"outpoint",
+			Required: true,
+		},
+	},
+	Action: ignoreAssetOutPoint,
+}
+
+func ignoreAssetOutPoint(ctx *cli.Context) error {
+	cliCtx := getContext()
+	client, cleanUp := getUniverseClient(ctx)
+	defer cleanUp()
+
+	anchorPointStr := ctx.String("asset_anchor_point")
+
+	assetID, err := hex.DecodeString(ctx.String(assetIDName))
+	if err != nil {
+		return fmt.Errorf("invalid asset_id: %w", err)
+	}
+
+	scriptKey, err := hex.DecodeString(ctx.String(scriptKeyName))
+	if err != nil {
+		return fmt.Errorf("invalid script_key: %w", err)
+	}
+
+	req := &unirpc.IgnoreAssetOutPointRequest{
+		AssetOutPoint: &taprpc.AssetOutPoint{
+			AnchorOutPoint: anchorPointStr,
+			AssetId:        assetID,
+			ScriptKey:      scriptKey,
+		},
+		Amount: ctx.Uint64("amount"),
+	}
+
+	resp, err := client.IgnoreAssetOutPoint(cliCtx, req)
+	if err != nil {
+		return err
+	}
+
+	printJSON(resp)
+	return nil
+}
+
+var updateSupplyCommitCmd = cli.Command{
+	Name:  "update",
+	Usage: "updates the on-chain supply commitment for an asset group",
+	Description: "This command updates the on-chain supply " +
+		"commitment for a specific asset group.",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:     "group_key",
+			Usage:    "the group key of the asset group to update",
+			Required: true,
+		},
+	},
+	Action: updateSupplyCommit,
+}
+
+func updateSupplyCommit(ctx *cli.Context) error {
+	cliCtx := getContext()
+	client, cleanUp := getUniverseClient(ctx)
+	defer cleanUp()
+
+	req := &unirpc.UpdateSupplyCommitRequest{
+		GroupKey: &unirpc.UpdateSupplyCommitRequest_GroupKeyStr{
+			GroupKeyStr: ctx.String("group_key"),
+		},
+	}
+
+	resp, err := client.UpdateSupplyCommit(cliCtx, req)
+	if err != nil {
+		return err
+	}
+
+	printJSON(resp)
+	return nil
+}
+
+var fetchSupplyCommitCmd = cli.Command{
+	Name:  "fetch",
+	Usage: "fetches the on-chain supply commitment for an asset group",
+	Description: "This command fetches the on-chain supply " +
+		"commitment for a specific asset group.",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:     "group_key",
+			Usage:    "the group key of the asset group to fetch",
+			Required: true,
+		},
+		&cli.StringSliceFlag{
+			Name: "issuance_leaf_keys",
+			Usage: "a list of issuance leaf keys to fetch " +
+				"inclusion proofs for",
+		},
+		&cli.StringSliceFlag{
+			Name: "burn_leaf_keys",
+			Usage: "a list of burn leaf keys to fetch inclusion " +
+				"proofs for",
+		},
+		&cli.StringSliceFlag{
+			Name: "ignore_leaf_keys",
+			Usage: "a list of ignore leaf keys to fetch " +
+				"inclusion proofs for",
+		},
+	},
+	Action: fetchSupplyCommit,
+}
+
+func fetchSupplyCommit(ctx *cli.Context) error {
+	cliCtx := getContext()
+	client, cleanUp := getUniverseClient(ctx)
+	defer cleanUp()
+
+	req := &unirpc.FetchSupplyCommitRequest{
+		GroupKey: &unirpc.FetchSupplyCommitRequest_GroupKeyStr{
+			GroupKeyStr: ctx.String("group_key"),
+		},
+	}
+
+	issuanceKeys, err := parseHexStrings(
+		ctx.StringSlice("issuance_leaf_keys"),
+	)
+	if err != nil {
+		return fmt.Errorf("invalid issuance_leaf_keys: %w", err)
+	}
+	req.IssuanceLeafKeys = issuanceKeys
+
+	burnKeys, err := parseHexStrings(ctx.StringSlice("burn_leaf_keys"))
+	if err != nil {
+		return fmt.Errorf("invalid burn_leaf_keys: %w", err)
+	}
+	req.BurnLeafKeys = burnKeys
+
+	ignoreKeys, err := parseHexStrings(ctx.StringSlice("ignore_leaf_keys"))
+	if err != nil {
+		return fmt.Errorf("invalid ignore_leaf_keys: %w", err)
+	}
+	req.IgnoreLeafKeys = ignoreKeys
+
+	resp, err := client.FetchSupplyCommit(cliCtx, req)
+	if err != nil {
+		return err
+	}
+
+	printJSON(resp)
+	return nil
+}
+
+// parseHexStrings converts a slice of hex-encoded strings into a slice of byte
+// slices. Each string in hexStrings must be a valid hex representation, or an
+// error is returned.
+func parseHexStrings(hexStrings []string) ([][]byte, error) {
+	result := make([][]byte, len(hexStrings))
+
+	for i, hexStr := range hexStrings {
+		decoded, err := hex.DecodeString(hexStr)
+		if err != nil {
+			return nil, fmt.Errorf("invalid hex string %q: %w",
+				hexStr, err)
+		}
+
+		result[i] = decoded
+	}
+
+	return result, nil
+}

internal/test/mock.go

@@ -37,7 +37,11 @@ type MockSigner struct {
 
 	SignOutputRawChannel chan SignOutputRawRequest
 
-	Signature    []byte
+	Signature []byte
+
+	// SignMessageErr holds the error returned by SignMessage, if any.
+	SignMessageErr error
+
 	SignatureMsg string
 }
 
@@ -66,6 +70,10 @@ func (s *MockSigner) SignMessage(_ context.Context, _ []byte,
 	_ keychain.KeyLocator, _ ...lndclient.SignMessageOption) ([]byte,
 	error) {
 
+	if s.SignMessageErr != nil {
+		return nil, s.SignMessageErr
+	}
+
 	return s.Signature, nil
 }
 

itest/psbt_test.go

@@ -3619,10 +3619,19 @@ func sendToTapscriptAddr(ctx context.Context, t *harnessTest, alice,
 	AssertSendEventsComplete(t.t, bobAddr.ScriptKey, sendEvents)
 }
 
+// sendAssetAndAssertResponse is a struct that holds the response of a
+// sendAssetsToAddr call.
+type sendAssetAndAssertResponse struct {
+	// RpcResp is the response message returned by the SendAsset RPC
+	// endpoint.
+	RpcResp *taprpc.SendAssetResponse
+}
+
 func sendAssetAndAssert(ctx context.Context, t *harnessTest, alice,
 	bob *tapdHarness, numUnits, change uint64,
 	genInfo *taprpc.GenesisInfo, mintedAsset *taprpc.Asset,
-	outTransferIdx, numOutTransfers, numInTransfers int) {
+	outTransferIdx, numOutTransfers,
+	numInTransfers int) sendAssetAndAssertResponse {
 
 	// And finally, we make sure that we can send out one of the asset UTXOs
 	// that shared the anchor output and the other one is treated as a
@@ -3645,6 +3654,10 @@ func sendAssetAndAssert(ctx context.Context, t *harnessTest, alice,
 	// appear in that RPC output).
 	AssertNonInteractiveRecvComplete(t.t, bob, numInTransfers)
 	AssertSendEventsComplete(t.t, bobAddr.ScriptKey, sendEvents)
+
+	return sendAssetAndAssertResponse{
+		RpcResp: sendResp,
+	}
 }
 
 func signPacket(t *testing.T, lnd *node.HarnessNode,