nomadex-client
Version:
Client library to programmatically interact with https://voi.nomadex.app
1,038 lines (1,037 loc) • 77.7 kB
TypeScript
import type { ABIAppCallArg, AppCallTransactionResult, AppCallTransactionResultOfType, AppCompilationResult, AppReference, AppStorageSchema, CoreAppCallArgs, RawAppCallArgs, TealTemplateParams } from '@algorandfoundation/algokit-utils/types/app';
import type { AppClientCallCoreParams, AppClientCompilationParams, AppClientDeployCoreParams, AppDetails, ApplicationClient } from '@algorandfoundation/algokit-utils/types/app-client';
import type { AppSpec } from '@algorandfoundation/algokit-utils/types/app-spec';
import type { SendTransactionResult, TransactionToSign, SendTransactionFrom, SendTransactionParams } from '@algorandfoundation/algokit-utils/types/transaction';
import type { ABIResult, TransactionWithSigner } from 'algosdk';
import { Algodv2, OnApplicationComplete, Transaction, AtomicTransactionComposer, modelsv2 } from 'algosdk';
export declare const APP_SPEC: AppSpec;
/**
* Defines an onCompletionAction of 'no_op'
*/
export type OnCompleteNoOp = {
onCompleteAction?: 'no_op' | OnApplicationComplete.NoOpOC;
};
/**
* Defines an onCompletionAction of 'opt_in'
*/
export type OnCompleteOptIn = {
onCompleteAction: 'opt_in' | OnApplicationComplete.OptInOC;
};
/**
* Defines an onCompletionAction of 'close_out'
*/
export type OnCompleteCloseOut = {
onCompleteAction: 'close_out' | OnApplicationComplete.CloseOutOC;
};
/**
* Defines an onCompletionAction of 'delete_application'
*/
export type OnCompleteDelApp = {
onCompleteAction: 'delete_application' | OnApplicationComplete.DeleteApplicationOC;
};
/**
* Defines an onCompletionAction of 'update_application'
*/
export type OnCompleteUpdApp = {
onCompleteAction: 'update_application' | OnApplicationComplete.UpdateApplicationOC;
};
/**
* A state record containing a single unsigned integer
*/
export type IntegerState = {
/**
* Gets the state value as a BigInt.
*/
asBigInt(): bigint;
/**
* Gets the state value as a number.
*/
asNumber(): number;
};
/**
* A state record containing binary data
*/
export type BinaryState = {
/**
* Gets the state value as a Uint8Array
*/
asByteArray(): Uint8Array;
/**
* Gets the state value as a string
*/
asString(): string;
};
export type AppCreateCallTransactionResult = AppCallTransactionResult & Partial<AppCompilationResult> & AppReference;
export type AppUpdateCallTransactionResult = AppCallTransactionResult & Partial<AppCompilationResult>;
export type AppClientComposeCallCoreParams = Omit<AppClientCallCoreParams, 'sendParams'> & {
sendParams?: Omit<SendTransactionParams, 'skipSending' | 'atc' | 'skipWaiting' | 'maxRoundsToWaitForConfirmation' | 'populateAppCallResources'>;
};
export type AppClientComposeExecuteParams = Pick<SendTransactionParams, 'skipWaiting' | 'maxRoundsToWaitForConfirmation' | 'populateAppCallResources' | 'suppressLog'>;
export type IncludeSchema = {
/**
* Any overrides for the storage schema to request for the created app; by default the schema indicated by the app spec is used.
*/
schema?: Partial<AppStorageSchema>;
};
/**
* Defines the types of available calls and state of the Pool smart contract.
*/
export type Pool = {
/**
* Maps method signatures / names to their argument and return types.
*/
methods: Record<'arc200_name()byte[32]' | 'arc200_name', {
argsObj: {};
argsTuple: [];
returns: Uint8Array;
}> & Record<'arc200_symbol()byte[8]' | 'arc200_symbol', {
argsObj: {};
argsTuple: [];
returns: Uint8Array;
}> & Record<'arc200_decimals()uint8' | 'arc200_decimals', {
argsObj: {};
argsTuple: [];
returns: number;
}> & Record<'arc200_totalSupply()uint256' | 'arc200_totalSupply', {
argsObj: {};
argsTuple: [];
returns: bigint;
}> & Record<'arc200_balanceOf(address)uint256' | 'arc200_balanceOf', {
argsObj: {
owner: string;
};
argsTuple: [owner: string];
returns: bigint;
}> & Record<'arc200_allowance(address,address)uint256' | 'arc200_allowance', {
argsObj: {
owner: string;
spender: string;
};
argsTuple: [owner: string, spender: string];
returns: bigint;
}> & Record<'arc200_transfer(address,uint256)bool' | 'arc200_transfer', {
argsObj: {
to: string;
value: bigint | number;
};
argsTuple: [to: string, value: bigint | number];
returns: boolean;
}> & Record<'arc200_approve(address,uint256)bool' | 'arc200_approve', {
argsObj: {
spender: string;
value: bigint | number;
};
argsTuple: [spender: string, value: bigint | number];
returns: boolean;
}> & Record<'arc200_transferFrom(address,address,uint256)bool' | 'arc200_transferFrom', {
argsObj: {
from: string;
to: string;
value: bigint | number;
};
argsTuple: [from: string, to: string, value: bigint | number];
returns: boolean;
}> & Record<'supportsInterface(byte[4])bool' | 'supportsInterface', {
argsObj: {
interfaceId: Uint8Array;
};
argsTuple: [interfaceId: Uint8Array];
returns: boolean;
}> & Record<'zeroAddress()address' | 'zeroAddress', {
argsObj: {};
argsTuple: [];
returns: string;
}> & Record<'hasBox(address,address)bool' | 'hasBox', {
argsObj: {
owner: string;
spender: string;
};
argsTuple: [owner: string, spender: string];
returns: boolean;
}> & Record<'createBalanceBox(address)bool' | 'createBalanceBox', {
argsObj: {
owner: string;
};
argsTuple: [owner: string];
returns: boolean;
}> & Record<'createAllowanceBox(address,address)bool' | 'createAllowanceBox', {
argsObj: {
owner: string;
spender: string;
};
argsTuple: [owner: string, spender: string];
returns: boolean;
}> & Record<'noop(uint64)void' | 'noop', {
argsObj: {
n: bigint | number;
};
argsTuple: [n: bigint | number];
returns: void;
}> & Record<'updateApplication()void' | 'updateApplication', {
argsObj: {};
argsTuple: [];
returns: void;
}> & Record<'deleteApplication()void' | 'deleteApplication', {
argsObj: {};
argsTuple: [];
returns: void;
}> & Record<'manager()address' | 'manager', {
argsObj: {};
argsTuple: [];
returns: string;
}> & Record<'grant(address)void' | 'grant', {
argsObj: {
manager: string;
};
argsTuple: [manager: string];
returns: void;
}> & Record<'setFees(uint256)bool' | 'setFees', {
argsObj: {
fee: bigint | number;
};
argsTuple: [fee: bigint | number];
returns: boolean;
}> & Record<'registerOnline(byte[],byte[],byte[],uint64,uint64,uint64)void' | 'registerOnline', {
argsObj: {
selectionPk: Uint8Array;
stateProofPk: Uint8Array;
votePk: Uint8Array;
voteFirst: bigint | number;
voteLast: bigint | number;
voteKeyDilution: bigint | number;
};
argsTuple: [selectionPk: Uint8Array, stateProofPk: Uint8Array, votePk: Uint8Array, voteFirst: bigint | number, voteLast: bigint | number, voteKeyDilution: bigint | number];
returns: void;
}> & Record<'registerOffline()void' | 'registerOffline', {
argsObj: {};
argsTuple: [];
returns: void;
}> & Record<'removeLiquidity(uint256)bool' | 'removeLiquidity', {
argsObj: {
lptAmount: bigint | number;
};
argsTuple: [lptAmount: bigint | number];
returns: boolean;
}> & Record<'addLiquidity(txn,txn)bool' | 'addLiquidity', {
argsObj: {
alphaTxn: TransactionToSign | Transaction | Promise<SendTransactionResult>;
betaTxn: TransactionToSign | Transaction | Promise<SendTransactionResult>;
};
argsTuple: [alphaTxn: TransactionToSign | Transaction | Promise<SendTransactionResult>, betaTxn: TransactionToSign | Transaction | Promise<SendTransactionResult>];
returns: boolean;
}> & Record<'swapAlphaToBeta(txn,uint256)uint256' | 'swapAlphaToBeta', {
argsObj: {
alphaTxn: TransactionToSign | Transaction | Promise<SendTransactionResult>;
minBetaAmount: bigint | number;
};
argsTuple: [alphaTxn: TransactionToSign | Transaction | Promise<SendTransactionResult>, minBetaAmount: bigint | number];
returns: bigint;
}> & Record<'swapBetaToAlpha(txn,uint256)uint256' | 'swapBetaToAlpha', {
argsObj: {
betaTxn: TransactionToSign | Transaction | Promise<SendTransactionResult>;
minAlphaAmount: bigint | number;
};
argsTuple: [betaTxn: TransactionToSign | Transaction | Promise<SendTransactionResult>, minAlphaAmount: bigint | number];
returns: bigint;
}> & Record<'createApplication(uint64,address,byte[32],byte[8],uint64,uint8,uint64,uint8,uint256)void' | 'createApplication', {
argsObj: {
factory: bigint | number;
manager: string;
name: Uint8Array;
symbol: Uint8Array;
alphaId: bigint | number;
alphaType: number;
betaId: bigint | number;
betaType: number;
swapFee: bigint | number;
};
argsTuple: [factory: bigint | number, manager: string, name: Uint8Array, symbol: Uint8Array, alphaId: bigint | number, alphaType: number, betaId: bigint | number, betaType: number, swapFee: bigint | number];
returns: void;
}> & Record<'bootstrap()void' | 'bootstrap', {
argsObj: {};
argsTuple: [];
returns: void;
}>;
/**
* Defines the shape of the global and local state of the application.
*/
state: {
global: {
name?: BinaryState;
symbol?: BinaryState;
decimals?: BinaryState;
totalSupply?: BinaryState;
initialized?: BinaryState;
warden?: BinaryState;
factory?: IntegerState;
alphaId?: IntegerState;
betaId?: IntegerState;
alphaType?: BinaryState;
betaType?: BinaryState;
swapFee?: BinaryState;
};
};
};
/**
* Defines the possible abi call signatures
*/
export type PoolSig = keyof Pool['methods'];
/**
* Defines an object containing all relevant parameters for a single call to the contract. Where TSignature is undefined, a bare call is made
*/
export type TypedCallParams<TSignature extends PoolSig | undefined> = {
method: TSignature;
methodArgs: TSignature extends undefined ? undefined : Array<ABIAppCallArg | undefined>;
} & AppClientCallCoreParams & CoreAppCallArgs;
/**
* Defines the arguments required for a bare call
*/
export type BareCallArgs = Omit<RawAppCallArgs, keyof CoreAppCallArgs>;
/**
* Maps a method signature from the Pool smart contract to the method's arguments in either tuple of struct form
*/
export type MethodArgs<TSignature extends PoolSig> = Pool['methods'][TSignature]['argsObj' | 'argsTuple'];
/**
* Maps a method signature from the Pool smart contract to the method's return type
*/
export type MethodReturn<TSignature extends PoolSig> = Pool['methods'][TSignature]['returns'];
/**
* A factory for available 'create' calls
*/
export type PoolCreateCalls = (typeof PoolCallFactory)['create'];
/**
* Defines supported create methods for this smart contract
*/
export type PoolCreateCallParams = (TypedCallParams<'createApplication(uint64,address,byte[32],byte[8],uint64,uint8,uint64,uint8,uint256)void'> & (OnCompleteNoOp));
/**
* A factory for available 'update' calls
*/
export type PoolUpdateCalls = (typeof PoolCallFactory)['update'];
/**
* Defines supported update methods for this smart contract
*/
export type PoolUpdateCallParams = TypedCallParams<'updateApplication()void'>;
/**
* A factory for available 'delete' calls
*/
export type PoolDeleteCalls = (typeof PoolCallFactory)['delete'];
/**
* Defines supported delete methods for this smart contract
*/
export type PoolDeleteCallParams = TypedCallParams<'deleteApplication()void'>;
/**
* Defines arguments required for the deploy method.
*/
export type PoolDeployArgs = {
deployTimeParams?: TealTemplateParams;
/**
* A delegate which takes a create call factory and returns the create call params for this smart contract
*/
createCall?: (callFactory: PoolCreateCalls) => PoolCreateCallParams;
/**
* A delegate which takes a update call factory and returns the update call params for this smart contract
*/
updateCall?: (callFactory: PoolUpdateCalls) => PoolUpdateCallParams;
/**
* A delegate which takes a delete call factory and returns the delete call params for this smart contract
*/
deleteCall?: (callFactory: PoolDeleteCalls) => PoolDeleteCallParams;
};
/**
* Exposes methods for constructing all available smart contract calls
*/
export declare abstract class PoolCallFactory {
/**
* Gets available create call factories
*/
static get create(): {
/**
* Constructs a create call for the Pool smart contract using the createApplication(uint64,address,byte[32],byte[8],uint64,uint8,uint64,uint8,uint256)void ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
createApplication(args: MethodArgs<"createApplication(uint64,address,byte[32],byte[8],uint64,uint8,uint64,uint8,uint256)void">, params?: AppClientCallCoreParams & CoreAppCallArgs & AppClientCompilationParams & (OnCompleteNoOp)): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
deployTimeParams?: TealTemplateParams;
updatable?: boolean;
deletable?: boolean;
onCompleteAction?: "no_op" | OnApplicationComplete.NoOpOC;
method: "createApplication(uint64,address,byte[32],byte[8],uint64,uint8,uint64,uint8,uint256)void";
methodArgs: (string | number | bigint | Uint8Array<ArrayBufferLike>)[];
};
};
/**
* Gets available update call factories
*/
static get update(): {
/**
* Constructs an update call for the Pool smart contract using the updateApplication()void ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
updateApplication(args: MethodArgs<"updateApplication()void">, params?: AppClientCallCoreParams & CoreAppCallArgs & AppClientCompilationParams): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
deployTimeParams?: TealTemplateParams;
updatable?: boolean;
deletable?: boolean;
method: "updateApplication()void";
methodArgs: any[];
};
};
/**
* Gets available delete call factories
*/
static get delete(): {
/**
* Constructs a delete call for the Pool smart contract using the deleteApplication()void ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
deleteApplication(args: MethodArgs<"deleteApplication()void">, params?: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "deleteApplication()void";
methodArgs: any[];
};
};
/**
* Constructs a no op call for the arc200_name()byte[32] ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static arc200Name(args: MethodArgs<'arc200_name()byte[32]'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "arc200_name()byte[32]";
methodArgs: any[];
};
/**
* Constructs a no op call for the arc200_symbol()byte[8] ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static arc200Symbol(args: MethodArgs<'arc200_symbol()byte[8]'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "arc200_symbol()byte[8]";
methodArgs: any[];
};
/**
* Constructs a no op call for the arc200_decimals()uint8 ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static arc200Decimals(args: MethodArgs<'arc200_decimals()uint8'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "arc200_decimals()uint8";
methodArgs: any[];
};
/**
* Constructs a no op call for the arc200_totalSupply()uint256 ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static arc200TotalSupply(args: MethodArgs<'arc200_totalSupply()uint256'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "arc200_totalSupply()uint256";
methodArgs: any[];
};
/**
* Constructs a no op call for the arc200_balanceOf(address)uint256 ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static arc200BalanceOf(args: MethodArgs<'arc200_balanceOf(address)uint256'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "arc200_balanceOf(address)uint256";
methodArgs: string[];
};
/**
* Constructs a no op call for the arc200_allowance(address,address)uint256 ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static arc200Allowance(args: MethodArgs<'arc200_allowance(address,address)uint256'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "arc200_allowance(address,address)uint256";
methodArgs: string[];
};
/**
* Constructs a no op call for the arc200_transfer(address,uint256)bool ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static arc200Transfer(args: MethodArgs<'arc200_transfer(address,uint256)bool'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "arc200_transfer(address,uint256)bool";
methodArgs: (string | number | bigint)[];
};
/**
* Constructs a no op call for the arc200_approve(address,uint256)bool ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static arc200Approve(args: MethodArgs<'arc200_approve(address,uint256)bool'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "arc200_approve(address,uint256)bool";
methodArgs: (string | number | bigint)[];
};
/**
* Constructs a no op call for the arc200_transferFrom(address,address,uint256)bool ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static arc200TransferFrom(args: MethodArgs<'arc200_transferFrom(address,address,uint256)bool'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "arc200_transferFrom(address,address,uint256)bool";
methodArgs: (string | number | bigint)[];
};
/**
* Constructs a no op call for the supportsInterface(byte[4])bool ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static supportsInterface(args: MethodArgs<'supportsInterface(byte[4])bool'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "supportsInterface(byte[4])bool";
methodArgs: Uint8Array<ArrayBufferLike>[];
};
/**
* Constructs a no op call for the zeroAddress()address ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static zeroAddress(args: MethodArgs<'zeroAddress()address'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "zeroAddress()address";
methodArgs: any[];
};
/**
* Constructs a no op call for the hasBox(address,address)bool ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static hasBox(args: MethodArgs<'hasBox(address,address)bool'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "hasBox(address,address)bool";
methodArgs: string[];
};
/**
* Constructs a no op call for the createBalanceBox(address)bool ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static createBalanceBox(args: MethodArgs<'createBalanceBox(address)bool'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "createBalanceBox(address)bool";
methodArgs: string[];
};
/**
* Constructs a no op call for the createAllowanceBox(address,address)bool ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static createAllowanceBox(args: MethodArgs<'createAllowanceBox(address,address)bool'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "createAllowanceBox(address,address)bool";
methodArgs: string[];
};
/**
* Constructs a no op call for the noop(uint64)void ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static noop(args: MethodArgs<'noop(uint64)void'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "noop(uint64)void";
methodArgs: (number | bigint)[];
};
/**
* Constructs a no op call for the manager()address ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static manager(args: MethodArgs<'manager()address'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "manager()address";
methodArgs: any[];
};
/**
* Constructs a no op call for the grant(address)void ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static grant(args: MethodArgs<'grant(address)void'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "grant(address)void";
methodArgs: string[];
};
/**
* Constructs a no op call for the setFees(uint256)bool ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static setFees(args: MethodArgs<'setFees(uint256)bool'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "setFees(uint256)bool";
methodArgs: (number | bigint)[];
};
/**
* Constructs a no op call for the registerOnline(byte[],byte[],byte[],uint64,uint64,uint64)void ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static registerOnline(args: MethodArgs<'registerOnline(byte[],byte[],byte[],uint64,uint64,uint64)void'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "registerOnline(byte[],byte[],byte[],uint64,uint64,uint64)void";
methodArgs: (number | bigint | Uint8Array<ArrayBufferLike>)[];
};
/**
* Constructs a no op call for the registerOffline()void ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static registerOffline(args: MethodArgs<'registerOffline()void'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "registerOffline()void";
methodArgs: any[];
};
/**
* Constructs a no op call for the removeLiquidity(uint256)bool ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static removeLiquidity(args: MethodArgs<'removeLiquidity(uint256)bool'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "removeLiquidity(uint256)bool";
methodArgs: (number | bigint)[];
};
/**
* Constructs a no op call for the addLiquidity(txn,txn)bool ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static addLiquidity(args: MethodArgs<'addLiquidity(txn,txn)bool'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "addLiquidity(txn,txn)bool";
methodArgs: (Transaction | TransactionToSign | Promise<SendTransactionResult>)[];
};
/**
* Constructs a no op call for the swapAlphaToBeta(txn,uint256)uint256 ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static swapAlphaToBeta(args: MethodArgs<'swapAlphaToBeta(txn,uint256)uint256'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "swapAlphaToBeta(txn,uint256)uint256";
methodArgs: (number | bigint | Transaction | TransactionToSign | Promise<SendTransactionResult>)[];
};
/**
* Constructs a no op call for the swapBetaToAlpha(txn,uint256)uint256 ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static swapBetaToAlpha(args: MethodArgs<'swapBetaToAlpha(txn,uint256)uint256'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "swapBetaToAlpha(txn,uint256)uint256";
methodArgs: (number | bigint | Transaction | TransactionToSign | Promise<SendTransactionResult>)[];
};
/**
* Constructs a no op call for the bootstrap()void ABI method
*
* @param args Any args for the contract call
* @param params Any additional parameters for the call
* @returns A TypedCallParams object for the call
*/
static bootstrap(args: MethodArgs<'bootstrap()void'>, params: AppClientCallCoreParams & CoreAppCallArgs): {
sender?: SendTransactionFrom;
note?: import("@algorandfoundation/algokit-utils/types/transaction").TransactionNote;
sendParams?: SendTransactionParams;
lease?: string | Uint8Array;
boxes?: (import("algosdk").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxReference | import("@algorandfoundation/algokit-utils/types/app").BoxIdentifier)[];
accounts?: (string | import("algosdk").Address)[];
apps?: number[];
assets?: number[];
rekeyTo?: SendTransactionFrom | string;
method: "bootstrap()void";
methodArgs: any[];
};
}
/**
* A client to make calls to the Pool smart contract
*/
export declare class PoolClient {
private algod;
/**
* The underlying `ApplicationClient` for when you want to have more flexibility
*/
readonly appClient: ApplicationClient;
private readonly sender;
/**
* Creates a new instance of `PoolClient`
*
* @param appDetails appDetails The details to identify the app to deploy
* @param algod An algod client instance
*/
constructor(appDetails: AppDetails, algod: Algodv2);
/**
* Checks for decode errors on the AppCallTransactionResult and maps the return value to the specified generic type
*
* @param result The AppCallTransactionResult to be mapped
* @param returnValueFormatter An optional delegate to format the return value if required
* @returns The smart contract response with an updated return value
*/
protected mapReturnValue<TReturn, TResult extends AppCallTransactionResult = AppCallTransactionResult>(result: AppCallTransactionResult, returnValueFormatter?: (value: any) => TReturn): AppCallTransactionResultOfType<TReturn> & TResult;
/**
* Calls the ABI method with the matching signature using an onCompletion code of NO_OP
*
* @param typedCallParams An object containing the method signature, args, and any other relevant parameters
* @param returnValueFormatter An optional delegate which when provided will be used to map non-undefined return values to the target type
* @returns The result of the smart contract call
*/
call<TSignature extends keyof Pool['methods']>(typedCallParams: TypedCallParams<TSignature>, returnValueFormatter?: (value: any) => MethodReturn<TSignature>): Promise<AppCallTransactionResultOfType<MethodReturn<TSignature>> & AppCallTransactionResult>;
/**
* Idempotently deploys the Pool smart contract.
*
* @param params The arguments for the contract calls and any additional parameters for the call
* @returns The deployment result
*/
deploy(params?: PoolDeployArgs & AppClientDeployCoreParams & IncludeSchema): ReturnType<ApplicationClient['deploy']>;
/**
* Gets available create methods
*/
get create(): {
/**
* Creates a new instance of the Pool smart contract using the createApplication(uint64,address,byte[32],byte[8],uint64,uint8,uint64,uint8,uint256)void ABI method.
*
* @param args The arguments for the smart contract call
* @param params Any additional parameters for the call
* @returns The create result
*/
createApplication(args: MethodArgs<"createApplication(uint64,address,byte[32],byte[8],uint64,uint8,uint64,uint8,uint256)void">, params?: AppClientCallCoreParams & AppClientCompilationParams & IncludeSchema & CoreAppCallArgs & (OnCompleteNoOp)): Promise<AppCallTransactionResultOfType<void> & AppCallTransactionResult & Partial<AppCompilationResult> & AppReference>;
};
/**
* Gets available update methods
*/
get update(): {
/**
* Updates an existing instance of the Pool smart contract using the updateApplication()void ABI method.
*
* @param args The arguments for the smart contract call
* @param params Any additional parameters for the call
* @returns The update result
*/
updateApplication(args: MethodArgs<"updateApplication()void">, params?: AppClientCallCoreParams & AppClientCompilationParams & CoreAppCallArgs): Promise<AppCallTransactionResultOfType<void> & AppCallTransactionResult & Partial<AppCompilationResult>>;
};
/**
* Gets available delete methods
*/
get delete(): {
/**
* Deletes an existing instance of the Pool smart contract using the deleteApplication()void ABI method.
*
* @param args The arguments for the smart contract call
* @param params Any additional parameters for the call
* @returns The delete result
*/
deleteApplication(args: MethodArgs<"deleteApplication()void">, params?: AppClientCallCoreParams & CoreAppCallArgs): Promise<AppCallTransactionResultOfType<void> & AppCallTransactionResult>;
};
/**
* Makes a clear_state call to an existing instance of the Pool smart contract.
*
* @param args The arguments for the bare call
* @returns The clear_state result
*/
clearState(args?: BareCallArgs & AppClientCallCoreParams & CoreAppCallArgs): Promise<AppCallTransactionResult>;
/**
* Calls the arc200_name()byte[32] ABI method.
*
* @param args The arguments for the contract call
* @param params Any additional parameters for the call
* @returns The result of the call
*/
arc200Name(args: MethodArgs<'arc200_name()byte[32]'>, params?: AppClientCallCoreParams & CoreAppCallArgs): Promise<AppCallTransactionResultOfType<Uint8Array<ArrayBufferLike>> & AppCallTransactionResult>;
/**
* Calls the arc200_symbol()byte[8] ABI method.
*
* @param args The arguments for the contract call
* @param params Any additional parameters for the call
* @returns The result of the call
*/
arc200Symbol(args: MethodArgs<'arc200_symbol()byte[8]'>, params?: AppClientCallCoreParams & CoreAppCallArgs): Promise<AppCallTransactionResultOfType<Uint8Array<ArrayBufferLike>> & AppCallTransactionResult>;
/**
* Calls the arc200_decimals()uint8 ABI method.
*
* @param args The arguments for the contract call
* @param params Any additional parameters for the call
* @returns The result of the call
*/
arc200Decimals(args: MethodArgs<'arc200_decimals()uint8'>, params?: AppClientCallCoreParams & CoreAppCallArgs): Promise<AppCallTransactionResultOfType<number> & AppCallTransactionResult>;
/**