libgoal

package
v0.0.2 Latest Latest
Warning

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

 Go to latest Published: Nov 24, 2019 License: AGPL-3.0 Imports: 22 Imported by: 0

Documentation

Index

Constants

View Source 
const DefaultKMDDataDir = nodecontrol.DefaultKMDDataDir

DefaultKMDDataDir is the name of the directory within the algod data directory where kmd data goes

Variables

View Source 
var UnencryptedWalletName = []byte("unencrypted-default-wallet")

UnencryptedWalletName is the name of the default, unencrypted wallet

Functions

func AlgorandDataIsPrivate 

func AlgorandDataIsPrivate(dataDir string) bool

AlgorandDataIsPrivate returns true if the algod data dir can be considered 'private' and we can store all related data there. Otherwise, some data will likely go under ${HOME}/.algorand/

Types

type Client 

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

Client represents the entry point for all libgoal functions

func MakeClient 

func MakeClient(dataDir, cacheDir string, clientType ClientType) (c Client, err error)

MakeClient creates and inits a libgoal.Client

func MakeClientFromConfig 

func MakeClientFromConfig(config ClientConfig, clientType ClientType) (c Client, err error)

MakeClientFromConfig creates a libgoal.Client from a config struct with many options.

func MakeClientWithBinDir 

func MakeClientWithBinDir(binDir, dataDir, cacheDir string, clientType ClientType) (c Client, err error)

MakeClientWithBinDir creates and inits a libgoal.Client, additionally allowing the user to specify a binary directory

func (*Client) AccountInformation 

func (c *Client) AccountInformation(account string) (resp v1.Account, err error)

AccountInformation takes an address and returns its information

func (Client) AlgodVersions 

func (c Client) AlgodVersions() (resp common.Version, err error)

AlgodVersions return the list of supported API versions in algod

func (*Client) AssetInformation 

func (c *Client) AssetInformation(index uint64) (resp v1.AssetParams, err error)

AssetInformation takes an asset's index and returns its information

func (*Client) Block 

func (c *Client) Block(round uint64) (resp v1.Block, err error)

Block takes a round and returns its block

func (*Client) BroadcastTransaction 

func (c *Client) BroadcastTransaction(stx transactions.SignedTxn) (txid string, err error)

BroadcastTransaction broadcasts a signed transaction to the network using algod

func (*Client) BroadcastTransactionBytes added in v0.0.2 

func (c *Client) BroadcastTransactionBytes(bytes []byte) (txid string, err error)

func (*Client) BroadcastTransactionGroup 

func (c *Client) BroadcastTransactionGroup(txgroup []transactions.SignedTxn) error

BroadcastTransactionGroup broadcasts a signed transaction group to the network using algod

func (*Client) ComputeValidityRounds 

func (c *Client) ComputeValidityRounds(firstValid, lastValid, validRounds uint64) (uint64, uint64, error)

ComputeValidityRounds takes first, last and rounds provided by a user and resolves them into actual firstValid and lastValid. Resolution table

validRounds | lastValid | result (lastValid) ------------------------------------------------- 

  	 0     |     0     | firstValid + maxTxnLife
	 0     |     N     | lastValid
	 M     |     0     | first + validRounds - 1
	 M     |     M     | error

func (*Client) ConsensusParams 

func (c *Client) ConsensusParams(round uint64) (consensus config.ConsensusParams, err error)

ConsensusParams returns the consensus parameters for the protocol active at the specified round

func (*Client) ConstructPayment 

func (c *Client) ConstructPayment(from, to string, fee, amount uint64, note []byte, closeTo string, lease [32]byte, firstValid, lastValid basics.Round) (transactions.Transaction, error)

ConstructPayment builds a payment transaction to be signed If the fee is 0, the function will use the suggested one form the network Although firstValid and lastValid come pre-computed in a normal flow, additional validation is done by computeValidityRounds: if the lastValid is 0, firstValid + maxTxnLifetime will be used if the firstValid is 0, lastRound + 1 will be used

func (*Client) CreateMultisigAccount 

func (c *Client) CreateMultisigAccount(walletHandle []byte, threshold uint8, addrs []string) (string, error)

