x

Documentation

Index

• Constants
• Variables
• type Backend
  • func NewBackend(ctx Context, chainID ids.ID, utxos ChainUTXOs) Backend
• type Builder
  • func NewBuilder(addrs ids.ShortSet, backend BuilderBackend) Builder
  • func NewBuilderWithOptions(builder Builder, options ...common.Option) Builder
• type BuilderBackend
• type ChainUTXOs
• type Context
  • func NewContext(networkID uint32, blockchainID ids.ID, djtxAssetID ids.ID, baseTxFee uint64, ...) Context
  • func NewContextFromClients(ctx stdcontext.Context, infoClient info.Client, xChainClient avm.Client) (Context, error)
  • func NewContextFromURI(ctx stdcontext.Context, uri string) (Context, error)
• type Signer
  • func NewSigner(kc *secp256k1fx.Keychain, backend SignerBackend) Signer
• type SignerBackend
• type Wallet
  • func NewWallet(builder Builder, signer Signer, client avm.Client, backend Backend) Wallet
  • func NewWalletWithOptions(wallet Wallet, options ...common.Option) Wallet

Constants

const (
	// CodecVersion is the current default codec version
	CodecVersion = 0

	// TODO: verify that these are correct
	SECP256K1FxIndex = 0
	NFTFxIndex       = 1
	PropertyFxIndex  = 2
)

Variables

var (
	Codec codec.Manager
)

Codecs do serialization and deserialization

Types

type Backend

type Backend interface {
	ChainUTXOs
	BuilderBackend
	SignerBackend

	AcceptTx(ctx stdcontext.Context, tx *avm.Tx) error
}

Backend defines the full interface required to support an X-chain wallet.

func NewBackend

func NewBackend(ctx Context, chainID ids.ID, utxos ChainUTXOs) Backend

type Builder

type Builder interface {
	// GetFTBalance calculates the amount of each fungible asset that this
	// builder has control over.
	GetFTBalance(
		options ...common.Option,
	) (map[ids.ID]uint64, error)

	// GetImportableBalance calculates the amount of each fungible asset that
	// this builder could import from the provided chain.
	//
	// - [chainID] specifies the chain the funds are from.
	GetImportableBalance(
		chainID ids.ID,
		options ...common.Option,
	) (map[ids.ID]uint64, error)

	// NewBaseTx creates a new simple value transfer.
	//
	// - [outputs] specifies all the recipients and amounts that should be sent
	//   from this transaction.
	NewBaseTx(
		outputs []*djtx.TransferableOutput,
		options ...common.Option,
	) (*avm.BaseTx, error)

	// NewCreateAssetTx creates a new asset.
	//
	// - [name] specifies a human readable name for this asset.
	// - [symbol] specifies a human readable abbreviation for this asset.
	// - [denomination] specifies how many times the asset can be split. For
	//   example, a denomination of [4] would mean that the smallest unit of the
	//   asset would be 0.001 units.
	// - [initialState] specifies the supported feature extensions for this
	//   asset as well as the initial outputs for the asset.
	NewCreateAssetTx(
		name string,
		symbol string,
		denomination byte,
		initialState map[uint32][]verify.State,
		options ...common.Option,
	) (*avm.CreateAssetTx, error)

	// NewOperationTx performs state changes on the UTXO set. These state
	// changes may be more complex than simple value transfers.
	//
	// - [operations] specifies the state changes to perform.
	NewOperationTx(
		operations []*avm.Operation,
		options ...common.Option,
	) (*avm.OperationTx, error)

	// NewOperationTxMintFT performs a set of state changes that mint new tokens
	// for the requested assets.
	//
	// - [outputs] maps the assetID to the output that should be created for the
	//   asset.
	NewOperationTxMintFT(
		outputs map[ids.ID]*secp256k1fx.TransferOutput,
		options ...common.Option,
	) (*avm.OperationTx, error)

	// NewOperationTxMintNFT performs a state change that mints new NFTs for the
	// requested asset.
	//
	// - [assetID] specifies the asset to mint the NFTs under.
	// - [payload] specifies the payload to provide each new NFT.
	// - [owners] specifies the new owners of each NFT.
	NewOperationTxMintNFT(
		assetID ids.ID,
		payload []byte,
		owners []*secp256k1fx.OutputOwners,
		options ...common.Option,
	) (*avm.OperationTx, error)

	// NewOperationTxMintProperty performs a state change that mints a new
	// property for the requested asset.
	//
	// - [assetID] specifies the asset to mint the property under.
	// - [owner] specifies the new owner of the property.
	NewOperationTxMintProperty(
		assetID ids.ID,
		owner *secp256k1fx.OutputOwners,
		options ...common.Option,
	) (*avm.OperationTx, error)

	// NewOperationTxBurnProperty performs state changes that burns all the
	// properties of the requested asset.
	//
	// - [assetID] specifies the asset to burn the property of.
	NewOperationTxBurnProperty(
		assetID ids.ID,
		options ...common.Option,
	) (*avm.OperationTx, error)

	// NewImportTx creates an import transaction that attempts to consume all
	// the available UTXOs and import the funds to [to].
	//
	// - [chainID] specifies the chain to be importing funds from.
	// - [to] specifies where to send the imported funds to.
	NewImportTx(
		chainID ids.ID,
		to *secp256k1fx.OutputOwners,
		options ...common.Option,
	) (*avm.ImportTx, error)

	// NewExportTx creates an export transaction that attempts to send all the
	// provided [outputs] to the requested [chainID].
	//
	// - [chainID] specifies the chain to be exporting the funds to.
	// - [outputs] specifies the outputs to send to the [chainID].
	NewExportTx(
		chainID ids.ID,
		outputs []*djtx.TransferableOutput,
		options ...common.Option,
	) (*avm.ExportTx, error)
}

