primary

package
v1.12.0-rc.1 Latest Latest
Warning

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

 Go to latest Published: Dec 2, 2024 License: BSD-3-Clause Imports: 25 Imported by: 47

Documentation

Index

Examples

Constants

View Source 
const (
	MainnetAPIURI = "https://api.avax.network"
	FujiAPIURI    = "https://api.avax-test.network"
	LocalAPIURI   = "http://localhost:9650"
)

Variables

This section is empty.

Functions

func AddAllUTXOs 

func AddAllUTXOs(
	ctx context.Context,
	utxos walletcommon.UTXOs,
	client UTXOClient,
	codec codec.Manager,
	sourceChainID ids.ID,
	destinationChainID ids.ID,
	addrs []ids.ShortID,
) error

AddAllUTXOs fetches all the UTXOs referenced by [addresses] that were sent from [sourceChainID] to [destinationChainID] from the [client]. It then uses codec to parse the returned UTXOs and it adds them into [utxos]. If [ctx] expires, then the returned error will be immediately reported.

func FetchPState 

func FetchPState(
	ctx context.Context,
	uri string,
	addrs set.Set[ids.ShortID],
) (
	platformvm.Client,
	*pbuilder.Context,
	walletcommon.UTXOs,
	error,
)

func MakePWallet 

func MakePWallet(
	ctx context.Context,
	uri string,
	keychain keychain.Keychain,
	config WalletConfig,
) (pwallet.Wallet, error)

MakePWallet returns a P-chain wallet that supports issuing transactions.

On creation, the wallet attaches to the provided uri and fetches all UTXOs that reference any of the provided keys. If the UTXOs are modified through an external issuance process, such as another instance of the wallet, the UTXOs may become out of sync. The wallet will also fetch all requested P-chain owners.

The wallet manages all state locally, and performs all tx signing locally.

Types

type AVAXState added in v1.10.9 

type AVAXState struct {
	PClient platformvm.Client
	PCTX    *pbuilder.Context
	XClient avm.Client
	XCTX    *xbuilder.Context
	CClient evm.Client
	CCTX    *c.Context
	UTXOs   walletcommon.UTXOs
}

func FetchState added in v1.7.8 

func FetchState(
	ctx context.Context,
	uri string,
	addrs set.Set[ids.ShortID],
) (
	*AVAXState,
	error,
)

type EthState added in v1.10.9 

type EthState struct {
	Client   ethclient.Client
	Accounts map[ethcommon.Address]*c.Account
}

func FetchEthState added in v1.10.9 

func FetchEthState(
	ctx context.Context,
	uri string,
	addrs set.Set[ethcommon.Address],
) (*EthState, error)

type UTXOClient 

type UTXOClient interface {
	GetAtomicUTXOs(
		ctx context.Context,
		addrs []ids.ShortID,
		sourceChain string,
		limit uint32,
		startAddress ids.ShortID,
		startUTXOID ids.ID,
		options ...rpc.Option,
	) ([][]byte, ids.ShortID, ids.ID, error)
}

type Wallet 

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

Wallet provides chain wallets for the primary network.

Example 
ctx := context.Background()
kc := secp256k1fx.NewKeychain(genesis.EWOQKey)

// MakeWallet fetches the available UTXOs owned by [kc] on the network that
// [LocalAPIURI] is hosting.
walletSyncStartTime := time.Now()
wallet, err := MakeWallet(
	ctx,
	LocalAPIURI,
	kc,
	kc,
	WalletConfig{},
)
if err != nil {
	log.Fatalf("failed to initialize wallet with: %s\n", err)
	return
}
log.Printf("synced wallet in %s\n", time.Since(walletSyncStartTime))

// Get the P-chain and the X-chain wallets
pWallet := wallet.P()
xWallet := wallet.X()
xBuilder := xWallet.Builder()
xContext := xBuilder.Context()

// Pull out useful constants to use when issuing transactions.
xChainID := xContext.BlockchainID
owner := &secp256k1fx.OutputOwners{
	Threshold: 1,
	Addrs: []ids.ShortID{
		genesis.EWOQKey.PublicKey().Address(),
	},
}

// Create a custom asset to send to the P-chain.
createAssetStartTime := time.Now()
createAssetTx, err := xWallet.IssueCreateAssetTx(
	"RnM",
	"RNM",
	9,
	map[uint32][]verify.State{
		0: {
			&secp256k1fx.TransferOutput{
				Amt:          100 * units.MegaAvax,
				OutputOwners: *owner,
			},
		},
	},
)
if err != nil {
	log.Fatalf("failed to create new X-chain asset with: %s\n", err)
	return
}
createAssetTxID := createAssetTx.ID()
log.Printf("created X-chain asset %s in %s\n", createAssetTxID, time.Since(createAssetStartTime))

// Send 100 MegaAvax to the P-chain.
exportStartTime := time.Now()
exportTx, err := xWallet.IssueExportTx(
	constants.PlatformChainID,
	[]*avax.TransferableOutput{
		{
			Asset: avax.Asset{
				ID: createAssetTxID,
			},
			Out: &secp256k1fx.TransferOutput{
				Amt:          100 * units.MegaAvax,
				OutputOwners: *owner,
			},
		},
	},
)
if err != nil {
	log.Fatalf("failed to issue X->P export transaction with: %s\n", err)
	return
}
exportTxID := exportTx.ID()
log.Printf("issued X->P export %s in %s\n", exportTxID, time.Since(exportStartTime))

