Overview
Variables¶
Functions¶
- algos
- assetBulkOptIn
- assetBulkOptOut
- assetOptIn
- assetOptOut
- callApp
- capTransactionFee
- compileTeal
- controlFees
- createApp
- decodeAppState
- deployApp
- encodeLease
- encodeTransactionNote
- ensureFunded
- executePaginatedRequest
- getABIMethodSignature
- getABIReturn
- getAccount
- getAccountAddressAsString
- getAccountAddressAsUint8Array
- getAccountConfigFromEnvironment
- getAlgoClient
- getAlgoIndexerClient
- getAlgoKmdClient
- getAlgoNodeConfig
- getAlgodConfigFromEnvironment
- getAppArgsForABICall
- getAppArgsForTransaction
- getAppBoxNames
- getAppBoxValue
- getAppBoxValueFromABIType
- getAppBoxValues
- getAppBoxValuesFromABIType
- getAppById
- getAppClient
- getAppClientByCreatorAndName
- getAppClientById
- getAppDeploymentTransactionNote
- getAppGlobalState
- getAppLocalState
- getAppOnCompleteAction
- getAtomicTransactionComposerTransactions
- getBoxReference
- getConfigFromEnvOrDefaults
- getCreatorAppsByName
- getDefaultLocalNetConfig
- getDispenserAccount
- getIndexerConfigFromEnvironment
- getKmdWalletAccount
- getLocalNetDispenserAccount
- getOrCreateKmdWalletAccount
- getSenderAddress
- getSenderTransactionSigner
- getTestNetDispenserApiClient
- getTransactionParams
- getTransactionWithSigner
- isLocalNet
- isMainNet
- isSchemaIsBroken
- isTestNet
- lookupAccountByAddress
- lookupAccountCreatedApplicationByAddress
- lookupTransactionById
- microAlgos
- mnemonicAccount
- mnemonicAccountFromEnvironment
- multisigAccount
- performAtomicTransactionComposerDryrun
- performAtomicTransactionComposerSimulate
- performTemplateSubstitution
- performTemplateSubstitutionAndCompile
- persistSourceMaps
- populateAppCallResources
- randomAccount
- rekeyAccount
- rekeyedAccount
- replaceDeployTimeControlParams
- searchTransactions
- sendAtomicTransactionComposer
- sendGroupOfTransactions
- sendTransaction
- signTransaction
- simulateAndPersistResponse
- stripTealComments
- transactionFees
- transactionSignerAccount
- transferAlgos
- transferAsset
- updateApp
- waitForConfirmation
Variables¶
Config¶
• Const
Config: UpdatableConfig
The AlgoKit config. To update it use the configure method.
Defined in¶
MAX_APP_CALL_ACCOUNT_REFERENCES¶
• Const
MAX_APP_CALL_ACCOUNT_REFERENCES: 4
Defined in¶
src/transaction/transaction.ts:29
MAX_APP_CALL_FOREIGN_REFERENCES¶
• Const
MAX_APP_CALL_FOREIGN_REFERENCES: 8
Defined in¶
src/transaction/transaction.ts:28
MAX_TRANSACTION_GROUP_SIZE¶
• Const
MAX_TRANSACTION_GROUP_SIZE: 16
Defined in¶
src/transaction/transaction.ts:27
Functions¶
algos¶
▸ algos(algos
): AlgoAmount
Returns an amount of Algos using AlgoAmount
Parameters¶
Name | Type | Description |
---|---|---|
algos |
number |
The amount in Algos |
Returns¶
Defined in¶
assetBulkOptIn¶
▸ assetBulkOptIn(optIn
, algod
): Promise
\<Record
\<number
, string
>>
Opt in to a list of assets on the Algorand blockchain.
Parameters¶
Name | Type | Description |
---|---|---|
optIn |
AssetBulkOptInOutParams |
The bulk opt-in request. |
algod |
default |
An instance of the Algodv2 class from the algosdk library. |
Returns¶
Promise
\<Record
\<number
, string
>>
A record object where the keys are the asset IDs and the values are the corresponding transaction IDs for successful opt-ins.
Throws
If there is an error during the opt-in process.
Example
algokit.bulkOptIn({ account: account, assetIds: [12345, 67890] }, algod)
Defined in¶
assetBulkOptOut¶
▸ assetBulkOptOut(optOut
, algod
): Promise
\<Record
\<number
, string
>>
Opt out of multiple assets in Algorand blockchain.
Parameters¶
Name | Type | Description |
---|---|---|
optOut |
AssetBulkOptInOutParams |
The bulk opt-out request. |
algod |
default |
An instance of the Algodv2 client used to interact with the Algorand blockchain. |
Returns¶
Promise
\<Record
\<number
, string
>>
A record object containing asset IDs as keys and their corresponding transaction IDs as values.
Throws
If there is an error during the opt-out process.
Example
algokit.bulkOptOut({ account: account, assetIds: [12345, 67890] }, algod)
Defined in¶
assetOptIn¶
▸ assetOptIn(optIn
, algod
): Promise
\<SendTransactionResult
>
Opt-in an account to an asset.
Parameters¶
Name | Type | Description |
---|---|---|
optIn |
AssetOptInParams |
The opt-in definition |
algod |
default |
An algod client |
Returns¶
Promise
\<SendTransactionResult
>
The transaction object and optionally the confirmation if it was sent to the chain (skipSending
is false
or unset)
Example
await algokit.assetOptIn({ account, assetId }, algod)
Defined in¶
assetOptOut¶
▸ assetOptOut(optOut
, algod
): Promise
\<SendTransactionResult
>
Opt-out an account from an asset.
Parameters¶
Name | Type | Description |
---|---|---|
optOut |
AssetOptOutParams |
The opt-in definition |
algod |
default |
An algod client |
Returns¶
Promise
\<SendTransactionResult
>
The transaction object and optionally the confirmation if it was sent to the chain (skipSending
is false
or unset)
Example
await algokit.assetOptOut({ account, assetId, assetCreatorAddress }, algod)
Defined in¶
callApp¶
▸ callApp(call
, algod
): Promise
\<AppCallTransactionResult
>
Issues a call to a given app.
Parameters¶
Name | Type | Description |
---|---|---|
call |
AppCallParams |
The call details. |
algod |
default |
An algod client |
Returns¶
Promise
\<AppCallTransactionResult
>
The result of the call
Defined in¶
capTransactionFee¶
▸ capTransactionFee(transaction
, maxAcceptableFee
): void
Limit the acceptable fee to a defined amount of µALGOs. This also sets the transaction to be flatFee to ensure the transaction only succeeds at the estimated rate.
Parameters¶
Name | Type | Description |
---|---|---|
transaction |
Transaction | SuggestedParams |
The transaction to cap or suggested params object about to be used to create a transaction |
maxAcceptableFee |
AlgoAmount |
The maximum acceptable fee to pay |
Returns¶
void
Defined in¶
src/transaction/transaction.ts:757
compileTeal¶
▸ compileTeal(tealCode
, algod
): Promise
\<CompiledTeal
>
Compiles the given TEAL using algod and returns the result, including source map.
Parameters¶
Name | Type | Description |
---|---|---|
tealCode |
string |
The TEAL code |
algod |
default |
An algod client |
Returns¶
Promise
\<CompiledTeal
>
The information about the compiled file
Defined in¶
controlFees¶
▸ controlFees\<T
>(transaction
, feeControl
): T
Allows for control of fees on a Transaction
or SuggestedParams
object
Type parameters¶
Name | Type |
---|---|
T |
extends Transaction | SuggestedParams |
Parameters¶
Name | Type | Description |
---|---|---|
transaction |
T |
The transaction or suggested params |
feeControl |
Object |
The fee control parameters |
feeControl.fee? |
AlgoAmount |
- |
feeControl.maxFee? |
AlgoAmount |
- |
Returns¶
T
Defined in¶
src/transaction/transaction.ts:780
createApp¶
▸ createApp(create
, algod
): Promise
\<Partial
\<AppCompilationResult
> & AppCallTransactionResult
& AppReference
>
Creates a smart contract app, returns the details of the created app.
Parameters¶
Name | Type | Description |
---|---|---|
create |
CreateAppParams |
The parameters to create the app with |
algod |
default |
An algod client |
Returns¶
Promise
\<Partial
\<AppCompilationResult
> & AppCallTransactionResult
& AppReference
>
The details of the created app, or the transaction to create it if skipSending
and the compilation result
Defined in¶
decodeAppState¶
▸ decodeAppState(state
): AppState
Converts an array of global/local state values from the algod api to a more friendly generic object keyed by the UTF-8 value of the key.
Parameters¶
Name | Type | Description |
---|---|---|
state |
{ key : string ; value : TealValue | EvalDelta }[] |
A global-state , local-state , global-state-deltas or local-state-deltas |
Returns¶
An object keyeed by the UTF-8 representation of the key with various parsings of the values
Defined in¶
deployApp¶
▸ deployApp(deployment
, algod
, indexer?
): Promise
\<Partial
\<AppCompilationResult
> & ConfirmedTransactionResults
& AppMetadata
& { operationPerformed
: "create"
| "update"
; return?
: ABIReturn
} | ConfirmedTransactionResults
& AppMetadata
& { deleteResult
: ConfirmedTransactionResult
; deleteReturn?
: ABIReturn
; operationPerformed
: "replace"
; return?
: ABIReturn
} | AppMetadata
& { operationPerformed
: "nothing"
}>
Idempotently deploy (create, update/delete if changed) an app against the given name via the given creator account, including deploy-time template placeholder substitutions.
To understand the architecture decisions behind this functionality please see https://github.com/algorandfoundation/algokit-cli/blob/main/docs/architecture-decisions/2023-01-12_smart-contract-deployment.md
Note: When using the return from this function be sure to check operationPerformed
to get access to various return properties like transaction
, confirmation
and deleteResult
.
Note: if there is a breaking state schema change to an existing app (and onSchemaBreak
is set to 'replace'
) the existing app will be deleted and re-created.
Note: if there is an update (different TEAL code) to an existing app (and onUpdate
is set to 'replace'
) the existing app will be deleted and re-created.
Parameters¶
Name | Type | Description |
---|---|---|
deployment |
AppDeploymentParams |
The arguments to control the app deployment |
algod |
default |
An algod client |
indexer? |
default |
An indexer client, needed if existingDeployments not passed in |
Returns¶
Promise
\<Partial
\<AppCompilationResult
> & ConfirmedTransactionResults
& AppMetadata
& { operationPerformed
: "create"
| "update"
; return?
: ABIReturn
} | ConfirmedTransactionResults
& AppMetadata
& { deleteResult
: ConfirmedTransactionResult
; deleteReturn?
: ABIReturn
; operationPerformed
: "replace"
; return?
: ABIReturn
} | AppMetadata
& { operationPerformed
: "nothing"
}>
The app reference of the new/existing app
Defined in¶
encodeLease¶
▸ encodeLease(lease?
): Uint8Array
| undefined
Encodes a transaction lease into a 32-byte array ready to be included in an Algorand transaction.
Parameters¶
Name | Type | Description |
---|---|---|
lease? |
string | Uint8Array |
The transaction lease as a string or binary array or null/undefined if there is no lease |
Returns¶
Uint8Array
| undefined
the transaction lease ready for inclusion in a transaction or undefined
if there is no lease
Throws
if the length of the data is > 32 bytes or empty
Example
algokit.encodeLease('UNIQUE_ID')
Example
algokit.encodeLease(new Uint8Array([1, 2, 3]))
Defined in¶
src/transaction/transaction.ts:67
encodeTransactionNote¶
▸ encodeTransactionNote(note?
): Uint8Array
| undefined
Encodes a transaction note into a byte array ready to be included in an Algorand transaction.
Parameters¶
Name | Type | Description |
---|---|---|
note? |
TransactionNote |
The transaction note |
Returns¶
Uint8Array
| undefined
the transaction note ready for inclusion in a transaction
Case on the value of data
this either be:
* null
| undefined
: undefined
* string
: The string value
* Uint8Array: passthrough
* Arc2TransactionNote object: ARC-0002 compatible transaction note
* Else: The object/value converted into a JSON string representation
Defined in¶
src/transaction/transaction.ts:43
ensureFunded¶
▸ ensureFunded\<T
>(funding
, algod
, kmd?
): Promise
\<EnsureFundedReturnType
| undefined
>
Funds a given account using a funding source such that it has a certain amount of algos free to spend (accounting for ALGOs locked in minimum balance requirement).
https://developer.algorand.org/docs/get-details/accounts/#minimum-balance
Type parameters¶
Name | Type |
---|---|
T |
extends EnsureFundedParams |
Parameters¶
Name | Type | Description |
---|---|---|
funding |
T |
The funding configuration of type EnsureFundedParams , including the account to fund, minimum spending balance, and optional parameters. If you set useDispenserApi to true, you must also set ALGOKIT_DISPENSER_ACCESS_TOKEN in your environment variables. |
algod |
default |
An instance of the Algodv2 client. |
kmd? |
default |
An optional instance of the Kmd client. |
Returns¶
Promise
\<EnsureFundedReturnType
| undefined
>
EnsureFundedReturnType
if funds were transferred.undefined
if no funds were needed.
Defined in¶
executePaginatedRequest¶
▸ executePaginatedRequest\<TResult
, TRequest
>(extractItems
, buildRequest
): Promise
\<TResult
[]>
Type parameters¶
Name | Type |
---|---|
TResult |
TResult |
TRequest |
extends Object |
Parameters¶
Name | Type |
---|---|
extractItems |
(response : any ) => TResult [] |
buildRequest |
(nextToken? : string ) => TRequest |
Returns¶
Promise
\<TResult
[]>
Defined in¶
getABIMethodSignature¶
▸ getABIMethodSignature(method
): string
Returns the encoded ABI spec for a given ABI Method
Parameters¶
Name | Type | Description |
---|---|---|
method |
ABIMethodParams | ABIMethod |
The method to return a signature for |
Returns¶
string
The encoded ABI method spec e.g. method_name(uint64,string)string
Defined in¶
getABIReturn¶
▸ getABIReturn(args?
, confirmation?
): ABIReturn
| undefined
Returns any ABI return values for the given app call arguments and transaction confirmation.
Parameters¶
Name | Type | Description |
---|---|---|
args? |
AppCallArgs |
The arguments that were used for the call |
confirmation? |
PendingTransactionResponse |
The transaction confirmation from algod |
Returns¶
ABIReturn
| undefined
The return value for the method call
Defined in¶
getAccount¶
▸ getAccount(account
, algod
, kmdClient?
): Promise
\<Account
| SigningAccount
>
Parameters¶
Name | Type | Description |
---|---|---|
account |
string | { fundWith? : AlgoAmount ; name : string } |
The details of the account to get, either the name identifier (string) or an object with: * name : The name identifier of the account * fundWith : The amount to fund the account with when it gets created (when targeting LocalNet), if not specified then 1000 Algos will be funded from the dispenser account |
algod |
default |
An algod client |
kmdClient? |
default |
An optional KMD client to use to create an account (when targeting LocalNet), if not specified then a default KMD client will be loaded from environment variables |
Returns¶
Promise
\<Account
| SigningAccount
>
The requested account with private key loaded from the environment variables or when targeting LocalNet from KMD (idempotently creating and funding the account)
Deprecated
use mnemonicAccountFromEnvironment instead
Returns an Algorand account with private key loaded by convention based on the given name identifier.
Note: This function expects to run in a Node.js environment.
Convention:¶
- Non-LocalNet: will load process.env['{NAME}_MNEMONIC'] as a mnemonic secret; Note: Be careful how the mnemonic is handled, never commit it into source control and ideally load it via a secret storage service rather than the file system. If process.env['{NAME}_SENDER'] is defined then it will use that for the sender address (i.e. to support rekeyed accounts)
- LocalNet: will load the account from a KMD wallet called {NAME} and if that wallet doesn't exist it will create it and fund the account for you
This allows you to write code that will work seamlessly in production and local development (LocalNet) without manual config locally (including when you reset the LocalNet).
Example
If you have a mnemonic secret loaded into process.env.ACCOUNT_MNEMONIC
then you can call the following to get that private key loaded into an account object:
const account = await getAccount('ACCOUNT', algod)
If that code runs against LocalNet then a wallet called ACCOUNT
will automatically be created with an account that is automatically funded with 1000 (default) ALGOs from the default LocalNet dispenser.
Defined in¶
▸ getAccount(account
, algod
, kmdClient?
): Promise
\<Account
| SigningAccount
>
Parameters¶
Name | Type | Description |
---|---|---|
account |
Object |
The details of the account to get, an object with: * config : Account configuration. To get from environment use getAccountConfigFromEnvironment(accountName) * fundWith : The amount to fund the account with when it gets created (when targeting LocalNet), if not specified then 1000 Algos will be funded from the dispenser account |
account.config |
AccountConfig |
- |
account.fundWith? |
AlgoAmount |
- |
algod |
default |
An algod client |
kmdClient? |
default |
An optional KMD client to use to create an account (when targeting LocalNet), if not specified then a default KMD client will be loaded from environment variables |
Returns¶
Promise
\<Account
| SigningAccount
>
The requested account with private key loaded from the environment variables or when targeting LocalNet from KMD (idempotently creating and funding the account)
Deprecated
use mnemonicAccountFromEnvironment instead Returns an Algorand account with private key loaded by convention based on the given name identifier.
Note: This function expects to run in a Node.js environment.
Example
If you have a mnemonic secret loaded into process.env.ACCOUNT_MNEMONIC
then you can call the following to get that private key loaded into an account object:
const account = await getAccount({config: getAccountConfigFromEnvironment('ACCOUNT')}, algod)
If that code runs against LocalNet then a wallet called ACCOUNT
will automatically be created with an account that is automatically funded with 1000 (default) ALGOs from the default LocalNet dispenser.
Defined in¶
getAccountAddressAsString¶
▸ getAccountAddressAsString(addressEncodedInB64
): string
Returns the string address of an Algorand account from a base64 encoded version of the underlying byte array of the address public key
Parameters¶
Name | Type | Description |
---|---|---|
addressEncodedInB64 |
string |
The base64 encoded version of the underlying byte array of the address public key |
Returns¶
string
Defined in¶
getAccountAddressAsUint8Array¶
▸ getAccountAddressAsUint8Array(account
): Uint8Array
Returns an account's address as a byte array
Parameters¶
Name | Type | Description |
---|---|---|
account |
string | SendTransactionFrom |
Either an account (with private key loaded) or the string address of an account |
Returns¶
Uint8Array
Defined in¶
getAccountConfigFromEnvironment¶
▸ getAccountConfigFromEnvironment(accountName
): AccountConfig
Parameters¶
Name | Type | Description |
---|---|---|
accountName |
string |
account name |
Returns¶
Deprecated
Use algokit.mnemonicAccountFromEnvironment, which doesn't need this function Returns the Account configuration from environment variables
Example
environment variables
{accountName}_MNEMONIC
{accountName}_SENDER
Defined in¶
src/account/get-account-config-from-environment.ts:13
getAlgoClient¶
▸ getAlgoClient(config?
): Algodv2
Returns an algod SDK client that automatically retries on idempotent calls
Parameters¶
Name | Type | Description |
---|---|---|
config? |
AlgoClientConfig |
The config if you want to override the default (getting config from process.env) |
Returns¶
Algodv2
Example
// Uses process.env.ALGOD_SERVER, process.env.ALGOD_PORT and process.env.ALGOD_TOKEN
// Automatically detects if you are using PureStake to switch in the right header name for ALGOD_TOKEN
const algod = getAlgoClient()
await algod.healthCheck().do()
```
**`Example`**
```typescript
const algod = getAlgoClient(getAlgoNodeConfig('testnet', 'algod'))
await algod.healthCheck().do()
Example
const algod = getAlgoClient(getAlgoNodeConfig('mainnet', 'algod'))
await algod.healthCheck().do()
Example
const algod = getAlgoClient({server: 'http://localhost', port: '4001', token: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'})
await algod.healthCheck().do()
Defined in¶
getAlgoIndexerClient¶
▸ getAlgoIndexerClient(config?
): Indexer
Returns an indexer SDK client that automatically retries on idempotent calls
Parameters¶
Name | Type | Description |
---|---|---|
config? |
AlgoClientConfig |
The config if you want to override the default (getting config from process.env) |
Returns¶
Indexer
Example
// Uses process.env.INDEXER_SERVER, process.env.INDEXER_PORT and process.env.INDEXER_TOKEN
// Automatically detects if you are using PureStake to switch in the right header name for INDEXER_TOKEN
const indexer = getAlgoIndexerClient()
await indexer.makeHealthCheck().do()
```
**`Example`**
```typescript
const indexer = getAlgoIndexerClient(getAlgoNodeConfig('testnet', 'indexer'))
await indexer.makeHealthCheck().do()
Example
const indexer = getAlgoIndexerClient(getAlgoNodeConfig('mainnet', 'indexer'))
await indexer.makeHealthCheck().do()
Example
const indexer = getAlgoIndexerClient({server: 'http://localhost', port: '8980', token: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'})
await indexer.makeHealthCheck().do()
Defined in¶
getAlgoKmdClient¶
▸ getAlgoKmdClient(config?
): Kmd
Returns a KMD SDK client that automatically retries on idempotent calls
KMD client allows you to export private keys, which is useful to get the default account in a LocalNet network.
Parameters¶
Name | Type | Description |
---|---|---|
config? |
AlgoClientConfig |
The config if you want to override the default (getting config from process.env) |
Returns¶
Kmd
Example
// Uses process.env.ALGOD_SERVER, process.env.KMD_PORT (or if not specified: port 4002) and process.env.ALGOD_TOKEN
const kmd = getAlgoKmdClient()
```
**`Example`**
```typescript
const kmd = getAlgoKmdClient({server: 'http://localhost', port: '4002', token: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'})
Defined in¶
getAlgoNodeConfig¶
▸ getAlgoNodeConfig(network
, config
): AlgoClientConfig
Returns the Algorand configuration to point to the AlgoNode service
Parameters¶
Name | Type | Description |
---|---|---|
network |
"testnet" | "mainnet" |
Which network to connect to - TestNet or MainNet |
config |
"algod" | "indexer" |
Which algod config to return - Algod or Indexer |
Returns¶
Defined in¶
getAlgodConfigFromEnvironment¶
▸ getAlgodConfigFromEnvironment(): AlgoClientConfig
Retrieve the algod configuration from environment variables (expects to be called from a Node.js environment not algod-side)
Returns¶
Defined in¶
getAppArgsForABICall¶
▸ getAppArgsForABICall(args
, from
): Promise
\<{ appAccounts
: undefined
| string
[] ; appForeignApps
: undefined
| number
[] = args.apps; appForeignAssets
: undefined
| number
[] = args.assets; boxes
: undefined
| BoxReference
[] ; lease
: undefined
| Uint8Array
; method
: ABIMethod
; methodArgs
: (string
| number
| bigint
| boolean
| TransactionWithSigner
| Uint8Array
| ABIValue
[])[] = methodArgs; rekeyTo
: undefined
| string
; sender
: string
; signer
: TransactionSigner
= signer }>
Returns the app args ready to load onto an ABI method call in AtomicTransactionComposer
Parameters¶
Name | Type | Description |
---|---|---|
args |
ABIAppCallArgs |
The ABI app call args |
from |
SendTransactionFrom |
The transaction signer |
Returns¶
Promise
\<{ appAccounts
: undefined
| string
[] ; appForeignApps
: undefined
| number
[] = args.apps; appForeignAssets
: undefined
| number
[] = args.assets; boxes
: undefined
| BoxReference
[] ; lease
: undefined
| Uint8Array
; method
: ABIMethod
; methodArgs
: (string
| number
| bigint
| boolean
| TransactionWithSigner
| Uint8Array
| ABIValue
[])[] = methodArgs; rekeyTo
: undefined
| string
; sender
: string
; signer
: TransactionSigner
= signer }>
The parameters ready to pass into addMethodCall
within AtomicTransactionComposer
Defined in¶
getAppArgsForTransaction¶
▸ getAppArgsForTransaction(args?
): undefined
| { accounts
: undefined
| string
[] ; appArgs
: undefined
| Uint8Array
[] ; boxes
: undefined
| BoxReference
[] ; foreignApps
: undefined
| number
[] = args.apps; foreignAssets
: undefined
| number
[] = args.assets; lease
: undefined
| Uint8Array
}
Returns the app args ready to load onto an app Transaction
object
Parameters¶
Name | Type | Description |
---|---|---|
args? |
RawAppCallArgs |
The app call args |
Returns¶
undefined
| { accounts
: undefined
| string
[] ; appArgs
: undefined
| Uint8Array
[] ; boxes
: undefined
| BoxReference
[] ; foreignApps
: undefined
| number
[] = args.apps; foreignAssets
: undefined
| number
[] = args.assets; lease
: undefined
| Uint8Array
}
The args ready to load into a Transaction
Defined in¶
getAppBoxNames¶
▸ getAppBoxNames(appId
, algod
): Promise
\<BoxName
[]>
Returns the names of the boxes for the given app.
Parameters¶
Name | Type | Description |
---|---|---|
appId |
number | bigint |
The ID of the app return box names for |
algod |
default |
An algod client instance |
Returns¶
Promise
\<BoxName
[]>
The current box names
Defined in¶
getAppBoxValue¶
▸ getAppBoxValue(appId
, boxName
, algod
): Promise
\<Uint8Array
>
Returns the value of the given box name for the given app.
Parameters¶
Name | Type | Description |
---|---|---|
appId |
number | bigint |
The ID of the app return box names for |
boxName |
string | Uint8Array | BoxName |
The name of the box to return either as a string, binary array or BoxName |
algod |
default |
An algod client instance |
Returns¶
Promise
\<Uint8Array
>
The current box value as a byte array
Defined in¶
getAppBoxValueFromABIType¶
▸ getAppBoxValueFromABIType(request
, algod
): Promise
\<ABIValue
>
Returns the value of the given box name for the given app decoded based on the given ABI type.
Parameters¶
Name | Type | Description |
---|---|---|
request |
BoxValueRequestParams |
The parameters for the box value request |
algod |
default |
An algod client instance |
Returns¶
Promise
\<ABIValue
>
The current box value as an ABI value
Defined in¶
getAppBoxValues¶
▸ getAppBoxValues(appId
, boxNames
, algod
): Promise
\<Uint8Array
[]>
Returns the value of the given box names for the given app.
Parameters¶
Name | Type | Description |
---|---|---|
appId |
number |
The ID of the app return box names for |
boxNames |
(string | Uint8Array | BoxName )[] |
The names of the boxes to return either as a string, binary array or BoxName |
algod |
default |
An algod client instance |
Returns¶
Promise
\<Uint8Array
[]>
The current box values as a byte array in the same order as the passed in box names
Defined in¶
getAppBoxValuesFromABIType¶
▸ getAppBoxValuesFromABIType(request
, algod
): Promise
\<ABIValue
[]>
Returns the value of the given box names for the given app decoded based on the given ABI type.
Parameters¶
Name | Type | Description |
---|---|---|
request |
BoxValuesRequestParams |
The parameters for the box value request |
algod |
default |
An algod client instance |
Returns¶
Promise
\<ABIValue
[]>
The current box values as an ABI value in the same order as the passed in box names
Defined in¶
getAppById¶
▸ getAppById(appId
, algod
): Promise
\<Application
>
Gets the current data for the given app from algod.
Parameters¶
Name | Type | Description |
---|---|---|
appId |
number | bigint |
The id of the app |
algod |
default |
An algod client |
Returns¶
Promise
\<Application
>
The data about the app
Defined in¶
getAppClient¶
▸ getAppClient(appDetails
, algod
): ApplicationClient
Create a new ApplicationClient instance
Parameters¶
Name | Type | Description |
---|---|---|
appDetails |
AppSpecAppDetails |
The details of the app |
algod |
default |
An algod instance |
Returns¶
The application client
Example
Resolve by creator and name
const client = algokit.getAppClient(
{
resolveBy: 'creatorAndName',
app: {appSpec},
sender: {account},
creatorAddress: {creator},
findExistingUsing: indexerClient,
},
algodClient,
)
Example
Resolve by id:
const client = algokit.getAppClient(
{
resolveBy: 'id',
app: {appSpec},
sender: {account},
id: {id},
},
algodClient,
)
Defined in¶
getAppClientByCreatorAndName¶
▸ getAppClientByCreatorAndName(appDetails
, algod
): ApplicationClient
Create a new ApplicationClient instance by creator and name
Parameters¶
Name | Type | Description |
---|---|---|
appDetails |
AppSpecAppDetailsByCreatorAndName |
The details of the app by creator and name |
algod |
default |
An algod instance |
Returns¶
The application client
Example
const client = algokit.getAppClientByCreatorAndName(
{
app: {appSpec},
sender: {account},
creatorAddress: {account.addr},
findExistingUsing: {indexerClient},
},
algodClient,
)
Defined in¶
getAppClientById¶
▸ getAppClientById(appDetails
, algod
): ApplicationClient
Create a new ApplicationClient instance by id
Parameters¶
Name | Type | Description |
---|---|---|
appDetails |
AppSpecAppDetailsById |
The details of the app |
algod |
default |
An algod instance |
Returns¶
The application client
Example
const client = algokit.getAppClientById(
{
app: {appSpec},
sender: {account},
id: {id},
},
algodClient,
)
Defined in¶
getAppDeploymentTransactionNote¶
▸ getAppDeploymentTransactionNote(metadata
): Arc2TransactionNote
Return the transaction note for an app deployment.
Parameters¶
Name | Type | Description |
---|---|---|
metadata |
AppDeployMetadata |
The metadata of the deployment |
Returns¶
The transaction note as a utf-8 string
Defined in¶
getAppGlobalState¶
▸ getAppGlobalState(appId
, algod
): Promise
\<AppState
>
Returns the current global state values for the given app ID
Parameters¶
Name | Type | Description |
---|---|---|
appId |
number | bigint |
The ID of the app return global state for |
algod |
default |
An algod client instance |
Returns¶
Promise
\<AppState
>
The current global state
Defined in¶
getAppLocalState¶
▸ getAppLocalState(appId
, account
, algod
): Promise
\<AppState
>
Returns the current global state values for the given app ID and account
Parameters¶
Name | Type | Description |
---|---|---|
appId |
number | bigint |
The ID of the app return global state for |
account |
string | SendTransactionFrom |
Either the string address of an account or an account object for the account to get local state for the given app |
algod |
default |
An algod client instance |
Returns¶
Promise
\<AppState
>
The current local state for the given (app, account) combination
Defined in¶
getAppOnCompleteAction¶
▸ getAppOnCompleteAction(onCompletionAction?
): OnApplicationComplete
Returns an algosdk.OnApplicationComplete
for the given onCompleteAction.
If given undefined
will return OnApplicationComplete.NoOpOC
.
If given an AppCallType
will convert the string enum to the correct underlying algosdk.OnApplicationComplete
.
Parameters¶
Name | Type | Description |
---|---|---|
onCompletionAction? |
AppCallType | OnApplicationComplete |
The on completion action |
Returns¶
OnApplicationComplete
The algosdk.OnApplicationComplete
Defined in¶
getAtomicTransactionComposerTransactions¶
▸ getAtomicTransactionComposerTransactions(atc
): TransactionWithSigner
[]
Returns the array of transactions currently present in the given AtomicTransactionComposer
Parameters¶
Name | Type | Description |
---|---|---|
atc |
AtomicTransactionComposer |
The atomic transaction composer |
Returns¶
TransactionWithSigner
[]
The array of transactions with signers
Defined in¶
src/transaction/transaction.ts:812
getBoxReference¶
▸ getBoxReference(box
): algosdk.BoxReference
Returns a algosdk.BoxReference
given a BoxIdentifier
or BoxReference
.
Parameters¶
Name | Type | Description |
---|---|---|
box |
BoxReference | BoxIdentifier | BoxReference |
The box to return a reference for |
Returns¶
algosdk.BoxReference
The box reference ready to pass into a Transaction
Defined in¶
getConfigFromEnvOrDefaults¶
▸ getConfigFromEnvOrDefaults(): AlgoConfig
Retrieve configurations from environment variables when defined or get defaults (expects to be called from a Node.js environment not algod-side)
Returns¶
Defined in¶
getCreatorAppsByName¶
▸ getCreatorAppsByName(creatorAccount
, indexer
): Promise
\<AppLookup
>
Returns a lookup of name => app metadata (id, address, ...metadata) for all apps created by the given account that have an AppDeployNote
in the transaction note of the creation transaction.
Note: It's recommended this is only called once and then stored since it's a somewhat expensive operation (multiple indexer calls).
Parameters¶
Name | Type | Description |
---|---|---|
creatorAccount |
string | SendTransactionFrom |
The account (with private key loaded) or string address of an account that is the creator of the apps you want to search for |
indexer |
default |
An indexer client |
Returns¶
Promise
\<AppLookup
>
A name-based lookup of the app information (id, address)
Defined in¶
getDefaultLocalNetConfig¶
▸ getDefaultLocalNetConfig(configOrPort
): AlgoClientConfig
Returns the Algorand configuration to point to the default LocalNet
Parameters¶
Name | Type | Description |
---|---|---|
configOrPort |
number | "algod" | "indexer" | "kmd" |
Which algod config to return - algod, kmd, or indexer OR a port number |
Returns¶
Defined in¶
getDispenserAccount¶
▸ getDispenserAccount(algod
, kmd?
): Promise
\<default
| SigningAccount
>
Returns an account (with private key loaded) that can act as a dispenser
If running on LocalNet then it will return the default dispenser account automatically, otherwise it will load the account mnemonic stored in process.env.DISPENSER_MNEMONIC
Parameters¶
Name | Type | Description |
---|---|---|
algod |
default |
An algod client |
kmd? |
default |
A KMD client, if not specified then a default KMD client will be loaded from environment variables |
Returns¶
Promise
\<default
| SigningAccount
>
Defined in¶
src/account/get-dispenser-account.ts:18
getIndexerConfigFromEnvironment¶
▸ getIndexerConfigFromEnvironment(): AlgoClientConfig
Retrieve the indexer configuration from environment variables (expects to be called from a Node.js environment not algod-side)
Returns¶
Defined in¶
getKmdWalletAccount¶
▸ getKmdWalletAccount(walletAccount
, algod
, kmdClient?
): Promise
\<Account
| undefined
>
Returns an Algorand account with private key loaded from the given KMD wallet (identified by name).
Parameters¶
Name | Type | Description |
---|---|---|
walletAccount |
Object |
The details of the wallet, with: * name : The name of the wallet to retrieve an account from * predicate : An optional filter to use to find the account (otherwise it will return a random account from the wallet) |
walletAccount.name |
string |
- |
walletAccount.predicate? |
(account : Record \<string , any >) => boolean |
- |
algod |
default |
An algod client |
kmdClient? |
default |
A KMD client, if not specified then a default KMD client will be loaded from environment variables |
Returns¶
Promise
\<Account
| undefined
>
Example
const defaultDispenserAccount = await getKmdWalletAccount(algod,
'unencrypted-default-wallet',
a => a.status !== 'Offline' && a.amount > 1_000_000_000
)
Defined in¶
src/localnet/get-kmd-wallet-account.ts:25
getLocalNetDispenserAccount¶
▸ getLocalNetDispenserAccount(algod
, kmd?
): Promise
\<Account
>
Returns an Algorand account with private key loaded for the default LocalNet dispenser account (that can be used to fund other accounts)
Parameters¶
Name | Type | Description |
---|---|---|
algod |
default |
An algod client |
kmd? |
default |
A KMD client, if not specified then a default KMD client will be loaded from environment variables |
Returns¶
Promise
\<Account
>
Defined in¶
src/localnet/get-localnet-dispenser-account.ts:13
getOrCreateKmdWalletAccount¶
▸ getOrCreateKmdWalletAccount(walletAccount
, algod
, kmdClient?
): Promise
\<Account
>
Gets an account with private key loaded from a KMD wallet of the given name, or alternatively creates one with funds in it via a KMD wallet of the given name.
This is useful to get idempotent accounts from LocalNet without having to specify the private key (which will change when resetting the LocalNet).
This significantly speeds up local dev time and improves experience since you can write code that just works first go without manual config in a fresh LocalNet.
If this is used via mnemonicAccountFromEnvironment
, then you can even use the same code that runs on production without changes for local development!
Parameters¶
Name | Type | Description |
---|---|---|
walletAccount |
Object |
The wallet details with: * name : The name of the wallet to retrieve / create * fundWith : The number of Algos to fund the account with when it gets created, if not specified then 1000 Algos will be funded from the dispenser account |
walletAccount.fundWith? |
AlgoAmount |
- |
walletAccount.name |
string |
- |
algod |
default |
An algod client |
kmdClient? |
default |
A KMD client, if not specified then a default KMD client will be loaded from environment variables |
Returns¶
Promise
\<Account
>
An Algorand account with private key loaded - either one that already existed in the given KMD wallet, or a new one that is funded for you
Defined in¶
src/localnet/get-or-create-kmd-wallet-account.ts:29
getSenderAddress¶
▸ getSenderAddress(sender
): string
Returns the public address of the given transaction sender.
Parameters¶
Name | Type | Description |
---|---|---|
sender |
string | SendTransactionFrom |
A transaction sender |
Returns¶
string
The public address
Defined in¶
src/transaction/transaction.ts:100
getSenderTransactionSigner¶
▸ getSenderTransactionSigner(val
): TransactionSigner
Returns a TransactionSigner
for the given transaction sender.
This function has memoization, so will return the same transaction signer for a given sender.
Parameters¶
Name | Type |
---|---|
val |
SendTransactionFrom |
Returns¶
TransactionSigner
A transaction signer
Defined in¶
src/transaction/transaction.ts:152
getTestNetDispenserApiClient¶
▸ getTestNetDispenserApiClient(params?
): TestNetDispenserApiClient
Create a new TestNetDispenserApiClient instance. Refer to docs on guidance to obtain an access token.
Parameters¶
Name | Type | Default value | Description |
---|---|---|---|
params |
null | TestNetDispenserApiClientParams |
null |
An object containing parameters for the TestNetDispenserApiClient class. Or null if you want the client to load the access token from the environment variable ALGOKIT_DISPENSER_ACCESS_TOKEN . |
Returns¶
An instance of the TestNetDispenserApiClient class.
Example
const client = algokit.getTestNetDispenserApiClient(
{
authToken: 'your_auth_token',
requestTimeout: 15,
}
)
Defined in¶
getTransactionParams¶
▸ getTransactionParams(params
, algod
): Promise
\<SuggestedParamsWithMinFee
| { fee
: number
; firstRound
: number
; flatFee?
: boolean
; genesisHash
: string
; genesisID
: string
; lastRound
: number
}>
Returns suggested transaction parameters from algod unless some are already provided.
Parameters¶
Name | Type | Description |
---|---|---|
params |
undefined | SuggestedParams |
Optionally provide parameters to use |
algod |
default |
Algod algod |
Returns¶
Promise
\<SuggestedParamsWithMinFee
| { fee
: number
; firstRound
: number
; flatFee?
: boolean
; genesisHash
: string
; genesisID
: string
; lastRound
: number
}>
The suggested transaction parameters
Defined in¶
src/transaction/transaction.ts:803
getTransactionWithSigner¶
▸ getTransactionWithSigner(transaction
, defaultSender?
): Promise
\<TransactionWithSigner
>
Given a transaction in a variety of supported formats, returns a TransactionWithSigner object ready to be passed to an AtomicTransactionComposer's addTransaction method.
Parameters¶
Name | Type | Description |
---|---|---|
transaction |
TransactionWithSigner | Transaction | TransactionToSign | Promise \<SendTransactionResult > |
One of: A TransactionWithSigner object (returned as is), a TransactionToSign object (signer is obtained from the signer property), a Transaction object (signer is extracted from the defaultSender parameter), an async SendTransactionResult returned by one of algokit utils' helpers (signer is obtained from the defaultSender parameter) |
defaultSender? |
SendTransactionFrom |
The default sender to be used to obtain a signer where the object provided to the transaction parameter does not include a signer. |
Returns¶
Promise
\<TransactionWithSigner
>
A TransactionWithSigner object.
Defined in¶
src/transaction/transaction.ts:123
isLocalNet¶
▸ isLocalNet(algod
): Promise
\<boolean
>
Returns true if the algod client is pointing to a LocalNet Algorand network
Parameters¶
Name | Type |
---|---|
algod |
default |
Returns¶
Promise
\<boolean
>
Defined in¶
isMainNet¶
▸ isMainNet(algod
): Promise
\<boolean
>
Parameters¶
Name | Type |
---|---|
algod |
default |
Returns¶
Promise
\<boolean
>
Defined in¶
isSchemaIsBroken¶
▸ isSchemaIsBroken(before
, after
): boolean
Returns true is there is a breaking change in the application state schema from before to after. i.e. if the schema becomes larger, since applications can't ask for more schema after creation. Otherwise, there is no error, the app just doesn't store data in the extra schema :(
Parameters¶
Name | Type | Description |
---|---|---|
before |
ApplicationStateSchema |
The existing schema |
after |
ApplicationStateSchema |
The new schema |
Returns¶
boolean
Whether or not there is a breaking change
Defined in¶
isTestNet¶
▸ isTestNet(algod
): Promise
\<boolean
>
Parameters¶
Name | Type |
---|---|
algod |
default |
Returns¶
Promise
\<boolean
>
Defined in¶
lookupAccountByAddress¶
▸ lookupAccountByAddress(accountAddress
, indexer
): Promise
\<AccountLookupResult
>
Looks up an account by address using Indexer.
Parameters¶
Name | Type | Description |
---|---|---|
accountAddress |
string |
The address of the account to look up |
indexer |
default |
An indexer client |
Returns¶
Promise
\<AccountLookupResult
>
The result of the look-up
Defined in¶
lookupAccountCreatedApplicationByAddress¶
▸ lookupAccountCreatedApplicationByAddress(indexer
, address
, getAll?
, paginationLimit?
): Promise
\<ApplicationResult
[]>
Looks up applications that were created by the given address.
Parameters¶
Name | Type | Default value | Description |
---|---|---|---|
indexer |
default |
undefined |
An indexer instance |
address |
string |
undefined |
The address of the creator to look up |
getAll |
undefined | boolean |
undefined |
Whether or not to include deleted applications |
paginationLimit? |
number |
undefined |
The number of records to return per paginated request, default 1000 |
Returns¶
Promise
\<ApplicationResult
[]>
The list of application results
Defined in¶
lookupTransactionById¶
▸ lookupTransactionById(transactionId
, indexer
): Promise
\<TransactionLookupResult
>
Looks up a transaction by ID using Indexer.
Parameters¶
Name | Type | Description |
---|---|---|
transactionId |
string |
The ID of the transaction to look up |
indexer |
default |
An indexer client |
Returns¶
Promise
\<TransactionLookupResult
>
The result of the look-up
Defined in¶
microAlgos¶
▸ microAlgos(microAlgos
): AlgoAmount
Returns an amount of µAlgos using AlgoAmount
Parameters¶
Name | Type | Description |
---|---|---|
microAlgos |
number |
The amount in µAlgos |
Returns¶
Defined in¶
mnemonicAccount¶
▸ mnemonicAccount(mnemonicSecret
): Account
Returns an Algorand account with secret key loaded (i.e. that can sign transactions) by taking the mnemonic secret.
This is a wrapper around algosdk.mnemonicToSecretKey to provide a more friendly/obvious name.
Parameters¶
Name | Type | Description |
---|---|---|
mnemonicSecret |
string |
The mnemonic secret representing the private key of an account; Note: Be careful how the mnemonic is handled, never commit it into source control and ideally load it from the environment (ideally via a secret storage service) rather than the file system. |
Returns¶
Account
Defined in¶
src/account/mnemonic-account.ts:11
mnemonicAccountFromEnvironment¶
▸ mnemonicAccountFromEnvironment(account
, algod
, kmdClient?
): Promise
\<Account
| SigningAccount
>
Returns an Algorand account with private key loaded by convention from environment variables based on the given name identifier.
Note: This function expects to run in a Node.js environment.
Convention:¶
- Non-LocalNet: will load process.env['{NAME}_MNEMONIC'] as a mnemonic secret; Note: Be careful how the mnemonic is handled, never commit it into source control and ideally load it via a secret storage service rather than the file system. If process.env['{NAME}_SENDER'] is defined then it will use that for the sender address (i.e. to support rekeyed accounts)
- LocalNet: will load the account from a KMD wallet called {NAME} and if that wallet doesn't exist it will create it and fund the account for you
This allows you to write code that will work seamlessly in production and local development (LocalNet) without manual config locally (including when you reset the LocalNet).
Parameters¶
Name | Type | Description |
---|---|---|
account |
string | { fundWith? : AlgoAmount ; name : string } |
The details of the account to get, either the name identifier (string) or an object with: * name : string: The name identifier of the account * fundWith : The amount to fund the account with when it gets created (when targeting LocalNet), if not specified then 1000 Algos will be funded from the dispenser account |
algod |
default |
An algod client |
kmdClient? |
default |
An optional KMD client to use to create an account (when targeting LocalNet), if not specified then a default KMD client will be loaded from environment variables |
Returns¶
Promise
\<Account
| SigningAccount
>
The requested account with private key loaded from the environment variables or when targeting LocalNet from KMD (idempotently creating and funding the account)
Example
If you have a mnemonic secret loaded into process.env.MY_ACCOUNT_MNEMONIC
then you can call the following to get that private key loaded into an account object:
const account = await mnemonicAccountFromEnvironment('MY_ACCOUNT', algod)
If that code runs against LocalNet then a wallet called MY_ACCOUNT
will automatically be created with an account that is automatically funded with 1000 (default) ALGOs from the default LocalNet dispenser.
If not running against LocalNet then it will use proces.env.MY_ACCOUNT_MNEMONIC as the private key and (if present) process.env.MY_ACCOUNT_SENDER as the sender address.
Defined in¶
multisigAccount¶
▸ multisigAccount(multisigParams
, signingAccounts
): MultisigAccount
Returns an account wrapper that supports partial or full multisig signing.
Parameters¶
Name | Type | Description |
---|---|---|
multisigParams |
MultisigMetadata |
The parameters that define the multisig account |
signingAccounts |
(default | SigningAccount )[] |
The signers that are currently present |
Returns¶
A multisig account wrapper
Defined in¶
performAtomicTransactionComposerDryrun¶
▸ performAtomicTransactionComposerDryrun(atc
, algod
): Promise
\<DryrunResult
>
Performs a dry run of the transactions loaded into the given AtomicTransactionComposer@param atc The AtomicTransactionComposer
with transaction(s) loaded
Parameters¶
Name | Type | Description |
---|---|---|
atc |
AtomicTransactionComposer |
- |
algod |
default |
An Algod client |
Returns¶
Promise
\<DryrunResult
>
The dryrun result
Defined in¶
src/transaction/transaction.ts:637
performAtomicTransactionComposerSimulate¶
▸ performAtomicTransactionComposerSimulate(atc
, algod
): Promise
\<SimulateResponse
>
Performs a simulation of the transactions loaded into the given AtomicTransactionComposer.
Parameters¶
Name | Type | Description |
---|---|---|
atc |
AtomicTransactionComposer |
The AtomicTransactionComposer with transaction(s) loaded. |
algod |
default |
An Algod client to perform the simulation. |
Returns¶
Promise
\<SimulateResponse
>
The simulation result, which includes various details about how the transactions would be processed.
Defined in¶
src/transaction/perform-atomic-transaction-composer-simulate.ts:13
performTemplateSubstitution¶
▸ performTemplateSubstitution(tealCode
, templateParams?
): string
Performs template substitution of a teal file.
Looks for TMPL_{parameter}
for template replacements.
Parameters¶
Name | Type | Description |
---|---|---|
tealCode |
string |
The TEAL logic to compile |
templateParams? |
TealTemplateParams |
Any parameters to replace in the .teal file before compiling |
Returns¶
string
The TEAL code with replacements
Defined in¶
performTemplateSubstitutionAndCompile¶
▸ performTemplateSubstitutionAndCompile(tealCode
, algod
, templateParams?
, deploymentMetadata?
): Promise
\<CompiledTeal
>
Performs template substitution of a teal file and compiles it, returning the compiled result.
Looks for TMPL_{parameter}
for template replacements.
Parameters¶
Name | Type | Description |
---|---|---|
tealCode |
string |
The TEAL logic to compile |
algod |
default |
An algod client |
templateParams? |
TealTemplateParams |
Any parameters to replace in the .teal file before compiling |
deploymentMetadata? |
AppDeployMetadata |
The deployment metadata the app will be deployed with |
Returns¶
Promise
\<CompiledTeal
>
The information about the compiled code
Defined in¶
persistSourceMaps¶
▸ persistSourceMaps(param0
): Promise
\<void
>
This function persists the source maps for the given sources.
Parameters¶
Name | Type | Description |
---|---|---|
param0 |
PersistSourceMapsParams |
The parameters to define the persistence |
Returns¶
Promise
\<void
>
A promise that resolves when the source maps have been persisted.
Defined in¶
src/debugging/debugging.ts:131
populateAppCallResources¶
▸ populateAppCallResources(atc
, algod
): Promise
\<AtomicTransactionComposer
>
Take an existing Atomic Transaction Composer and return a new one with the required app call resources packed into it
Parameters¶
Name | Type | Description |
---|---|---|
atc |
AtomicTransactionComposer |
The ATC containing the txn group |
algod |
default |
The algod client to use for the simulation |
Returns¶
Promise
\<AtomicTransactionComposer
>
A new ATC with the resources packed into the transactions
Defined in¶
src/transaction/transaction.ts:288
randomAccount¶
▸ randomAccount(): Account
Returns a new, random Algorand account with secret key loaded.
This is a wrapper around algosdk.generateAccount to provide a more friendly/obvious name.
Returns¶
Account
Defined in¶
rekeyAccount¶
▸ rekeyAccount(rekey
, algod
): Promise
\<SendTransactionResult
>
Rekey an account to a new address.
Note: Please be careful with this function and be sure to read the official rekey guidance.
Parameters¶
Name | Type | Description |
---|---|---|
rekey |
AlgoRekeyParams |
The rekey definition |
algod |
default |
An algod client |
Returns¶
Promise
\<SendTransactionResult
>
The transaction object and optionally the confirmation if it was sent to the chain (skipSending
is false
or unset)
Example
await algokit.rekeyAccount({ from, rekeyTo }, algod)
Defined in¶
rekeyedAccount¶
▸ rekeyedAccount(signer
, sender
): SigningAccount
Returns an account wrapper that supports a rekeyed account.
Parameters¶
Name | Type | Description |
---|---|---|
signer |
default |
The account, with private key loaded, that is signing |
sender |
string |
The address of the rekeyed account that will act as a sender |
Returns¶
The SigningAccount wrapper
Defined in¶
replaceDeployTimeControlParams¶
▸ replaceDeployTimeControlParams(tealCode
, params
): string
Replaces deploy-time deployment control parameters within the given teal code.
TMPL_UPDATABLE
for updatability / immutability controlTMPL_DELETABLE
for deletability / permanence control
Note: If these values are not undefined, but the corresponding TMPL_*
value
isn't in the teal code it will throw an exception.
Parameters¶
Name | Type | Description |
---|---|---|
tealCode |
string |
The TEAL code to substitute |
params |
Object |
The deploy-time deployment control parameter value to replace |
params.deletable? |
boolean |
- |
params.updatable? |
boolean |
- |
Returns¶
string
The replaced TEAL code
Defined in¶
searchTransactions¶
▸ searchTransactions(indexer
, searchCriteria
, paginationLimit?
): Promise
\<TransactionSearchResults
>
Allows transactions to be searched for the given criteria.
Parameters¶
Name | Type | Description |
---|---|---|
indexer |
default |
An indexer client |
searchCriteria |
(s : default ) => default |
The criteria to search for |
paginationLimit? |
number |
The number of records to return per paginated request, default 1000 |
Returns¶
Promise
\<TransactionSearchResults
>
The search results
Defined in¶
sendAtomicTransactionComposer¶
▸ sendAtomicTransactionComposer(atcSend
, algod
): Promise
\<SendAtomicTransactionComposerResults
>
Signs and sends transactions that have been collected by an AtomicTransactionComposer
.
Parameters¶
Name | Type | Description |
---|---|---|
atcSend |
AtomicTransactionComposerToSend |
The parameters controlling the send, including: * atc The AtomicTransactionComposer * sendParams The parameters to control the send behaviour |
algod |
default |
An algod client |
Returns¶
Promise
\<SendAtomicTransactionComposerResults
>
An object with transaction IDs, transactions, group transaction ID (groupTransactionId
) if more than 1 transaction sent, and (if skipWaiting
is false
or unset) confirmation (confirmation
)
Defined in¶
src/transaction/transaction.ts:509
sendGroupOfTransactions¶
▸ sendGroupOfTransactions(groupSend
, algod
): Promise
\<Omit
\<SendAtomicTransactionComposerResults
, "returns"
>>
Signs and sends a group of up to 16 transactions to the chain
Parameters¶
Name | Type | Description |
---|---|---|
groupSend |
TransactionGroupToSend |
The group details to send, with: * transactions : The array of transactions to send along with their signing account * sendParams : The parameters to dictate how the group is sent |
algod |
default |
An algod client |
Returns¶
Promise
\<Omit
\<SendAtomicTransactionComposerResults
, "returns"
>>
An object with transaction IDs, transactions, group transaction ID (groupTransactionId
) if more than 1 transaction sent, and (if skipWaiting
is false
or unset) confirmation (confirmation
)
Defined in¶
src/transaction/transaction.ts:655
sendTransaction¶
▸ sendTransaction(send
, algod
): Promise
\<SendTransactionResult
>
Prepares a transaction for sending and then (if instructed) signs and sends the given transaction to the chain.
Parameters¶
Name | Type | Description |
---|---|---|
send |
Object |
The details for the transaction to prepare/send, including: * transaction : The unsigned transaction * from : The account to sign the transaction with: either an account with private key loaded or a logic signature account * config : The sending configuration for this transaction |
send.from |
SendTransactionFrom |
- |
send.sendParams? |
SendTransactionParams |
- |
send.transaction |
Transaction |
- |
algod |
default |
An algod client |
Returns¶
Promise
\<SendTransactionResult
>
An object with transaction (transaction
) and (if skipWaiting
is false
or undefined
) confirmation (confirmation
)
Defined in¶
src/transaction/transaction.ts:186
signTransaction¶
▸ signTransaction(transaction
, signer
): Promise
\<Uint8Array
>
Signs a single transaction by the given signer.
Parameters¶
Name | Type | Description |
---|---|---|
transaction |
Transaction |
The transaction to sign |
signer |
SendTransactionFrom |
The signer to sign |
Returns¶
Promise
\<Uint8Array
>
The signed transaction as a Uint8Array
Defined in¶
src/transaction/transaction.ts:166
simulateAndPersistResponse¶
▸ simulateAndPersistResponse(param0
): Promise
\<SimulateResponse
>
This function simulates the atomic transactions using the provided AtomicTransactionComposer
object and Algodv2
object,
and persists the simulation response to an AlgoKit AVM Debugger compliant JSON file.
Parameters¶
Name | Type | Description |
---|---|---|
param0 |
SimulateAndPersistResponseParams |
The parameters to control the simulation and persistence. |
Returns¶
Promise
\<SimulateResponse
>
The simulation result, which includes various details about how the transactions would be processed.
Example
const atc = new AtomicTransactionComposer();
const algod = new algosdk.Algodv2(token, server, port);
const projectRoot = '/path/to/project';
const bufferSizeMb = 10;
const result = await simulateAndPersistResponse({ atc, projectRoot, algod, bufferSizeMb });
console.log(result);
Defined in¶
src/debugging/simulate-and-persist-response.ts:33
stripTealComments¶
▸ stripTealComments(tealCode
): string
Remove comments from TEAL Code
Parameters¶
Name | Type | Description |
---|---|---|
tealCode |
string |
The TEAL logic to compile |
Returns¶
string
The TEAL without comments
Defined in¶
transactionFees¶
▸ transactionFees(numberOfTransactions
): AlgoAmount
Returns an amount of µAlgos to cover standard fees for the given number of transactions using AlgoAmount
Parameters¶
Name | Type | Description |
---|---|---|
numberOfTransactions |
number |
The of standard transaction fees to return the amount of ALGOs |
Returns¶
Defined in¶
transactionSignerAccount¶
▸ transactionSignerAccount(signer
, sender
): TransactionSignerAccount
Returns an account wrapper that supports a transaction signer with associated sender address.
Parameters¶
Name | Type | Description |
---|---|---|
signer |
TransactionSigner |
The transaction signer |
sender |
string |
The address of sender account |
Returns¶
The SigningAccount wrapper
Defined in¶
transferAlgos¶
▸ transferAlgos(transfer
, algod
): Promise
\<SendTransactionResult
>
Transfer ALGOs between two accounts.
Parameters¶
Name | Type | Description |
---|---|---|
transfer |
AlgoTransferParams |
The transfer definition |
algod |
default |
An algod client |
Returns¶
Promise
\<SendTransactionResult
>
The transaction object and optionally the confirmation if it was sent to the chain (skipSending
is false
or unset)
Example
await algokit.transferAlgos({ from, to, amount: algokit.algos(1) }, algod)
Defined in¶
src/transfer/transfer-algos.ts:19
transferAsset¶
▸ transferAsset(transfer
, algod
): Promise
\<SendTransactionResult
>
Transfer asset between two accounts.
Parameters¶
Name | Type | Description |
---|---|---|
transfer |
TransferAssetParams |
The transfer definition |
algod |
default |
An algod client |
Returns¶
Promise
\<SendTransactionResult
>
The transaction object and optionally the confirmation if it was sent to the chain (skipSending
is false
or unset)
Example
await algokit.transferAsset({ from, to, assetId, amount }, algod)
Defined in¶
updateApp¶
▸ updateApp(update
, algod
): Promise
\<Partial
\<AppCompilationResult
> & AppCallTransactionResult
>
Updates a smart contract app.
Parameters¶
Name | Type | Description |
---|---|---|
update |
UpdateAppParams |
The parameters to update the app with |
algod |
default |
An algod client |
Returns¶
Promise
\<Partial
\<AppCompilationResult
> & AppCallTransactionResult
>
The transaction send result and the compilation result
Defined in¶
waitForConfirmation¶
▸ waitForConfirmation(transactionId
, maxRoundsToWait
, algod
): Promise
\<PendingTransactionResponse
>
Wait until the transaction is confirmed or rejected, or until timeout
number of rounds have passed.
Parameters¶
Name | Type | Description |
---|---|---|
transactionId |
string |
The transaction ID to wait for |
maxRoundsToWait |
number | bigint |
Maximum number of rounds to wait |
algod |
default |
An algod client |
Returns¶
Promise
\<PendingTransactionResponse
>
Pending transaction information
Throws
Throws an error if the transaction is not confirmed or rejected in the next timeout
rounds