taprootassets

package module
v0.7.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 18, 2025 License: MIT Imports: 101 Imported by: 2

README

Taproot Assets

The Taproot Assets Daemon tapd implements the Taproot Assets Protocol for issuing assets on the Bitcoin blockchain. Taproot Assets leverage Taproot transactions to commit to newly created assets and their transfers in an efficient and scalable manner. Multiple assets can be created and transferred in a single bitcoin UTXO, while witness data is transacted and stored off-chain.

Features:

  • Mint and burn assets
  • Synchronize to universes
  • Send and receive assets
  • Export and import Taproot Asset proofs
  • Create and manage CLI profiles

How it works:

When minting a new asset, Taproot Assets will generate the relevant witness data, assign the asset to a key held by you and publish the corresponding bitcoin UTXO -- the minting transaction.

The outpoint this minting transaction consumes becomes the genesis_point of the newly minted asset, acting as its unique identifier. Assets can be spent to a new recipient, who provides the sender with the necessary information encoded in their Taproot Asset address.

To transact assets, the witnesses in the prior transaction are recommitted into one or multiple taproot outputs while the necessary witness data is passed to the recipient. Similar to bitcoin transactions, the remaining balance is spent back to the sender as a change output.

Learn more about the Taproot Assets Protocol.

Architecture:

Taproot Assets are implemented as the Taproot Assets Daemon tapd and the Taproot Assets Command Line Interface tapcli. Additionally, tapd exposes a GRPC interface to allow for a direct integration into applications.

Taproot Assets leverage several LND features including the Taproot wallet and signing capabilities. These facilities are accessed through LND’s GRPC.

The Taproot Assets stack:

Bitcoin blockchain backend <-> LND <-> Taproot Assets

Custody of Taproot Assets is segmented across LND and Tapd to maximize security. LND holds the private key, which has had a taproot tweak applied to it, controlling the bitcoin UTXO holding the Taproot Asset. The taproot tweak on the other hand is held by Tapd. This increases the requirements for asset recovery as both the internal key as well as the taproot tweak are necessary to spend the output. This prevents LND from accidentally burning Taproot assets.

Prerequisites:

Taproot Assets require LND version v0.16.2-beta or later to be synced and running on the same Bitcoin network as Taproot Assets (e.g. regtest, simnet, testnet3). RPC connections need to be accepted and a valid macaroon needs to be present.

git clone https://github.com/lightningnetwork/lnd.git
cd lnd 
make install tags="signrpc walletrpc chainrpc invoicesrpc"

Installation:

From source:

Compile Taproot Assets from source by cloning this repository. Go version 1.19 or higher is required.

git clone --recurse-submodules https://github.com/lightninglabs/taproot-assets.git
cd taproot-assets
make install

Initialization:

Run Taproot Assets with the command tapd. Specify how Taproot Assets can reach LND and what network to run Tapd with by passing it additional flags. The Bitcoin backend and LND need to be running and synced before the Taproot Assets daemon can be started.

tapd --network=testnet --debuglevel=debug --lnd.host=localhost:10009 --lnd.macaroonpath=~/.lnd/data/chain/bitcoin/testnet/admin.macaroon --lnd.tlspath=~/.lnd/tls.cert

Usage:

See a full list of options by executing:

tapd --help

Use tapcli to interact with tapd

tapcli assets mint --type normal --name fantasycoin --supply 100 --meta_bytes "fantastic money"
tapcli assets mint finalize

tapcli assets list

Synchronize yourself with a universe, for example the one running as part of the issuer's tapd.

tapcli universe sync --universe_host testnet.universe.lightning.finance

Add multiple universes to your local federation to always stay up to date. You can also use the universe to query existing assets and their metadata. You may also configure your tapd instance to listen to incoming requests with --rpclisten 0.0.0.0:10029 to run your own universe.

tapcli universe federation add --universe_host testnet.universe.lightning.finance
tapcli universe roots

Once you have obtained the necessary proofs and asset IDs, you can generate a Taproot Asset address for a specific asset and amount.

tapcli addrs new --asset_id bab08407[...]129bf6d0 --amt 21

The sender can now fulfill the request by initiating the transfer.

tapcli assets send --addr taptb1q[...]tywpre3a

Development

API

Taproot Assets exposes a GRPC (port 10029) and a REST (port 8089) API. Connections are encrypted with TLS and authenticated using macaroons. The API is documented here. Further guides can be found here.

Mainnet

Starting with the release of version v0.3.0 the daemon does support the Bitcoin mainnet.

IMPORTANT NOTE: To avoid loss of funds, it's imperative that you read the Operational Safety Guidelines before using tapd on mainnet!

The daemon is still in alpha state, which means there can still be bugs and not all desired data safety and backup mechanisms have been implemented yet. Releasing on mainnet mainly signals that there will be no breaking changes in the future and that assets minted with v0.3.0 will be compatible with later versions.

Important note for Umbrel/Lightning Terminal users

DO NOT UNDER ANY CIRCUMSTANCE uninstall (or re-install) the "Lightning Terminal" app without first making a manual backup of all local tapd data, if you are using Taproot Assets as part of the "Lightning Terminal" app with Umbrel -- or any comparable node-in-a-box solution. Uninstalling Umbrel apps deletes application data. This Taproot Assets application data encumbers Taproot Assets AND bitcoin funds. Receiving and sending tapd assets updates the daemon's funds-custody material. Merely having the lnd seed phrase is NOT enough to restore assets minted or received. WITHOUT BACKUP BEFORE DELETION, FUNDS ARE DESTROYED.

RFQ, asset decimal display, unit precision and price oracle

Everything related to the RFQ (Request For Quote) system, the asset's currency precision (decimal display) and the RFQ price oracle can be found in this document.

Submit feature requests

The GitHub issue tracker can be used to request specific improvements or report bugs.

Join us on Slack

Join us in the Lightning Labs Slack and join the #taproot-assets channel to ask questions and interact with the community.

Documentation

Index

Constants

View Source 
const (
	// AppMajor defines the major version of this binary.
	AppMajor uint = 0

	// AppMinor defines the minor version of this binary.
	AppMinor uint = 7

	// AppPatch defines the application patch for this binary.
	AppPatch uint = 0

	// AppStatus defines the release status of this binary (e.g. beta).
	AppStatus = "alpha"

	// AppPreRelease defines the pre-release version of this binary.
	// It MUST only contain characters from the semantic versioning spec.
	AppPreRelease = ""

	// GitTagIncludeStatus indicates whether the status should be included
	// in the git tag name.
	//
	// Including the app version status in the git tag may be problematic
	// for golang projects when importing them as dependencies. We therefore
	// include this flag to allow toggling the status on and off in a
	// standardised way across our projects.
	GitTagIncludeStatus = false
)