Builder provides a convenient interface for building unsigned X-chain transactions.

func NewBuilder

func NewBuilder(addrs ids.ShortSet, backend BuilderBackend) Builder

NewBuilder returns a new transaction builder.

• [addrs] is the set of addresses that the builder assumes can be used when signing the transactions in the future.
• [backend] provides the required access to the chain's context and state to build out the transactions.

func NewBuilderWithOptions

func NewBuilderWithOptions(builder Builder, options ...common.Option) Builder

NewBuilderWithOptions returns a new transaction builder that will use the given options by default.

• [builder] is the builder that will be called to perform the underlying opterations.
• [options] will be provided to the builder in addition to the options provided in the method calls.

type BuilderBackend

type BuilderBackend interface {
	Context

	UTXOs(ctx stdcontext.Context, sourceChainID ids.ID) ([]*djtx.UTXO, error)
}

BuilderBackend specifies the required information needed to build unsigned X-chain transactions.

type ChainUTXOs

type ChainUTXOs interface {
	AddUTXO(ctx stdcontext.Context, destinationChainID ids.ID, utxo *djtx.UTXO) error
	RemoveUTXO(ctx stdcontext.Context, sourceChainID, utxoID ids.ID) error

	UTXOs(ctx stdcontext.Context, sourceChainID ids.ID) ([]*djtx.UTXO, error)
	GetUTXO(ctx stdcontext.Context, sourceChainID, utxoID ids.ID) (*djtx.UTXO, error)
}

type Context

type Context interface {
	NetworkID() uint32
	HRP() string
	BlockchainID() ids.ID
	DJTXAssetID() ids.ID
	BaseTxFee() uint64
	CreateAssetTxFee() uint64
}

func NewContext

func NewContext(
	networkID uint32,
	blockchainID ids.ID,
	djtxAssetID ids.ID,
	baseTxFee uint64,
	createAssetTxFee uint64,
) Context

func NewContextFromClients

func NewContextFromClients(
	ctx stdcontext.Context,
	infoClient info.Client,
	xChainClient avm.Client,
) (Context, error)

func NewContextFromURI

func NewContextFromURI(ctx stdcontext.Context, uri string) (Context, error)

type Signer

type Signer interface {
	SignUnsigned(ctx stdcontext.Context, tx avm.UnsignedTx) (*avm.Tx, error)
	Sign(ctx stdcontext.Context, tx *avm.Tx) error
}

func NewSigner

func NewSigner(kc *secp256k1fx.Keychain, backend SignerBackend) Signer

type SignerBackend

type SignerBackend interface {
	GetUTXO(ctx stdcontext.Context, chainID, utxoID ids.ID) (*djtx.UTXO, error)
}

type Wallet