CreateMultisigAccount takes a wallet handle, a list of (nonmultisig) addresses, and a threshold and creates (and returns) a multisig adress TODO: Should these be raw public keys instead of addresses so users can't shoot themselves in the foot by passing in a multisig addr? Probably will become irrelevant after CSID changes.

func (*Client) CreateWallet 

func (c *Client) CreateWallet(name []byte, password []byte, mdk crypto.MasterDerivationKey) ([]byte, error)

CreateWallet creates a kmd wallet with the specified parameters

func (Client) CurrentRound 

func (c Client) CurrentRound() (lastRound uint64, err error)

CurrentRound returns the current known round

func (*Client) DataDir 

func (c *Client) DataDir() string

DataDir returns the Algorand's client data directory path

func (*Client) DeleteAccount 

func (c *Client) DeleteAccount(walletHandle []byte, walletPassword []byte, addr string) error

DeleteAccount deletes an account.

func (*Client) DeleteMultisigAccount 

func (c *Client) DeleteMultisigAccount(walletHandle []byte, walletPassword []byte, addr string) error

DeleteMultisigAccount deletes a multisig account.

func (*Client) ExportKey 

func (c *Client) ExportKey(walletHandle []byte, password, account string) (resp kmdapi.APIV1POSTKeyExportResponse, err error)

ExportKey exports the private key of the passed account, assuming it's available

func (*Client) ExportMasterDerivationKey 

func (c *Client) ExportMasterDerivationKey(wh []byte, pw []byte) (mdk crypto.MasterDerivationKey, err error)

ExportMasterDerivationKey returns the master derivation key from the given wallet

func (*Client) FillUnsignedTxTemplate 

func (c *Client) FillUnsignedTxTemplate(sender string, firstValid, lastValid, fee uint64, tx transactions.Transaction) (transactions.Transaction, error)

FillUnsignedTxTemplate fills in header fields in a partially-filled-in transaction.

func (*Client) FindWalletIDByName 

func (c *Client) FindWalletIDByName(name []byte) (wid []byte, duplicate bool, err error)

FindWalletIDByName searches the list of wallets for one with the passed name, and returns its ID. If there is more than one wallet with the passed name, it sets duplicate to true.

func (*Client) FindWalletNameByID 

func (c *Client) FindWalletNameByID(wid []byte) (name []byte, duplicate bool, err error)

FindWalletNameByID searches the list of wallets for one with the passed ID, and returns its name. If there is more than one wallet with the passed ID, it sets duplicate to true.

func (*Client) FullStop 

func (c *Client) FullStop() error

FullStop stops the clients including graceful shutdown to algod and kmd

func (*Client) GenParticipationKeys 

func (c *Client) GenParticipationKeys(address string, firstValid, lastValid, keyDilution uint64) (part account.Participation, filePath string, err error)

GenParticipationKeys creates a .partkey database for a given address, fills it with keys, and installs it in the right place

func (*Client) GenParticipationKeysTo 

func (c *Client) GenParticipationKeysTo(address string, firstValid, lastValid, keyDilution uint64, outDir string) (part account.Participation, filePath string, err error)

GenParticipationKeysTo creates a .partkey database for a given address, fills it with keys, and saves it in the specified output directory.

func (*Client) GenerateAddress 

func (c *Client) GenerateAddress(walletHandle []byte) (string, error)

GenerateAddress takes a wallet handle, generate an additional address for it and returns the public address

func (*Client) GenesisID 

func (c *Client) GenesisID() (string, error)

GenesisID fetches the genesis ID for the running algod node

func (*Client) GetBalance 

func (c *Client) GetBalance(address string) (uint64, error)

GetBalance takes an address and returns its total balance; if the address doesn't exist, it returns 0.

func (*Client) GetPendingTransactions 

func (c *Client) GetPendingTransactions(maxTxns uint64) (resp v1.PendingTransactions, err error)

GetPendingTransactions gets a snapshot of current pending transactions on the node. If maxTxns = 0, fetches as many transactions as possible.

func (*Client) GetUnencryptedWalletHandle 

func (c *Client) GetUnencryptedWalletHandle() ([]byte, error)

GetUnencryptedWalletHandle returns the unencrypted wallet handle. If there is no unencrypted wallet, it creates one first. This should never be used outside of tests, because it creates a wallet named unencrypted-default-wallet if it doesn't exist.