// Import the 100 MegaAvax from the X-chain into the P-chain.
importStartTime := time.Now()
importTx, err := pWallet.IssueImportTx(xChainID, owner)
if err != nil {
	log.Fatalf("failed to issue X->P import transaction with: %s\n", err)
	return
}
importTxID := importTx.ID()
log.Printf("issued X->P import %s in %s\n", importTxID, time.Since(importStartTime))

createSubnetStartTime := time.Now()
createSubnetTx, err := pWallet.IssueCreateSubnetTx(owner)
if err != nil {
	log.Fatalf("failed to issue create subnet transaction with: %s\n", err)
	return
}
createSubnetTxID := createSubnetTx.ID()
log.Printf("issued create subnet transaction %s in %s\n", createSubnetTxID, time.Since(createSubnetStartTime))

transformSubnetStartTime := time.Now()
transformSubnetTx, err := pWallet.IssueTransformSubnetTx(
	createSubnetTxID,
	createAssetTxID,
	50*units.MegaAvax,
	100*units.MegaAvax,
	reward.PercentDenominator,
	reward.PercentDenominator,
	1,
	100*units.MegaAvax,
	time.Second,
	365*24*time.Hour,
	0,
	1,
	5,
	.80*reward.PercentDenominator,
)
if err != nil {
	log.Fatalf("failed to issue transform subnet transaction with: %s\n", err)
	return
}
transformSubnetTxID := transformSubnetTx.ID()
log.Printf("issued transform subnet transaction %s in %s\n", transformSubnetTxID, time.Since(transformSubnetStartTime))

addPermissionlessValidatorStartTime := time.Now()
startTime := time.Now().Add(time.Minute)
addSubnetValidatorTx, err := pWallet.IssueAddPermissionlessValidatorTx(
	&txs.SubnetValidator{
		Validator: txs.Validator{
			NodeID: genesis.LocalConfig.InitialStakers[0].NodeID,
			Start:  uint64(startTime.Unix()),
			End:    uint64(startTime.Add(5 * time.Second).Unix()),
			Wght:   25 * units.MegaAvax,
		},
		Subnet: createSubnetTxID,
	},
	&signer.Empty{},
	createAssetTx.ID(),
	&secp256k1fx.OutputOwners{},
	&secp256k1fx.OutputOwners{},
	reward.PercentDenominator,
)
if err != nil {
	log.Fatalf("failed to issue add subnet validator with: %s\n", err)
	return
}
addSubnetValidatorTxID := addSubnetValidatorTx.ID()
log.Printf("issued add subnet validator transaction %s in %s\n", addSubnetValidatorTxID, time.Since(addPermissionlessValidatorStartTime))

addPermissionlessDelegatorStartTime := time.Now()
addSubnetDelegatorTx, err := pWallet.IssueAddPermissionlessDelegatorTx(
	&txs.SubnetValidator{
		Validator: txs.Validator{
			NodeID: genesis.LocalConfig.InitialStakers[0].NodeID,
			Start:  uint64(startTime.Unix()),
			End:    uint64(startTime.Add(5 * time.Second).Unix()),
			Wght:   25 * units.MegaAvax,
		},
		Subnet: createSubnetTxID,
	},
	createAssetTxID,
	&secp256k1fx.OutputOwners{},
)
if err != nil {
	log.Fatalf("failed to issue add subnet delegator with: %s\n", err)
	return
}
addSubnetDelegatorTxID := addSubnetDelegatorTx.ID()
log.Printf("issued add subnet validator delegator %s in %s\n", addSubnetDelegatorTxID, time.Since(addPermissionlessDelegatorStartTime))

Output:

func MakeWallet added in v1.10.9 

func MakeWallet(
	ctx context.Context,
	uri string,
	avaxKeychain keychain.Keychain,
	ethKeychain c.EthKeychain,
	config WalletConfig,
) (*Wallet, error)

MakeWallet returns a wallet that supports issuing transactions to the chains living in the primary network.

On creation, the wallet attaches to the provided uri and fetches all UTXOs that reference any of the provided keys. If the UTXOs are modified through an external issuance process, such as another instance of the wallet, the UTXOs may become out of sync. The wallet will also fetch all requested P-chain owners.

The wallet manages all state locally, and performs all tx signing locally.

func NewWallet 

func NewWallet(p pwallet.Wallet, x x.Wallet, c c.Wallet) *Wallet

Creates a new default wallet

func NewWalletWithOptions 

func NewWalletWithOptions(w *Wallet, options ...common.Option) *Wallet

Creates a Wallet with the given set of options

func (*Wallet) C added in v1.10.9 

func (w *Wallet) C() c.Wallet

func (*Wallet) P 

func (w *Wallet) P() pwallet.Wallet

func (*Wallet) X 

func (w *Wallet) X() x.Wallet

type WalletConfig added in v1.10.9 

type WalletConfig struct {
	// Subnet IDs that the wallet should know about to be able to generate
	// transactions.
	SubnetIDs []ids.ID // optional
	// Validation IDs that the wallet should know about to be able to generate
	// transactions.
	ValidationIDs []ids.ID // optional
}

Source Files

View all Source files

Directories

Path Synopsis
utxotest
examples
add-permissioned-subnet-validator
add-primary-validator
c-chain-export
c-chain-import
convert-subnet-to-l1
create-asset
create-chain
create-locked-stakeable
create-subnet
disable-l1-validator
get-p-chain-balance
get-x-chain-balance
increase-l1-validator-balance
register-l1-validator
remove-subnet-validator
set-l1-validator-weight
sign-l1-validator-registration
sign-l1-validator-removal-genesis
sign-l1-validator-removal-registration
sign-l1-validator-weight
sign-subnet-to-l1-conversion

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.