These constants define the application version and follow the semantic versioning 2.0.0 spec (http://semver.org/).

View Source 
const (

	// AssetBurnConfirmationText is the text that needs to be set on the
	// RPC to confirm an asset burn.
	AssetBurnConfirmationText = "assets will be destroyed"
)

Variables

View Source 
var (
	// MaxMsgReceiveSize is the largest message our client will receive. We
	// set this to 200MiB atm.
	MaxMsgReceiveSize = grpc.MaxCallRecvMsgSize(lnrpc.MaxGrpcMsgSize)

	// ServerMaxMsgReceiveSize is the largest message our server will
	// receive.
	ServerMaxMsgReceiveSize = grpc.MaxRecvMsgSize(lnrpc.MaxGrpcMsgSize)

	// P2TRChangeType is the type of change address that should be used for
	// funding PSBTs, as we'll always want to use P2TR change addresses.
	P2TRChangeType = walletrpc.ChangeAddressType_CHANGE_ADDRESS_TYPE_P2TR
)
View Source 
var (
	// Commit stores the current commit of this build, which includes the
	// most recent tag, the number of commits since that tag (if non-zero),
	// the commit hash, and a dirty marker. This should be set using the
	// -ldflags during compilation.
	Commit string

	// CommitHash stores the current commit hash of this build.
	CommitHash string

	// RawTags contains the raw set of build tags, separated by commas.
	RawTags string

	// GoVersion stores the go version that the executable was compiled
	// with.
	GoVersion string
)

Functions

func AddSubLogger 

func AddSubLogger(root *build.SubLoggerManager, subsystem string,
	interceptor signal.Interceptor, useLoggers ...func(btclog.Logger))

AddSubLogger is a helper method to conveniently create and register the logger of one or more sub systems.

func CheckFederationServer added in v0.2.1 

func CheckFederationServer(localRuntimeID int64, connectTimeout time.Duration,
	server universe.ServerAddr) error

CheckFederationServer attempts to connect to the target server and ensure that it is a valid federation server that isn't the local daemon.

func ConnectUniverse added in v0.2.1 

func ConnectUniverse(
	serverAddr universe.ServerAddr) (*universeClientConn, error)

ConnectUniverse connects to a remote Universe server using the provided server address.

func MarshalAssetFedSyncCfg added in v0.3.0 

func MarshalAssetFedSyncCfg(
	config universe.FedUniSyncConfig) (*unirpc.AssetFederationSyncConfig,
	error)

MarshalAssetFedSyncCfg returns an RPC ready asset specific federation sync config.

func MarshalUniID added in v0.3.0 

func MarshalUniID(id universe.Identifier) (*unirpc.ID, error)

MarshalUniID marshals the universe ID into the RPC counterpart.

func MarshalUniProofType added in v0.3.0 

func MarshalUniProofType(
	proofType universe.ProofType) (unirpc.ProofType, error)

MarshalUniProofType marshals the universe proof type into the RPC counterpart.

func NewRpcSupplySync added in v0.7.0 

func NewRpcSupplySync(
	serverAddr universe.ServerAddr) (supplyverifier.UniverseClient, error)

NewRpcSupplySync creates a new RpcSupplySync instance that dials out to the target remote universe server address.

func NewRpcUniverseDiff 

func NewRpcUniverseDiff(
	serverAddr universe.ServerAddr) (universe.DiffEngine, error)

NewRpcUniverseDiff creates a new RpcUniverseDiff instance that dials out to the target remote universe server address.

func NewRpcUniverseRegistrar added in v0.2.1 

func NewRpcUniverseRegistrar(
	serverAddr universe.ServerAddr) (universe.Registrar, error)

NewRpcUniverseRegistrar creates a new RpcUniverseRegistrar instance that dials out to the target remote universe server address.

func SetAgentName 

func SetAgentName(newAgentName string)

SetAgentName overwrites the default agent name which can be used to identify the software tapd is bundled in (for example LiT). This function panics if the agent name contains characters outside of the allowed semantic alphabet.

func SetSubLogger 

func SetSubLogger(root *build.SubLoggerManager, subsystem string,
	logger btclog.Logger, useLoggers ...func(btclog.Logger))

SetSubLogger is a helper method to conveniently register the logger of a sub system.

func SetupLoggers 

func SetupLoggers(root *build.SubLoggerManager,
	interceptor signal.Interceptor)

SetupLoggers initializes all package-global logger variables.

func Tags 

func Tags() []string

Tags returns the list of build tags that were compiled into the executable.

func UnmarshalGroupWitness added in v0.6.0 

func UnmarshalGroupWitness(
	wit *taprpc.GroupWitness) (*tapgarden.PendingGroupWitness, error)

UnmarshalGroupWitness parses an asset group witness from the RPC variant.

func UnmarshalUniID added in v0.3.0 

func UnmarshalUniID(rpcID *unirpc.ID) (universe.Identifier, error)

UnmarshalUniID parses the RPC universe ID into the native counterpart.

func UnmarshalUniProofType added in v0.3.0 

func UnmarshalUniProofType(rpcType unirpc.ProofType) (universe.ProofType,
	error)

UnmarshalUniProofType parses the RPC universe proof type into the native counterpart.

func UserAgent 

func UserAgent(initiator string) string

UserAgent returns the full user agent string that identifies the software that is submitting swaps to the loop server.

func Version 

func Version() string

Version returns the application version as a properly formed string per the semantic versioning 2.0.0 spec (http://semver.org/).

Types

type Config 

type Config struct {
	DebugLevel string

	// RuntimeID is a pseudo-random ID that is generated when the server
	// starts. It is used to identify the server to itself, to avoid
	// connecting to itself as a federation member.
	RuntimeID int64

	// EnableChannelFeatures indicates that tapd is running inside the
	// Lightning Terminal daemon (litd) and can provide Taproot Asset
	// channel functionality.
	EnableChannelFeatures bool

	ChainParams address.ChainParams

	Lnd *lndclient.LndServices

	SignalInterceptor signal.Interceptor

	MboxServerConfig authmailbox.ServerConfig

	ReOrgWatcher *tapgarden.ReOrgWatcher

	AssetMinter tapgarden.Planter

	AssetCustodian *tapgarden.Custodian

	ChainBridge tapgarden.ChainBridge

	AddrBook *address.Book

	// AddrBookDisableSyncer is a flag which, if true, will prevent the
	// daemon from trying to sync issuance proofs for unknown assets when
	// creating an address.
	AddrBookDisableSyncer bool

	DefaultProofCourierAddr *url.URL

	ProofArchive proof.Archiver

	AssetWallet tapfreighter.Wallet

	CoinSelect *tapfreighter.CoinSelect

	ChainPorter tapfreighter.Porter

	// FsmDaemonAdapters is a set of adapters that allow a state machine to
	// interact with external daemons.
	FsmDaemonAdapters *lndservices.LndFsmDaemonAdapters

	// SupplyCommitManager is a service that is used to manage supply
	// commitments for assets. Supply commitments are issuer published
	// attestations of the total supply of an asset.
	SupplyCommitManager *supplycommit.Manager

	IgnoreChecker *tapdb.CachingIgnoreChecker

	// SupplyVerifyManager is a service that is used to verify supply
	// commitments for assets. Supply commitments are issuer published
	// attestations of the total supply of an asset.
	SupplyVerifyManager *supplyverifier.Manager

	UniverseArchive *universe.Archive

	UniverseSyncer universe.Syncer

	UniverseFederation *universe.FederationEnvoy

	// UniFedSyncAllAssets is a flag that indicates whether the
	// universe federation syncer should default to syncing all assets.
	UniFedSyncAllAssets bool

	RfqManager *rfq.Manager

	PriceOracle rfq.PriceOracle

	PriceOracleSendPeerID bool

	UniverseStats universe.Telemetry

	AuxLeafSigner *tapchannel.AuxLeafSigner

	AuxFundingController *tapchannel.FundingController

	AuxTrafficShaper *tapchannel.AuxTrafficShaper

	AuxChanNegotiator *tapfeatures.AuxChannelNegotiator

	AuxInvoiceManager *tapchannel.AuxInvoiceManager

	AuxChanCloser *tapchannel.AuxChanCloser

	AuxSweeper *tapchannel.AuxSweeper

	// UniversePublicAccess is a field that indicates the status of public
	// access (i.e. read/write) to the universe server.
	//
	// NOTE: This field does not influence universe federation syncing
	// behaviour.
	UniversePublicAccess UniversePublicAccessStatus

	// UniverseQueriesPerSecond is the maximum number of queries per
	// second across the set of active universe queries that is permitted.
	// Anything above this starts to get rate limited.
	UniverseQueriesPerSecond rate.Limit

	// UniverseQueriesBurst is the burst budget for the universe query rate
	// limiting.
	UniverseQueriesBurst int

	Prometheus monitoring.PrometheusConfig

	// LogWriter is the root logger that all of the daemon's subloggers are
	// hooked up to.
	LogWriter *build.RotatingLogWriter

	// LogMgr is the sublogger manager that is used to create subloggers for
	// the daemon.
	LogMgr *build.SubLoggerManager

	*RPCConfig

	*DatabaseConfig
}

Config is the main config of the Taproot Assets server.

type DatabaseConfig 

type DatabaseConfig struct {
	RootKeyStore *tapdb.RootKeyStore

	MintingStore tapgarden.MintingStore

	AssetStore *tapdb.AssetStore

	TapAddrBook *tapdb.TapAddressBook

	Multiverse *tapdb.MultiverseStore

	FederationDB *tapdb.UniverseFederationDB
}

DatabaseConfig is the config that holds all the persistence related structs and interfaces needed for tapd to function.

type EventStream added in v0.4.0 

type EventStream[T any] interface {
	// Send sends an event object to the notification stream.
	Send(T) error
	grpc.ServerStream
}

EventStream is a generic interface type for notification streams.

type IgnoreAssetOutPointRequest added in v0.7.0 

type IgnoreAssetOutPointRequest struct {
	// AssetAnchorPoint is the asset anchor point to ignore.
	AssetAnchorPoint asset.AnchorPoint

	// Amount is the amount of the asset at the anchor outpoint.
	Amount uint64
}

IgnoreAssetOutPointRequest is the request type for the IgnoreAssetOutPoint RPC method.

type RPCConfig 

type RPCConfig struct {
	LisCfg *lnd.ListenerCfg

	RPCListeners []net.Addr

	RESTListeners []net.Addr

	GrpcServerOpts []grpc.ServerOption

	RestDialOpts []grpc.DialOption

	RestListenFunc func(net.Addr) (net.Listener, error)

	WSPingInterval time.Duration

	WSPongWait time.Duration

	RestCORS []string

	NoMacaroons bool

	MacaroonPath string

	AllowPublicUniProofCourier bool

	AllowPublicStats bool

	LetsEncryptDir string

	LetsEncryptListen string

	LetsEncryptDomain string

	LetsEncryptEmail string
}

RPCConfig is a sub-config of the main server that packages up everything needed to start the RPC server.

type RpcSupplySync added in v0.7.0 

type RpcSupplySync struct {
	// contains filtered or unexported fields
}

RpcSupplySync is an implementation of the universe.SupplySyncer interface that uses an RPC connection to target a remote universe server.

func (*RpcSupplySync) Close added in v0.7.0 

func (r *RpcSupplySync) Close() error

Close closes the RPC connection to the universe server.

func (*RpcSupplySync) FetchSupplyCommit added in v0.7.0 

func (r *RpcSupplySync) FetchSupplyCommit(ctx context.Context,
	assetSpec asset.Specifier,
	spentCommitOutpoint fn.Option[wire.OutPoint]) (
	supplycommit.FetchSupplyCommitResult, error)

FetchSupplyCommit fetches a supply commitment for a specific asset group from the remote universe server.

func (*RpcSupplySync) InsertSupplyCommit added in v0.7.0 

func (r *RpcSupplySync) InsertSupplyCommit(ctx context.Context,
	assetSpec asset.Specifier, commitment supplycommit.RootCommitment,
	leaves supplycommit.SupplyLeaves,
	chainProof supplycommit.ChainProof) error

InsertSupplyCommit inserts a supply commitment for a specific asset group into the remote universe server.

type RpcUniverseDiff 

type RpcUniverseDiff struct {
	// contains filtered or unexported fields
}

RpcUniverseDiff is an implementation of the universe.DiffEngine interface that uses an RPC connection to target Universe.

func (*RpcUniverseDiff) Close added in v0.3.3 

func (r *RpcUniverseDiff) Close() error

Close closes the underlying RPC connection to the remote universe server.

func (*RpcUniverseDiff) FetchProofLeaf added in v0.3.1 

func (r *RpcUniverseDiff) FetchProofLeaf(ctx context.Context,
	id universe.Identifier,
	key universe.LeafKey) ([]*universe.Proof, error)

FetchProofLeaf attempts to fetch a proof leaf for the target leaf key and given a universe identifier (assetID/groupKey).

TODO(roasbeef): actually add this somewhere else? * rn kinda asymmetric, as just need this to complete final portion of diff

func (*RpcUniverseDiff) RootNode 

func (r *RpcUniverseDiff) RootNode(ctx context.Context,
	id universe.Identifier) (universe.Root, error)

RootNode returns the root node for a given universe.

func (*RpcUniverseDiff) RootNodes 

func (r *RpcUniverseDiff) RootNodes(ctx context.Context,
	q universe.RootNodesQuery) ([]universe.Root, error)

RootNodes returns the complete set of known root nodes for the set of assets tracked in the universe.

func (*RpcUniverseDiff) UniverseLeafKeys added in v0.3.0 

func (r *RpcUniverseDiff) UniverseLeafKeys(ctx context.Context,
	q universe.UniverseLeafKeysQuery) ([]universe.LeafKey, error)

UniverseLeafKeys returns all the keys inserted in the universe.

type RpcUniverseRegistrar added in v0.2.1 

type RpcUniverseRegistrar struct {
	// contains filtered or unexported fields
}

RpcUniverseRegistrar is an implementation of the universe.Registrar interface that uses an RPC connection to target Universe.

func (*RpcUniverseRegistrar) Close added in v0.3.3 

func (r *RpcUniverseRegistrar) Close() error

Close closes the underlying RPC connection to the remote Universe server.

func (*RpcUniverseRegistrar) UpsertProofLeaf added in v0.3.1 

func (r *RpcUniverseRegistrar) UpsertProofLeaf(ctx context.Context,
	id universe.Identifier, key universe.LeafKey,
	leaf *universe.Leaf) (*universe.Proof, error)

UpsertProofLeaf is an implementation of the universe.Registrar interface that uses a remote Universe server as the Registry instance.

type Server 

type Server struct {
	// contains filtered or unexported fields
}

Server is the main daemon construct for the Taproot Asset server. It handles spinning up the RPC sever, the database, and any other components that the Taproot Asset server needs to function.

func NewServer 

func NewServer(chainParams *address.ChainParams) *Server

NewServer creates a new server.

func (Server) AddAssetBuyOffer added in v0.4.0 

func (r Server) AddAssetBuyOffer(_ context.Context,
	req *rfqrpc.AddAssetBuyOfferRequest) (*rfqrpc.AddAssetBuyOfferResponse,
	error)

AddAssetBuyOffer upserts a new buy offer for the given asset into the RFQ manager. If the offer already exists for the given asset, it will be updated.

A buy offer is used by the node to selectively accept or reject incoming asset sell quote requests before price is considered.

func (Server) AddAssetBuyOrder added in v0.4.0 

func (r Server) AddAssetBuyOrder(ctx context.Context,
	req *rfqrpc.AddAssetBuyOrderRequest) (*rfqrpc.AddAssetBuyOrderResponse,
	error)

AddAssetBuyOrder upserts a new buy order for the given asset into the RFQ manager. If the order already exists for the given asset, it will be updated.

func (Server) AddAssetSellOffer added in v0.4.0 

func (r Server) AddAssetSellOffer(_ context.Context,
	req *rfqrpc.AddAssetSellOfferRequest) (*rfqrpc.AddAssetSellOfferResponse,
	error)

AddAssetSellOffer upserts a new sell offer for the given asset into the RFQ manager. If the offer already exists for the given asset, it will be updated.

func (Server) AddAssetSellOrder added in v0.4.0 

func (r Server) AddAssetSellOrder(ctx context.Context,
	req *rfqrpc.AddAssetSellOrderRequest) (*rfqrpc.AddAssetSellOrderResponse,
	error)

AddAssetSellOrder upserts a new sell order for the given asset into the RFQ manager. If the order already exists for the given asset, it will be updated.

func (Server) AddFederationServer 

func (r Server) AddFederationServer(ctx context.Context,
	req *unirpc.AddFederationServerRequest,
) (*unirpc.AddFederationServerResponse, error)

AddFederationServer adds a new server to the federation of the local Universe server. Once a server is added, this call can also optionally be used to trigger a sync of the remote server.

func (Server) AddInvoice added in v0.5.0 

func (r Server) AddInvoice(ctx context.Context,
	req *tchrpc.AddInvoiceRequest) (*tchrpc.AddInvoiceResponse, error)

AddInvoice is a wrapper around lnd's lnrpc.AddInvoice method with asset specific parameters. It allows RPC users to create invoices that correspond to the specified asset amount.

func (Server) AddrReceives 

func (r Server) AddrReceives(ctx context.Context,
	req *taprpc.AddrReceivesRequest) (*taprpc.AddrReceivesResponse,
	error)

AddrReceives lists all receives for incoming asset transfers for addresses that were created previously.

func (Server) AnchorVirtualPsbts 

func (r Server) AnchorVirtualPsbts(ctx context.Context,
	req *wrpc.AnchorVirtualPsbtsRequest) (*taprpc.SendAssetResponse,
	error)

AnchorVirtualPsbts merges and then commits multiple virtual transactions in a single BTC level anchor transaction.

func (*Server) ApplyHtlcView added in v0.4.0 

func (s *Server) ApplyHtlcView(
	in lnwl.CommitDiffAuxInput) lfn.Result[lfn.Option[tlv.Blob]]

ApplyHtlcView serves as the state transition function for the custom channel's blob. Given the old blob, and an HTLC view, then a new blob should be returned that reflects the pending updates.

NOTE: This method is part of the lnwallet.AuxLeafStore interface.

func (Server) AssetLeafKeys 

func (r Server) AssetLeafKeys(ctx context.Context,
	req *unirpc.AssetLeafKeysRequest) (*unirpc.AssetLeafKeyResponse, error)

AssetLeafKeys queries for the set of Universe keys associated with a given asset_id or group_key. Each key takes the form: (outpoint, script_key), where outpoint is an outpoint in the Bitcoin blockchain that anchors a valid Taproot Asset commitment, and script_key is the script_key of the asset within the Taproot Asset commitment for the given asset_id or group_key.

func (Server) AssetLeaves 

func (r Server) AssetLeaves(ctx context.Context,
	req *unirpc.ID) (*unirpc.AssetLeafResponse, error)

AssetLeaves queries for the set of asset leaves (the values in the Universe MS-SMT tree) for a given asset_id or group_key. These represents either asset issuance events (they have a genesis witness) or asset transfers that took place on chain. The leaves contain a normal Taproot asset proof, as well as details for the asset.

func (Server) AssetRoots 

func (r Server) AssetRoots(ctx context.Context,
	req *unirpc.AssetRootRequest) (*unirpc.AssetRootResponse, error)

AssetRoots queries for the known Universe roots associated with each known asset. These roots represent the supply/audit state for each known asset.

func (*Server) AuxCloseOutputs added in v0.4.0 

func (s *Server) AuxCloseOutputs(
	desc chancloser.AuxCloseDesc) (lfn.Option[chancloser.AuxCloseOutputs],
	error)

AuxCloseOutputs returns the set of close outputs to use for this co-op close attempt. We'll add some extra outputs to the co-op close transaction, and also give the caller a custom sorting routine.

NOTE: This method is part of the chancloser.AuxChanCloser interface.

func (Server) BurnAsset added in v0.3.0 

func (r Server) BurnAsset(ctx context.Context,
	in *taprpc.BurnAssetRequest) (*taprpc.BurnAssetResponse, error)

BurnAsset burns the given number of units of a given asset by sending them to a provably un-spendable script key. Burning means irrevocably destroying a certain number of assets, reducing the total supply of the asset. Because burning is such a destructive and non-reversible operation, some specific values need to be set in the request to avoid accidental burns.

func (*Server) CanHandle added in v0.4.0 

func (s *Server) CanHandle(msg msgmux.PeerMsg) bool

CanHandle returns true if the target message can be routed to this endpoint.

NOTE: This method is part of the msgmux.MsgEndpoint interface.

func (Server) CancelBatch 

func (r Server) CancelBatch(_ context.Context,
	_ *mintrpc.CancelBatchRequest) (*mintrpc.CancelBatchResponse,
	error)

CancelBatch attempts to cancel the current pending batch.

func (*Server) ChannelFinalized added in v0.4.0 

func (s *Server) ChannelFinalized(pid funding.PendingChanID) error

ChannelFinalized is called once we receive the commit sig from a remote party and find it to be valid.

NOTE: This method is part of the funding.AuxFundingController interface.

func (*Server) ChannelReady added in v0.4.0 

func (s *Server) ChannelReady(openChan lnwl.AuxChanState) error

ChannelReady is called when a channel has been fully opened and is ready to be used. This can be used to perform any final setup or cleanup.

NOTE: This method is part of the funding.AuxFundingController interface.

func (Server) CommitVirtualPsbts added in v0.4.0 

func (r Server) CommitVirtualPsbts(ctx context.Context,
	req *wrpc.CommitVirtualPsbtsRequest) (*wrpc.CommitVirtualPsbtsResponse,
	error)

CommitVirtualPsbts creates the output commitments and proofs for the given virtual transactions by committing them to the BTC level anchor transaction. In addition, the BTC level anchor transaction is funded and prepared up to the point where it is ready to be signed.

func (Server) DebugLevel 

func (r Server) DebugLevel(ctx context.Context,
	req *taprpc.DebugLevelRequest) (*taprpc.DebugLevelResponse, error)

DebugLevel allows a caller to programmatically set the logging verbosity of tapd. The logging can be targeted according to a coarse daemon-wide logging level, or in a granular fashion to specify the logging for a target sub-system.

func (Server) DeclareScriptKey added in v0.4.0 

func (r Server) DeclareScriptKey(ctx context.Context,
	in *wrpc.DeclareScriptKeyRequest) (*wrpc.DeclareScriptKeyResponse,
	error)

DeclareScriptKey declares a new script key to the wallet. This is useful when the script key contains scripts, which would mean it wouldn't be recognized by the wallet automatically. Declaring a script key will make any assets sent to the script key be recognized as being local assets.

func (Server) DecodeAddr 

func (r Server) DecodeAddr(_ context.Context,
	req *taprpc.DecodeAddrRequest) (*taprpc.Addr, error)

DecodeAddr decode a Taproot Asset address into a partial asset message that represents the asset it wants to receive.

func (Server) DecodeAssetPayReq added in v0.5.0 

func (r Server) DecodeAssetPayReq(ctx context.Context,
	payReq *tchrpc.AssetPayReq) (*tchrpc.AssetPayReqResponse, error)

DecodeAssetPayReq decodes an incoming invoice, then uses the RFQ system to map the BTC amount to the amount of asset units for the specified asset ID.

func (Server) DecodeProof added in v0.2.1 

func (r Server) DecodeProof(ctx context.Context,
	req *taprpc.DecodeProofRequest) (*taprpc.DecodeProofResponse, error)

DecodeProof attempts to decode a given proof file that claims to be anchored at the specified genesis point.

func (Server) DeleteAssetRoot added in v0.2.1 

func (r Server) DeleteAssetRoot(ctx context.Context,
	req *unirpc.DeleteRootQuery) (*unirpc.DeleteRootResponse, error)

DeleteAssetRoot attempts to locate the current Universe root for a specific asset, and deletes the associated Universe tree if found.

func (Server) DeleteFederationServer 

func (r Server) DeleteFederationServer(ctx context.Context,
	req *unirpc.DeleteFederationServerRequest,
) (*unirpc.DeleteFederationServerResponse, error)

DeleteFederationServer removes a server from the federation of the local Universe server.

func (*Server) DeriveSweepAddr added in v0.4.0 

func (s *Server) DeriveSweepAddr(inputs []input.Input,
	change lnwl.AddrWithKey) lfn.Result[sweep.SweepOutput]

DeriveSweepAddr takes a set of inputs, and the change address we'd use to sweep them, and maybe results in an extra sweep output that we should add to the sweeping transaction.

NOTE: This method is part of the sweep.AuxSweeper interface.

func (*Server) DeriveTapscriptRoot added in v0.4.0 

func (s *Server) DeriveTapscriptRoot(
	pid funding.PendingChanID) funding.AuxTapscriptResult

DeriveTapscriptRoot takes a pending channel ID and maybe returns a tapscript root that should be used when creating any MuSig2 sessions for a channel.

NOTE: This method is part of the funding.AuxFundingController interface.

func (*Server) DescFromPendingChanID added in v0.4.0 

func (s *Server) DescFromPendingChanID(pid funding.PendingChanID,
	chanState lnwl.AuxChanState,
	keyRing lntypes.Dual[lnwl.CommitmentKeyRing],
	initiator bool) funding.AuxFundingDescResult

DescFromPendingChanID takes a pending channel ID, that may already be known due to prior custom channel messages, and maybe returns an aux funding desc which can be used to modify how a channel is funded.

NOTE: This method is part of the funding.AuxFundingController interface.

func (Server) EncodeCustomRecords added in v0.4.0 

func (r Server) EncodeCustomRecords(_ context.Context,
	in *tchrpc.EncodeCustomRecordsRequest) (
	*tchrpc.EncodeCustomRecordsResponse, error)

EncodeCustomRecords allows RPC users to encode Taproot Asset channel related data into the TLV format that is used in the custom records of the lnd payment or other channel related RPCs. This RPC is completely stateless and does not perform any checks on the data provided, other than pure format validation.

func (Server) ExportProof 

func (r Server) ExportProof(ctx context.Context,
	req *taprpc.ExportProofRequest) (*taprpc.ProofFile, error)

ExportProof exports the latest raw proof file anchored at the specified script_key.

func (*Server) ExtraBudgetForInputs added in v0.5.0 

func (s *Server) ExtraBudgetForInputs(
	inputs []input.Input) lfn.Result[btcutil.Amount]

ExtraBudgetForInputs takes a set of inputs and maybe returns an extra budget that should be added to the sweep transaction.

NOTE: This method is part of the sweep.AuxSweeper interface.

func (Server) FetchAssetMeta 

func (r Server) FetchAssetMeta(ctx context.Context,
	req *taprpc.FetchAssetMetaRequest) (*taprpc.FetchAssetMetaResponse,
	error)

func (*Server) FetchLeavesFromCommit added in v0.4.0 

func (s *Server) FetchLeavesFromCommit(chanState lnwl.AuxChanState,
	com channeldb.ChannelCommitment, keys lnwl.CommitmentKeyRing,
	whoseCommit lntypes.ChannelParty) lfn.Result[lnwl.CommitDiffAuxResult]

FetchLeavesFromCommit attempts to fetch the auxiliary leaves that correspond to the passed aux blob, and an existing channel commitment.

NOTE: This method is part of the lnwallet.AuxLeafStore interface. nolint:lll

func (*Server) FetchLeavesFromRevocation added in v0.4.0 

func (s *Server) FetchLeavesFromRevocation(
	r *channeldb.RevocationLog) lfn.Result[lnwl.CommitDiffAuxResult]

FetchLeavesFromRevocation attempts to fetch the auxiliary leaves from a channel revocation that stores balance + blob information.

NOTE: This method is part of the lnwallet.AuxLeafStore interface.

func (*Server) FetchLeavesFromView added in v0.4.0 

func (s *Server) FetchLeavesFromView(
	in lnwl.CommitDiffAuxInput) lfn.Result[lnwl.CommitDiffAuxResult]

FetchLeavesFromView attempts to fetch the auxiliary leaves that correspond to the passed aux blob, and pending fully evaluated HTLC view.

NOTE: This method is part of the lnwallet.AuxLeafStore interface.

func (Server) FetchSupplyCommit added in v0.7.0 

func (r Server) FetchSupplyCommit(ctx context.Context,
	req *unirpc.FetchSupplyCommitRequest) (
	*unirpc.FetchSupplyCommitResponse, error)

FetchSupplyCommit fetches the on-chain supply commitment for a specific asset group.

func (Server) FetchSupplyLeaves added in v0.7.0 

func (r Server) FetchSupplyLeaves(ctx context.Context,
	req *unirpc.FetchSupplyLeavesRequest) (
	*unirpc.FetchSupplyLeavesResponse, error)

FetchSupplyLeaves fetches the supply leaves for a specific asset group within a specified block height range. The leaves include issuance, burn, and ignore leaves, which represent the supply changes for the asset group.

func (Server) FinalizeBatch 

func (r Server) FinalizeBatch(ctx context.Context,
	req *mintrpc.FinalizeBatchRequest) (*mintrpc.FinalizeBatchResponse,
	error)

FinalizeBatch attempts to finalize the current pending batch.

func (*Server) FinalizeClose added in v0.4.0 

func (s *Server) FinalizeClose(desc chancloser.AuxCloseDesc,
	closeTx *wire.MsgTx) error

FinalizeClose is called once the co-op close transaction has been agreed upon. We'll finalize the exclusion proofs, then send things off to the custodian or porter to finish sending/receiving the proofs.

NOTE: This method is part of the chancloser.AuxChanCloser interface.

func (Server) FundBatch added in v0.4.0 

func (r Server) FundBatch(ctx context.Context,
	req *mintrpc.FundBatchRequest) (*mintrpc.FundBatchResponse, error)

FundBatch attempts to fund the current pending batch.

func (Server) FundChannel added in v0.4.0 

func (r Server) FundChannel(ctx context.Context,
	req *tchrpc.FundChannelRequest) (*tchrpc.FundChannelResponse,
	error)

FundChannel initiates the channel funding negotiation with a peer for the creation of a channel that contains a specified amount of a given asset.

func (Server) FundVirtualPsbt 

func (r Server) FundVirtualPsbt(ctx context.Context,
	req *wrpc.FundVirtualPsbtRequest) (*wrpc.FundVirtualPsbtResponse,
	error)

FundVirtualPsbt selects inputs from the available asset commitments to fund a virtual transaction matching the template.

func (Server) GetInfo added in v0.2.1 

func (r Server) GetInfo(ctx context.Context,
	_ *taprpc.GetInfoRequest) (*taprpc.GetInfoResponse, error)

GetInfo returns general information relating to the active daemon. For example: its version, network, and lnd version.

func (*Server) GetInitRecords added in v0.7.0 

func (s *Server) GetInitRecords(
	peer route.Vertex) (lnwire.CustomRecords, error)

GetInitRecords is called when sending an init message to a peer. It returns custom records to include in the init message TLVs. The implementation can decide which records to include based on the peer identity.

func (Server) IgnoreAssetOutPoint added in v0.7.0 

func (r Server) IgnoreAssetOutPoint(ctx context.Context,
	rpcReq *unirpc.IgnoreAssetOutPointRequest) (
	*unirpc.IgnoreAssetOutPointResponse, error)

IgnoreAssetOutPoint allows an asset issuer to mark a specific asset outpoint as ignored. An ignored outpoint will be included in the next universe commitment transaction that is published.

func (Server) ImportProof 

func (r Server) ImportProof(ctx context.Context,
	req *tapdevrpc.ImportProofRequest) (*tapdevrpc.ImportProofResponse,
	error)

ImportProof attempts to import a proof file into the daemon. If successful, a new asset will be inserted on disk, spendable using the specified target script key, and internal key.

func (Server) Info added in v0.2.1 

func (r Server) Info(ctx context.Context,
	_ *unirpc.InfoRequest) (*unirpc.InfoResponse, error)

Info returns a set of information about the current state of the Universe and allows a caller to check that a universe server is reachable and configured correctly to allow proof courier access without macaroons.

func (*Server) InlineParseCustomData added in v0.4.0 

func (s *Server) InlineParseCustomData(msg proto.Message) error

InlineParseCustomData replaces any custom data binary blob in the given RPC message with its corresponding JSON formatted data. This transforms the binary (likely TLV encoded) data to a human-readable JSON representation (still as byte slice).

NOTE: This method is part of the lnd.AuxDataParser interface.

func (Server) InsertProof 

func (r Server) InsertProof(ctx context.Context,
	req *unirpc.AssetProof) (*unirpc.AssetProofResponse, error)

InsertProof attempts to insert a new issuance or transfer proof into the Universe tree specified by the UniverseKey. If valid, then the proof is inserted into the database, with a new Universe root returned for the updated asset_id/group_key.

func (Server) InsertSupplyCommit added in v0.7.0 

func (r Server) InsertSupplyCommit(ctx context.Context,
	req *unirpc.InsertSupplyCommitRequest) (
	*unirpc.InsertSupplyCommitResponse, error)

InsertSupplyCommit stores a verified supply commitment for the given asset group in the node's local database.

func (*Server) IsCustomHTLC added in v0.5.1 

func (s *Server) IsCustomHTLC(htlcRecords lnwire.CustomRecords) bool

IsCustomHTLC returns true if the HTLC carries the set of relevant custom records to put it under the purview of the traffic shaper, meaning that it's from a custom channel.

NOTE: This method is part of the routing.TlvTrafficShaper interface.

func (Server) ListAssets 

func (r Server) ListAssets(ctx context.Context,
	req *taprpc.ListAssetRequest) (*taprpc.ListAssetResponse, error)

ListAssets lists the set of assets owned by the target daemon.

func (Server) ListBalances 

func (r Server) ListBalances(ctx context.Context,
	req *taprpc.ListBalancesRequest) (*taprpc.ListBalancesResponse, error)

ListBalances lists the asset balances owned by the daemon.

func (Server) ListBatches 

func (r Server) ListBatches(_ context.Context,
	req *mintrpc.ListBatchRequest) (*mintrpc.ListBatchResponse, error)

ListBatches lists the set of batches submitted for minting, including pending and cancelled batches.

func (Server) ListBurns added in v0.5.0 

func (r Server) ListBurns(ctx context.Context,
	in *taprpc.ListBurnsRequest) (*taprpc.ListBurnsResponse, error)

ListBurns returns a list of burnt assets. Some filters may be defined in the request to return more specific results.

func (Server) ListFederationServers 

func (r Server) ListFederationServers(ctx context.Context,
	_ *unirpc.ListFederationServersRequest) (
	*unirpc.ListFederationServersResponse, error)

ListFederationServers lists the set of servers that make up the federation of the local Universe server. These servers are used to push out new proofs, and also periodically call sync new proofs from the remote server.

func (Server) ListGroups 

func (r Server) ListGroups(ctx context.Context,
	_ *taprpc.ListGroupsRequest) (*taprpc.ListGroupsResponse, error)

ListGroups lists known groups and the assets held in each group.

func (Server) ListTransfers 

func (r Server) ListTransfers(ctx context.Context,
	req *taprpc.ListTransfersRequest) (*taprpc.ListTransfersResponse,
	error)

ListTransfers returns a list of all asset transfers managed by this daemon. This includes both confirmed and unconfirmed transfers.

func (Server) ListUtxos 

func (r Server) ListUtxos(ctx context.Context,
	req *taprpc.ListUtxosRequest) (*taprpc.ListUtxosResponse, error)

ListUtxos lists the UTXOs managed by the target daemon, and the assets they hold.

func (Server) MarshalChainAsset added in v0.4.0 

func (r Server) MarshalChainAsset(ctx context.Context, a asset.ChainAsset,
	meta *proof.MetaReveal, withWitness bool,
	keyRing rpcutils.KeyLookup) (*taprpc.Asset, error)

MarshalChainAsset marshals the given chain asset into an RPC asset.

func (Server) MintAsset 

func (r Server) MintAsset(ctx context.Context,
	req *mintrpc.MintAssetRequest) (*mintrpc.MintAssetResponse, error)

MintAsset attempts to mint the set of assets (async by default to ensure proper batching) specified in the request.

func (Server) MultiverseRoot added in v0.4.0 

func (r Server) MultiverseRoot(ctx context.Context,
	req *unirpc.MultiverseRootRequest) (*unirpc.MultiverseRootResponse,
	error)

MultiverseRoot returns the root of the multiverse tree. This is useful to determine the equality of two multiverse trees, since the root can directly be compared to another multiverse root to find out if a sync is required.

func (*Server) Name added in v0.4.0 

func (s *Server) Name() msgmux.EndpointName

Name returns the name of this endpoint. This MUST be unique across all registered endpoints.

NOTE: This method is part of the msgmux.MsgEndpoint interface.

func (Server) NewAddr 

func (r Server) NewAddr(ctx context.Context,
	req *taprpc.NewAddrRequest) (*taprpc.Addr, error)

NewAddr makes a new address from the set of request params.

func (Server) NextInternalKey 

func (r Server) NextInternalKey(ctx context.Context,
	req *wrpc.NextInternalKeyRequest) (*wrpc.NextInternalKeyResponse,
	error)

NextInternalKey derives the next internal key for the given key family and stores it as an internal key in the database to make sure it is identified as a local key later on when importing proofs. While an internal key can also be used as the internal key of a script key, it is recommended to use the NextScriptKey RPC instead, to make sure the tweaked Taproot output key is also recognized as a local key.

func (Server) NextScriptKey 

func (r Server) NextScriptKey(ctx context.Context,
	req *wrpc.NextScriptKeyRequest) (*wrpc.NextScriptKeyResponse,
	error)

NextScriptKey derives the next script key (and its corresponding internal key) and stores them both in the database to make sure they are identified as local keys later on when importing proofs.

func (*Server) NotifyBroadcast added in v0.4.0 

func (s *Server) NotifyBroadcast(req *sweep.BumpRequest,
	tx *wire.MsgTx, fee btcutil.Amount,
	outpointToTxIndex map[wire.OutPoint]int) error

NotifyBroadcast is used to notify external callers of the broadcast of a sweep transaction, generated by the passed BumpRequest.

NOTE: This method is part of the sweep.AuxSweeper interface.

func (*Server) PackSigs added in v0.4.0 

func (s *Server) PackSigs(
	blob []lfn.Option[tlv.Blob]) lfn.Result[lfn.Option[tlv.Blob]]

PackSigs takes a series of aux signatures and packs them into a single blob that can be sent alongside the CommitSig messages.

NOTE: This method is part of the lnwallet.AuxSigner interface.

func (*Server) PaymentBandwidth added in v0.4.0 

func (s *Server) PaymentBandwidth(fundingBlob, htlcBlob,
	commitmentBlob lfn.Option[tlv.Blob], linkBandwidth,
	htlcAmt lnwire.MilliSatoshi, htlcView lnwallet.AuxHtlcView,
	peer route.Vertex) (lnwire.MilliSatoshi, error)

PaymentBandwidth returns the available bandwidth for a custom channel decided by the given channel aux blob and HTLC blob. A return value of 0 means there is no bandwidth available. To find out if a channel is a custom channel that should be handled by the traffic shaper, the HandleTraffic method should be called first.

NOTE: This method is part of the routing.TlvTrafficShaper interface.

func (*Server) ProcessChannelReady added in v0.7.0 

func (s *Server) ProcessChannelReady(cid lnwire.ChannelID, peer route.Vertex)

ProcessChannelReady handles the event of marking a channel identified by its channel ID as ready to use. We also provide the peer the channel was established with.

func (*Server) ProcessInitRecords added in v0.7.0 

func (s *Server) ProcessInitRecords(peer route.Vertex,
	customRecords lnwire.CustomRecords) error

ProcessInitRecords handles received init records from a peer. The implementation can store state internally to affect future channel operations with this peer.

func (*Server) ProcessReestablish added in v0.7.0 

func (s *Server) ProcessReestablish(cid lnwire.ChannelID, peer route.Vertex)

ProcessReestablishFeatures handles received channel_reestablish feature TLVs. This is a blocking call - the channel link will wait for this method to complete before continuing channel operations. The implementation can modify aux channel behavior based on the negotiated features.

func (*Server) ProduceHtlcExtraData added in v0.4.0 

func (s *Server) ProduceHtlcExtraData(totalAmount lnwire.MilliSatoshi,
	htlcCustomRecords lnwire.CustomRecords,
	peer route.Vertex) (lnwire.MilliSatoshi, lnwire.CustomRecords, error)

ProduceHtlcExtraData is a function that, based on the previous custom record blob of an HTLC, may produce a different blob or modify the amount of bitcoin this HTLC should carry.

NOTE: This method is part of the routing.TlvTrafficShaper interface.

func (Server) ProofVerifierCtx added in v0.7.0 

func (r Server) ProofVerifierCtx(ctx context.Context) proof.VerifierCtx

ProofVerifierCtx returns a proof.VerifierCtx that can be used to verify proofs in the RPC server.

func (Server) ProveAssetOwnership 

func (r Server) ProveAssetOwnership(ctx context.Context,
	req *wrpc.ProveAssetOwnershipRequest) (*wrpc.ProveAssetOwnershipResponse,
	error)

ProveAssetOwnership creates an ownership proof embedded in an asset transition proof. That ownership proof is a signed virtual transaction spending the asset with a valid witness to prove the prover owns the keys that can spend the asset.

func (Server) PublishAndLogTransfer added in v0.4.0 

func (r Server) PublishAndLogTransfer(ctx context.Context,
	req *wrpc.PublishAndLogRequest) (*taprpc.SendAssetResponse, error)

PublishAndLogTransfer accepts a fully committed and signed anchor transaction and publishes it to the Bitcoin network. It also logs the transfer of the given active and passive assets in the database and ships any outgoing proofs to the counterparties.

func (Server) PushProof added in v0.4.0 

func (r Server) PushProof(ctx context.Context,
	req *unirpc.PushProofRequest) (*unirpc.PushProofResponse, error)

PushProof attempts to query the local universe for a proof specified by a UniverseKey. If found, a connection is made to a remote Universe server to attempt to upload the asset leaf.

func (Server) QueryAddrs 

func (r Server) QueryAddrs(ctx context.Context,
	req *taprpc.QueryAddrRequest) (*taprpc.QueryAddrResponse, error)

QueryAddrs queries the set of Taproot Asset addresses stored in the database.

func (Server) QueryAssetRoots 

func (r Server) QueryAssetRoots(ctx context.Context,
	req *unirpc.AssetRootQuery) (*unirpc.QueryRootResponse, error)

QueryAssetRoots attempts to locate the current Universe root for a specific asset. This asset can be identified by its asset ID or group key.

func (Server) QueryAssetStats 

func (r Server) QueryAssetStats(ctx context.Context,
	req *unirpc.AssetStatsQuery) (*unirpc.UniverseAssetStats, error)

QueryAssetStats returns a set of statistics for a given set of assets. Stats can be queried for all assets, or based on the: asset ID, name, or asset type. Pagination is supported via the offset and limit params. Results can also be sorted based on any of the main query params.

func (Server) QueryEvents added in v0.2.3 

func (r Server) QueryEvents(ctx context.Context,
	req *unirpc.QueryEventsRequest) (*unirpc.QueryEventsResponse, error)

QueryEvents returns the number of sync and proof events for a given time period, grouped by day.

func (Server) QueryFederationSyncConfig added in v0.3.0 

func (r Server) QueryFederationSyncConfig(ctx context.Context,
	_ *unirpc.QueryFederationSyncConfigRequest,
) (*unirpc.QueryFederationSyncConfigResponse, error)

QueryFederationSyncConfig queries the universe federation sync configuration settings.

func (Server) QueryInternalKey added in v0.4.0 

func (r Server) QueryInternalKey(ctx context.Context,
	req *wrpc.QueryInternalKeyRequest) (*wrpc.QueryInternalKeyResponse,
	error)

QueryInternalKey returns the key descriptor for the given internal key.

func (Server) QueryPeerAcceptedQuotes added in v0.4.0 

func (r Server) QueryPeerAcceptedQuotes(_ context.Context,
	_ *rfqrpc.QueryPeerAcceptedQuotesRequest) (
	*rfqrpc.QueryPeerAcceptedQuotesResponse, error)

QueryPeerAcceptedQuotes is used to query for quotes that were requested by our node and have been accepted our peers.

func (Server) QueryProof 

func (r Server) QueryProof(ctx context.Context,
	req *unirpc.UniverseKey) (*unirpc.AssetProofResponse, error)

QueryProof attempts to query for an issuance or transfer proof for a given asset based on its UniverseKey. A UniverseKey is composed of the Universe ID (asset_id/group_key) and also a leaf key (outpoint || script_key). If found, the target universe proof leaf is returned in addition to inclusion proofs for the Universe and Multiverse MS-SMTs. This allows a caller to verify the known Universe root, Multiverse root, and transition or issuance proof for the target asset.

func (Server) QueryScriptKey added in v0.4.0 

func (r Server) QueryScriptKey(ctx context.Context,
	req *wrpc.QueryScriptKeyRequest) (*wrpc.QueryScriptKeyResponse, error)

QueryScriptKey returns the full script key descriptor for the given tweaked script key.

func (*Server) RegisterGrpcService added in v0.7.0 

func (s *Server) RegisterGrpcService(registrar grpc.ServiceRegistrar)

RegisterGrpcService must register the sub-server's GRPC server with the given registrar.

NOTE: this is part of the SubServer interface.

func (*Server) RegisterRestService added in v0.7.0 

func (s *Server) RegisterRestService(ctx context.Context, mux *proxy.ServeMux,
	endpoint string, dialOpts []grpc.DialOption) error

RegisterRestService registers the sub-server's REST handlers with the given endpoint.

NOTE: this is part of the SubServer interface.

func (Server) RegisterTransfer added in v0.5.1 

func (r Server) RegisterTransfer(ctx context.Context,
	req *taprpc.RegisterTransferRequest) (*taprpc.RegisterTransferResponse,
	error)

RegisterTransfer informs the daemon about a new inbound transfer that has happened. This is used for interactive transfers where no TAP address is involved and the recipient is aware of the transfer through an out-of-band protocol but the daemon hasn't been informed about the completion of the transfer. For this to work, the proof must already be in the recipient's local universe (e.g. through the use of the universerpc.InsertProof RPC or the universe proof courier and universe sync mechanisms) and this call simply instructs the daemon to detect the transfer as an asset it owns.

func (Server) RegisterWithGrpcServer 

func (r Server) RegisterWithGrpcServer(
	registrar grpc.ServiceRegistrar) error

RegisterWithGrpcServer registers the rpcServer with the passed root gRPC server.

func (Server) RegisterWithRestProxy 

func (r Server) RegisterWithRestProxy(restCtx context.Context,
	restMux *proxy.ServeMux, restDialOpts []grpc.DialOption,
	restProxyDest string) error

RegisterWithRestProxy registers the RPC server with the given rest proxy.

func (Server) RemoveUTXOLease added in v0.3.0 

func (r Server) RemoveUTXOLease(ctx context.Context,
	req *wrpc.RemoveUTXOLeaseRequest) (*wrpc.RemoveUTXOLeaseResponse,
	error)

RemoveUTXOLease removes the lease/lock/reservation of the given managed UTXO.

func (*Server) ResolveContract added in v0.4.0 

func (s *Server) ResolveContract(req lnwl.ResolutionReq) lfn.Result[tlv.Blob]

ResolveContract attempts to obtain a resolution blob for the specified contract.

NOTE: This method is part of the lnwallet.AuxContractResolver interface.

func (*Server) RunUntilShutdown 

func (s *Server) RunUntilShutdown(mainErrChan <-chan error) error

RunUntilShutdown runs the main Taproot Asset server loop until a signal is received to shut down the process.

func (Server) SealBatch added in v0.4.0 

func (r Server) SealBatch(ctx context.Context,
	req *mintrpc.SealBatchRequest) (*mintrpc.SealBatchResponse, error)

SealBatch attempts to seal the current pending batch, validating provided asset group witnesses and generating asset group witnesses as needed.

func (Server) SendAsset 

func (r Server) SendAsset(ctx context.Context,
	req *taprpc.SendAssetRequest) (*taprpc.SendAssetResponse, error)

SendAsset uses one or multiple passed Taproot Asset address(es) to attempt to complete an asset send. The method returns information w.r.t the on chain send, as well as the proof file information the receiver needs to fully receive the asset.

func (*Server) SendMessage added in v0.4.0 

func (s *Server) SendMessage(ctx context.Context, msg msgmux.PeerMsg) bool

SendMessage handles the target message, and returns true if the message was able to be processed.

NOTE: This method is part of the msgmux.MsgEndpoint interface.

func (Server) SendPayment added in v0.5.0 

func (r Server) SendPayment(req *tchrpc.SendPaymentRequest,
	stream tchrpc.TaprootAssetChannels_SendPaymentServer) error

SendPayment is a wrapper around lnd's routerrpc.SendPaymentV2 RPC method with asset specific parameters. It allows RPC users to send asset keysend payments (direct payments) or payments to an invoice with a specified asset amount.

func (Server) SetFederationSyncConfig added in v0.3.0 

func (r Server) SetFederationSyncConfig(ctx context.Context,
	req *unirpc.SetFederationSyncConfigRequest) (
	*unirpc.SetFederationSyncConfigResponse, error)

SetFederationSyncConfig sets the configuration of the universe federation sync.

func (*Server) ShouldHandleTraffic added in v0.5.0 

func (s *Server) ShouldHandleTraffic(cid lnwire.ShortChannelID,
	fundingBlob, htlcBlob lfn.Option[tlv.Blob]) (bool, error)

ShouldHandleTraffic is called in order to check if the channel identified by the provided channel ID is handled by the traffic shaper implementation. If it is handled by the traffic shaper, then the normal bandwidth calculation can be skipped and the bandwidth returned by PaymentBandwidth should be used instead.

NOTE: This method is part of the routing.TlvTrafficShaper interface.

func (*Server) ShutdownBlob added in v0.4.0 

func (s *Server) ShutdownBlob(
	req chancloser.AuxShutdownReq) (lfn.Option[lnwire.CustomRecords],
	error)

ShutdownBlob returns the set of custom records that should be included in the shutdown message.

NOTE: This method is part of the chancloser.AuxChanCloser interface.

func (Server) SignVirtualPsbt 

func (r Server) SignVirtualPsbt(ctx context.Context,
	req *wrpc.SignVirtualPsbtRequest) (*wrpc.SignVirtualPsbtResponse,
	error)

SignVirtualPsbt signs the inputs of a virtual transaction and prepares the commitments of the inputs and outputs.

func (Server) Start 

func (r Server) Start(cfg *Config) error

Start signals that the RPC server starts accepting requests.

func (*Server) StartAsSubserver 

func (s *Server) StartAsSubserver(lndGrpc *lndclient.GrpcLndServices) error

StartAsSubserver is an alternative to Start where the RPC server does not create its own gRPC server but registers to an existing one. The same goes for REST (if enabled), instead of creating an own mux and HTTP server, we register to an existing one.

func (*Server) Stop 

func (s *Server) Stop() error

Stop signals that the main tapd server should attempt a graceful shutdown.

func (Server) StopDaemon 

func (r Server) StopDaemon(_ context.Context,
	_ *taprpc.StopRequest) (*taprpc.StopResponse, error)

StopDaemon will send a shutdown request to the interrupt handler, triggering a graceful shutdown of the daemon.

func (*Server) SubmitSecondLevelSigBatch added in v0.4.0 

func (s *Server) SubmitSecondLevelSigBatch(chanState lnwl.AuxChanState,
	commitTx *wire.MsgTx, sigJob []lnwl.AuxSigJob) error

SubmitSecondLevelSigBatch takes a batch of aux sign jobs and processes them asynchronously.

NOTE: This method is part of the lnwallet.AuxSigner interface.

func (Server) SubscribeMintEvents added in v0.4.0 

func (r Server) SubscribeMintEvents(req *mintrpc.SubscribeMintEventsRequest,
	ntfnStream mintEventStream) error

SubscribeMintEvents allows a caller to subscribe to mint events for asset creation batches.

func (Server) SubscribeReceiveAssetEventNtfns added in v0.3.1 

func (r Server) SubscribeReceiveAssetEventNtfns(
	_ *tapdevrpc.SubscribeReceiveAssetEventNtfnsRequest,
	ntfnStream devReceiveEventStream) error

SubscribeReceiveAssetEventNtfns registers a subscription to the event notification stream which relates to the asset receiving process.

func (Server) SubscribeReceiveEvents added in v0.4.0 

func (r Server) SubscribeReceiveEvents(
	req *taprpc.SubscribeReceiveEventsRequest,
	ntfnStream receiveEventStream) error

SubscribeReceiveEvents registers a subscription to the event notification stream which relates to the asset receiving process.

func (Server) SubscribeRfqEventNtfns added in v0.4.0 

func (r Server) SubscribeRfqEventNtfns(
	_ *rfqrpc.SubscribeRfqEventNtfnsRequest,
	ntfnStream rfqrpc.Rfq_SubscribeRfqEventNtfnsServer) error

SubscribeRfqEventNtfns subscribes to RFQ event notifications.

func (Server) SubscribeSendAssetEventNtfns 

func (r Server) SubscribeSendAssetEventNtfns(
	_ *tapdevrpc.SubscribeSendAssetEventNtfnsRequest,
	ntfnStream devSendEventStream) error

SubscribeSendAssetEventNtfns registers a subscription to the event notification stream which relates to the asset sending process.

func (Server) SubscribeSendEvents added in v0.4.0 

func (r Server) SubscribeSendEvents(req *taprpc.SubscribeSendEventsRequest,
	ntfnStream sendEventStream) error

SubscribeSendEvents registers a subscription to the event notification stream which relates to the asset sending process.

func (Server) SyncUniverse 

func (r Server) SyncUniverse(ctx context.Context,
	req *unirpc.SyncRequest) (*unirpc.SyncResponse, error)

SyncUniverse takes host information for a remote Universe server, then attempts to synchronize either only the set of specified asset_ids, or all assets if none are specified. The sync process will attempt to query for the latest known root for each asset, performing tree based reconciliation to arrive at a new shared root.

func (Server) UniverseStats 

func (r Server) UniverseStats(ctx context.Context,
	_ *unirpc.StatsRequest) (*unirpc.StatsResponse, error)

UniverseStats returns a set of aggregate statistics for the current state of the Universe.

func (Server) UnpackProofFile added in v0.5.1 

func (r Server) UnpackProofFile(_ context.Context,
	req *taprpc.UnpackProofFileRequest) (*taprpc.UnpackProofFileResponse,
	error)

UnpackProofFile unpacks a proof file into a list of the individual raw proofs in the proof chain.

func (*Server) UnpackSigs added in v0.4.0 

func (s *Server) UnpackSigs(
	blob lfn.Option[tlv.Blob]) lfn.Result[[]lfn.Option[tlv.Blob]]

UnpackSigs takes a packed blob of signatures and returns the original signatures for each HTLC, keyed by HTLC index.

NOTE: This method is part of the lnwallet.AuxSigner interface.

func (*Server) UpdateConfig added in v0.4.0 

func (s *Server) UpdateConfig(cfg *Config)

UpdateConfig updates the server's configuration. This MUST be called before the server is started.

func (Server) UpdateSupplyCommit added in v0.7.0 

func (r Server) UpdateSupplyCommit(ctx context.Context,
	req *unirpc.UpdateSupplyCommitRequest) (
	*unirpc.UpdateSupplyCommitResponse, error)

UpdateSupplyCommit updates the on-chain supply commitment for a specific asset group.

func (*Server) ValidateMacaroon 

func (s *Server) ValidateMacaroon(ctx context.Context,
	requiredPermissions []bakery.Op, fullMethod string) error

ValidateMacaroon extracts the macaroon from the context's gRPC metadata, checks its signature, makes sure all specified permissions for the called method are contained within and finally ensures all caveat conditions are met. A non-nil error is returned if any of the checks fail. This method is needed to enable tapd running as an external subserver in the same process as lnd but still validate its own macaroons.

func (Server) VerifyAssetOwnership 

func (r Server) VerifyAssetOwnership(ctx context.Context,
	req *wrpc.VerifyAssetOwnershipRequest) (*wrpc.VerifyAssetOwnershipResponse,
	error)

VerifyAssetOwnership verifies the asset ownership proof embedded in the given transition proof of an asset and returns true if the proof is valid.

func (Server) VerifyProof 

func (r Server) VerifyProof(ctx context.Context,
	req *taprpc.ProofFile) (*taprpc.VerifyProofResponse, error)

VerifyProof attempts to verify a given proof file that claims to be anchored at the specified genesis point.

func (*Server) VerifySecondLevelSigs added in v0.4.0 

func (s *Server) VerifySecondLevelSigs(chanState lnwl.AuxChanState,
	commitTx *wire.MsgTx, verifyJob []lnwl.AuxVerifyJob) error

VerifySecondLevelSigs attempts to synchronously verify a batch of aux sig jobs.

NOTE: This method is part of the lnwallet.AuxSigner interface.

type UniversePublicAccessStatus added in v0.4.0 

type UniversePublicAccessStatus string

UniversePublicAccessStatus is a type that indicates the status of public access to the universe server. 

const (
	// UniversePublicAccessStatusNone indicates that no public access is
	// granted.
	UniversePublicAccessStatusNone UniversePublicAccessStatus = ""

	// UniversePublicAccessStatusRead indicates that read access is granted.
	UniversePublicAccessStatusRead UniversePublicAccessStatus = "r"

	// UniversePublicAccessStatusWrite indicates that write access is
	// granted.
	UniversePublicAccessStatusWrite UniversePublicAccessStatus = "w"

	// UniversePublicAccessStatusReadWrite indicates that read and write
	// access is granted.
	UniversePublicAccessStatusReadWrite UniversePublicAccessStatus = "rw"
)

func ParseUniversePublicAccessStatus added in v0.4.0 

func ParseUniversePublicAccessStatus(
	s string) (UniversePublicAccessStatus, error)

ParseUniversePublicAccessStatus parses a string into a universe public access status.

func (UniversePublicAccessStatus) IsReadAccessGranted added in v0.4.0 

func (s UniversePublicAccessStatus) IsReadAccessGranted() bool

IsReadAccessGranted returns true if the status indicates that read access is granted.

func (UniversePublicAccessStatus) IsWriteAccessGranted added in v0.4.0 

func (s UniversePublicAccessStatus) IsWriteAccessGranted() bool

IsWriteAccessGranted returns true if the status indicates that write access is granted.

type ValidatorV0 

type ValidatorV0 struct{}

ValidatorV0 is an implementation of the tapscript.TxValidator interface that supports Taproot Asset script version 0.

func (*ValidatorV0) Execute 

func (v *ValidatorV0) Execute(newAsset *asset.Asset,
	splitAssets []*commitment.SplitAsset, prevAssets commitment.InputSet,
	chainLookup asset.ChainLookup) error

Execute creates and runs an instance of the Taproot Asset script V0 VM.

type WitnessValidatorV0 added in v0.4.0 

type WitnessValidatorV0 struct{}

WitnessValidatorV0 is an implementation of the tapscript.WitnessValidator interface that supports Taproot Asset script version 0.

func (*WitnessValidatorV0) ValidateWitnesses added in v0.4.0 

func (v *WitnessValidatorV0) ValidateWitnesses(newAsset *asset.Asset,
	splitAssets []*commitment.SplitAsset,
	prevAssets commitment.InputSet) error

ValidateWitnesses validates the created witnesses of an asset transfer.

Source Files

View all Source files

Directories

Path Synopsis
cmd
commands
merge-sql-schemas command
tapcli command
tapd command
internal
ecies
pedersen
test
loadtest
rpcassert
nolint:lll
 nolint:lll
sqlc
taprpc module
supplycommit
supplyverifier

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.