func (*Client) GetWalletHandleToken 

func (c *Client) GetWalletHandleToken(wid, pw []byte) ([]byte, error)

GetWalletHandleToken inits the wallet with the given id, returning a wallet handle token

func (*Client) GetWalletHandleTokenCached 

func (c *Client) GetWalletHandleTokenCached(walletID, pw []byte) ([]byte, error)

GetWalletHandleTokenCached first checks the cache for a valid token for this wallet and renews it if possible. If there aren't any valid cached tokens, it generates a new one and adds it to the cache.

func (*Client) GroupID 

func (c *Client) GroupID(txgroup []transactions.Transaction) (gid crypto.Digest, err error)

GroupID computes the group ID for a group of transactions.

func (*Client) HealthCheck 

func (c *Client) HealthCheck() error

HealthCheck returns an error if something is wrong

func (*Client) ImportKey 

func (c *Client) ImportKey(walletHandle []byte, secretKey []byte) (response kmdapi.APIV1POSTKeyImportResponse, err error)

ImportKey wraps imports a secret key into the kmd wallet using the passed walletHandle

func (*Client) InstallParticipationKeys 

func (c *Client) InstallParticipationKeys(inputfile string) (part account.Participation, filePath string, err error)

InstallParticipationKeys creates a .partkey database for a given address, based on an existing database from inputfile. On successful install, it deletes the input file.

func (Client) LedgerSupply 

func (c Client) LedgerSupply() (resp v1.Supply, err error)

LedgerSupply returns the total number of algos in the system

func (*Client) ListAddresses 

func (c *Client) ListAddresses(walletHandle []byte) ([]string, error)

ListAddresses takes a wallet handle and returns the list of addresses associated with it. If no addresses are associated with the wallet, it returns an empty list.

func (*Client) ListAddressesWithInfo 

func (c *Client) ListAddressesWithInfo(walletHandle []byte) ([]ListedAddress, error)

ListAddressesWithInfo takes a wallet handle and returns the list of addresses associated with it, along with additional information to indicate if an address is multisig or not. If no addresses are associated with the wallet, it returns an empty list.

func (*Client) ListParticipationKeys 

func (c *Client) ListParticipationKeys() (partKeyFiles map[string]account.Participation, err error)

ListParticipationKeys returns the available participation keys, as a map from database filename to Participation key object.

func (*Client) ListWallets 

func (c *Client) ListWallets() (wallets []kmdapi.APIV1Wallet, err error)

ListWallets returns the list of wallets that kmd is aware of

func (*Client) LookupMultisigAccount 

func (c *Client) LookupMultisigAccount(walletHandle []byte, multisigAddr string) (info MultisigInfo, err error)

LookupMultisigAccount returns the threshold and public keys for a multisig address.

func (*Client) MakeUnsignedAssetConfigTx 

func (c *Client) MakeUnsignedAssetConfigTx(creator string, index uint64, newManager *string, newReserve *string, newFreeze *string, newClawback *string) (transactions.Transaction, error)

MakeUnsignedAssetConfigTx creates a tx template for changing the keys for an asset. A nil pointer for a new key argument means no change to existing key. An empty string means a zero key (which cannot be changed after becoming zero).

Call FillUnsignedTxTemplate afterwards to fill out common fields in the resulting transaction template.

func (*Client) MakeUnsignedAssetCreateTx 

func (c *Client) MakeUnsignedAssetCreateTx(total uint64, defaultFrozen bool, manager string, reserve string, freeze string, clawback string, unitName string, assetName string, url string, metadataHash []byte) (transactions.Transaction, error)

MakeUnsignedAssetCreateTx creates a tx template for creating an asset.

Call FillUnsignedTxTemplate afterwards to fill out common fields in the resulting transaction template.

func (*Client) MakeUnsignedAssetDestroyTx 

func (c *Client) MakeUnsignedAssetDestroyTx(index uint64) (transactions.Transaction, error)

MakeUnsignedAssetDestroyTx creates a tx template for destroying an asset.

Call FillUnsignedTxTemplate afterwards to fill out common fields in the resulting transaction template.

func (*Client) MakeUnsignedAssetFreezeTx 