type Wallet interface {
	Context

	// Builder returns the builder that will be used to create the transactions.
	Builder() Builder

	// Signer returns the signer that will be used to sign the transactions.
	Signer() Signer

	// IssueBaseTx creates, signs, and issues a new simple value transfer.
	//
	// - [outputs] specifies all the recipients and amounts that should be sent
	//   from this transaction.
	IssueBaseTx(
		outputs []*djtx.TransferableOutput,
		options ...common.Option,
	) (ids.ID, error)

	// IssueCreateAssetTx creates, signs, and issues a new asset.
	//
	// - [name] specifies a human readable name for this asset.
	// - [symbol] specifies a human readable abbreviation for this asset.
	// - [denomination] specifies how many times the asset can be split. For
	//   example, a denomination of [4] would mean that the smallest unit of the
	//   asset would be 0.001 units.
	// - [initialState] specifies the supported feature extensions for this
	//   asset as well as the initial outputs for the asset.
	IssueCreateAssetTx(
		name string,
		symbol string,
		denomination byte,
		initialState map[uint32][]verify.State,
		options ...common.Option,
	) (ids.ID, error)

	// IssueOperationTx creates, signs, and issues state changes on the UTXO
	// set. These state changes may be more complex than simple value transfers.
	//
	// - [operations] specifies the state changes to perform.
	IssueOperationTx(
		operations []*avm.Operation,
		options ...common.Option,
	) (ids.ID, error)

	// IssueOperationTxMintFT creates, signs, and issues a set of state changes
	// that mint new tokens for the requested assets.
	//
	// - [outputs] maps the assetID to the output that should be created for the
	//   asset.
	IssueOperationTxMintFT(
		outputs map[ids.ID]*secp256k1fx.TransferOutput,
		options ...common.Option,
	) (ids.ID, error)

	// IssueOperationTxMintNFT creates, signs, and issues a state change that
	// mints new NFTs for the requested asset.
	//
	// - [assetID] specifies the asset to mint the NFTs under.
	// - [payload] specifies the payload to provide each new NFT.
	// - [owners] specifies the new owners of each NFT.
	IssueOperationTxMintNFT(
		assetID ids.ID,
		payload []byte,
		owners []*secp256k1fx.OutputOwners,
		options ...common.Option,
	) (ids.ID, error)

	// IssueOperationTxMintProperty creates, signs, and issues a state change
	// that mints a new property for the requested asset.
	//
	// - [assetID] specifies the asset to mint the property under.
	// - [owner] specifies the new owner of the property.
	IssueOperationTxMintProperty(
		assetID ids.ID,
		owner *secp256k1fx.OutputOwners,
		options ...common.Option,
	) (ids.ID, error)

	// IssueOperationTxBurnProperty creates, signs, and issues state changes
	// that burns all the properties of the requested asset.
	//
	// - [assetID] specifies the asset to burn the property of.
	IssueOperationTxBurnProperty(
		assetID ids.ID,
		options ...common.Option,
	) (ids.ID, error)

	// IssueImportTx creates, signs, and issues an import transaction that
	// attempts to consume all the available UTXOs and import the funds to [to].
	//
	// - [chainID] specifies the chain to be importing funds from.
	// - [to] specifies where to send the imported funds to.
	IssueImportTx(
		chainID ids.ID,
		to *secp256k1fx.OutputOwners,
		options ...common.Option,
	) (ids.ID, error)

	// IssueExportTx creates, signs, and issues an export transaction that
	// attempts to send all the provided [outputs] to the requested [chainID].
	//
	// - [chainID] specifies the chain to be exporting the funds to.
	// - [outputs] specifies the outputs to send to the [chainID].
	IssueExportTx(
		chainID ids.ID,
		outputs []*djtx.TransferableOutput,
		options ...common.Option,
	) (ids.ID, error)

	// IssueUnsignedTx signs and issues the unsigned tx.
	IssueUnsignedTx(
		utx avm.UnsignedTx,
		options ...common.Option,
	) (ids.ID, error)

	// IssueTx issues the signed tx.
	IssueTx(
		tx *avm.Tx,
		options ...common.Option,
	) (ids.ID, error)
}

func NewWallet

func NewWallet(
	builder Builder,
	signer Signer,
	client avm.Client,
	backend Backend,
) Wallet

func NewWalletWithOptions

func NewWalletWithOptions(
	wallet Wallet,
	options ...common.Option,
) Wallet