func (c *Client) MakeUnsignedAssetFreezeTx(index uint64, accountToChange string, newFreezeSetting bool) (transactions.Transaction, error)

MakeUnsignedAssetFreezeTx creates a tx template for freezing assets.

Call FillUnsignedTxTemplate afterwards to fill out common fields in the resulting transaction template.

func (*Client) MakeUnsignedAssetSendTx 

func (c *Client) MakeUnsignedAssetSendTx(index uint64, amount uint64, recipient string, closeTo string, senderForClawback string) (transactions.Transaction, error)

MakeUnsignedAssetSendTx creates a tx template for sending assets. To allocate a slot for a particular asset, send a zero amount to self.

Call FillUnsignedTxTemplate afterwards to fill out common fields in the resulting transaction template.

func (*Client) MakeUnsignedBecomeNonparticipatingTx 

func (c *Client) MakeUnsignedBecomeNonparticipatingTx(address string, firstValid, lastValid, fee uint64) (transactions.Transaction, error)

MakeUnsignedBecomeNonparticipatingTx creates a transaction that will mark an account as non-participating

func (*Client) MakeUnsignedGoOfflineTx 

func (c *Client) MakeUnsignedGoOfflineTx(address string, firstValid, lastValid, fee uint64, leaseBytes [32]byte) (transactions.Transaction, error)

MakeUnsignedGoOfflineTx creates a transaction that will bring an address offline

func (*Client) MakeUnsignedGoOnlineTx 

func (c *Client) MakeUnsignedGoOnlineTx(address string, part *account.Participation, firstValid, lastValid, fee uint64, leaseBytes [32]byte) (transactions.Transaction, error)

MakeUnsignedGoOnlineTx creates a transaction that will bring an address online using available participation keys

func (*Client) MultisigSignProgramWithWallet 

func (c *Client) MultisigSignProgramWithWallet(walletHandle, pw, program []byte, signerAddr string, partial crypto.MultisigSig) (msig crypto.MultisigSig, err error)

MultisigSignProgramWithWallet creates a multisig (or adds to an existing partial multisig, if one is provided), signing with the key corresponding to the given address and using the specified wallet

func (*Client) MultisigSignTransactionWithWallet 

func (c *Client) MultisigSignTransactionWithWallet(walletHandle, pw []byte, utx transactions.Transaction, signerAddr string, partial crypto.MultisigSig) (msig crypto.MultisigSig, err error)

MultisigSignTransactionWithWallet creates a multisig (or adds to an existing partial multisig, if one is provided), signing with the key corresponding to the given address and using the specified wallet TODO instead of returning MultisigSigs, accept and return blobs

func (*Client) PendingTransactionInformation 

func (c *Client) PendingTransactionInformation(txid string) (resp v1.Transaction, err error)

PendingTransactionInformation returns information about a recently issued transaction based on its txid.

func (*Client) ReleaseWalletHandle 

func (c *Client) ReleaseWalletHandle(wh []byte) error

ReleaseWalletHandle invalidates the passed wallet handle token

func (*Client) SendPaymentFromUnencryptedWallet 

func (c *Client) SendPaymentFromUnencryptedWallet(from, to string, fee, amount uint64, note []byte) (transactions.Transaction, error)

SendPaymentFromUnencryptedWallet signs a transaction using the default wallet and returns the resulted transaction id

func (*Client) SendPaymentFromWallet 

func (c *Client) SendPaymentFromWallet(walletHandle, pw []byte, from, to string, fee, amount uint64, note []byte, closeTo string, firstValid, lastValid basics.Round) (transactions.Transaction, error)

SendPaymentFromWallet signs a transaction using the given wallet and returns the resulted transaction id

func (*Client) SendPaymentFromWalletWithLease 

func (c *Client) SendPaymentFromWalletWithLease(walletHandle, pw []byte, from, to string, fee, amount uint64, note []byte, closeTo string, lease [32]byte, firstValid, lastValid basics.Round) (transactions.Transaction, error)

SendPaymentFromWalletWithLease is like SendPaymentFromWallet, but with a custom lease.

func (*Client) SetKMDStartArgs 

func (c *Client) SetKMDStartArgs(args nodecontrol.KMDStartArgs)

SetKMDStartArgs sets the arguments used when starting kmd

func (*Client) SignAndBroadcastTransaction 

func (c *Client) SignAndBroadcastTransaction(walletHandle, pw []byte, utx transactions.Transaction) (txid string, err error)

SignAndBroadcastTransaction signs the unsigned transaction with keys from the default wallet, and broadcasts it

func (*Client) SignProgramWithWallet 

func (c *Client) SignProgramWithWallet(walletHandle, pw []byte, addr string, program []byte) (signature crypto.Signature, err error)

SignProgramWithWallet signs the passed transaction with keys from the wallet associated with the passed walletHandle

func (*Client) SignTransactionWithWallet 

func (c *Client) SignTransactionWithWallet(walletHandle, pw []byte, utx transactions.Transaction) (stx transactions.SignedTxn, err error)

SignTransactionWithWallet signs the passed transaction with keys from the wallet associated with the passed walletHandle

func (*Client) Status 

func (c *Client) Status() (resp v1.NodeStatus, err error)

Status returns the node status

func (*Client) SuggestedFee 

func (c *Client) SuggestedFee() (fee uint64, err error)

SuggestedFee returns the suggested fee per byte by the network

func (*Client) SuggestedParams 

func (c *Client) SuggestedParams() (params v1.TransactionParams, err error)

SuggestedParams returns the suggested parameters for a new transaction

func (*Client) TransactionInformation 

func (c *Client) TransactionInformation(addr, txid string) (resp v1.Transaction, err error)

TransactionInformation takes an address and associated txid and return its information

func (*Client) UnencryptedMultisigSignTransaction 

func (c *Client) UnencryptedMultisigSignTransaction(utx transactions.Transaction, signerAddr string, partial crypto.MultisigSig) (msig crypto.MultisigSig, err error)

UnencryptedMultisigSignTransaction is MultisigSignTransactionWithWallet for the default wallet

func (*Client) WaitForRound 

func (c *Client) WaitForRound(round uint64) (resp v1.NodeStatus, err error)

WaitForRound takes a round, waits until it appears and returns its status. This function blocks.

func (*Client) WalletIsUnencrypted 

func (c *Client) WalletIsUnencrypted(wid []byte) bool

WalletIsUnencrypted is a helper that checks if the passed wallet ID requires a password. This function will also return false if there are any other errors when contacting kmd. TODO: return errors when the kmd API has proper error codes

type ClientConfig 

type ClientConfig struct {
	// AlgodDataDir is the data dir for `algod`
	AlgodDataDir string

	// KMDDataDir is the data dir for `kmd`, default ${HOME}/.algorand/kmd
	KMDDataDir string

	// CacheDir is a place to store some stuff
	CacheDir string

	// BinDir may be "" and it will be guesed
	BinDir string
}

ClientConfig is data to configure a Client

type ClientType 

type ClientType int

ClientType represents the type of client you need It ensures the specified type(s) can be initialized when the libgoal client is created. Any client type not specified will be initialized on-demand. 

const (
	// DynamicClient creates clients on-demand
	DynamicClient ClientType = iota
	// KmdClient ensures the kmd client can be initialized when created
	KmdClient
	// AlgodClient ensures the algod client can be initialized when created
	AlgodClient
	// FullClient ensures all clients can be initialized when created
	FullClient
)

type ListedAddress 

type ListedAddress struct {
	Addr     string
	Multisig bool
}

ListedAddress is an address returned by ListAddresses, with a flag to indicate whether it's a multisig address.

type MultisigInfo 

type MultisigInfo struct {
	Version   uint8
	Threshold uint8
	PKs       []string
}

MultisigInfo represents the information about a multisig account.

type SystemConfig 

type SystemConfig struct {
	// SharedServer is true if this is a daemon on a multiuser system.
	// If not shared, kmd and other files are often stored under $ALGORAND_DATA when otherwise they might go under $HOME/.algorand/
	SharedServer bool `json:"shared_server,omitempty"`
}

SystemConfig is the json object in $ALGORAND_DATA/system.json

func ReadSystemConfig 

func ReadSystemConfig(dataDir string) (sc SystemConfig, err error)

ReadSystemConfig read and parse $ALGORAND_DATA/system.json

Source Files

View all Source files

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.