algosdk 1.10.1 → 1.13.0-beta.1

package/dist/esm/src/types/intDecoding.js.map

@@ -1 +1 @@
-{"version":3,"file":"intDecoding.js","sourceRoot":"","sources":["../../../../src/types/intDecoding.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,6CAA6C;AAC7C,IAAK,WAuBJ;AAvBD,WAAK,WAAW;IACd;;;OAGG;IACH,kCAAmB,CAAA;IAEnB;;;OAGG;IACH,4BAAa,CAAA;IAEb;;;OAGG;IACH,8BAAe,CAAA;IAEf;;OAEG;IACH,gCAAiB,CAAA;AACnB,CAAC,EAvBI,WAAW,KAAX,WAAW,QAuBf;AACD,4CAA4C;AAE5C,eAAe,WAAW,CAAC"}
+{"version":3,"file":"intDecoding.js","sourceRoot":"","sources":["../../../../src/types/intDecoding.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,IAAK,WAuBJ;AAvBD,WAAK,WAAW;IACd;;;OAGG;IACH,kCAAmB,CAAA;IAEnB;;;OAGG;IACH,4BAAa,CAAA;IAEb;;;OAGG;IACH,8BAAe,CAAA;IAEf;;OAEG;IACH,gCAAiB,CAAA;AACnB,CAAC,EAvBI,WAAW,KAAX,WAAW,QAuBf;AAED,eAAe,WAAW,CAAC"}

package/dist/esm/src/types/transactions/base.js

@@ -1,4 +1,3 @@
-/* eslint-disable no-shadow,no-unused-vars */
 /**
  * Enum for application transaction types.
  *

package/dist/esm/src/types/transactions/base.js.map

@@ -1 +1 @@
-{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../../../src/types/transactions/base.ts"],"names":[],"mappings":"AAAA,6CAA6C;AAE7C;;;;GAIG;AACH,MAAM,CAAN,IAAY,eA8BX;AA9BD,WAAY,eAAe;IACzB;;OAEG;IACH,8BAAW,CAAA;IAEX;;OAEG;IACH,oCAAiB,CAAA;IAEjB;;OAEG;IACH,gCAAa,CAAA;IAEb;;OAEG;IACH,kCAAe,CAAA;IAEf;;OAEG;IACH,gCAAa,CAAA;IAEb;;OAEG;IACH,gCAAa,CAAA;AACf,CAAC,EA9BW,eAAe,KAAf,eAAe,QA8B1B;AAED;;GAEG;AACH,MAAM,CAAN,IAAY,qBAsCX;AAtCD,WAAY,qBAAqB;IAC/B;;;OAGG;IACH,qEAAM,CAAA;IAEN;;;OAGG;IACH,uEAAO,CAAA;IAEP;;;OAGG;IACH,6EAAU,CAAA;IAEV;;;;OAIG;IACH,iFAAY,CAAA;IAEZ;;;OAGG;IACH,+FAAmB,CAAA;IAEnB;;;;OAIG;IACH,+FAAmB,CAAA;AACrB,CAAC,EAtCW,qBAAqB,KAArB,qBAAqB,QAsChC"}
+{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../../../src/types/transactions/base.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAN,IAAY,eA8BX;AA9BD,WAAY,eAAe;IACzB;;OAEG;IACH,8BAAW,CAAA;IAEX;;OAEG;IACH,oCAAiB,CAAA;IAEjB;;OAEG;IACH,gCAAa,CAAA;IAEb;;OAEG;IACH,kCAAe,CAAA;IAEf;;OAEG;IACH,gCAAa,CAAA;IAEb;;OAEG;IACH,gCAAa,CAAA;AACf,CAAC,EA9BW,eAAe,KAAf,eAAe,QA8B1B;AAED;;GAEG;AACH,MAAM,CAAN,IAAY,qBAsCX;AAtCD,WAAY,qBAAqB;IAC/B;;;OAGG;IACH,qEAAM,CAAA;IAEN;;;OAGG;IACH,uEAAO,CAAA;IAEP;;;OAGG;IACH,6EAAU,CAAA;IAEV;;;;OAIG;IACH,iFAAY,CAAA;IAEZ;;;OAGG;IACH,+FAAmB,CAAA;IAEnB;;;;OAIG;IACH,+FAAmB,CAAA;AACrB,CAAC,EAtCW,qBAAqB,KAArB,qBAAqB,QAsChC"}

package/dist/esm/src/wait.js

@@ -0,0 +1,36 @@
+/**
+ * Wait until a transaction has been confirmed or rejected by the network, or
+ * until 'waitRounds' number of rounds have passed.
+ * @param client - An Algodv2 client
+ * @param txid - The ID of the transaction to wait for.
+ * @param waitRounds - The maximum number of rounds to wait for.
+ * @returns A promise that, upon success, will resolve to the output of the
+ *   `pendingTransactionInformation` call for the confirmed transaction.
+ */
+export async function waitForConfirmation(client, txid, waitRounds) {
+    // Wait until the transaction is confirmed or rejected, or until 'waitRounds'
+    // number of rounds have passed.
+    const status = await client.status().do();
+    if (typeof status === 'undefined') {
+        throw new Error('Unable to get node status');
+    }
+    const startRound = status['last-round'] + 1;
+    let currentRound = startRound;
+    /* eslint-disable no-await-in-loop */
+    while (currentRound < startRound + waitRounds) {
+        const pendingInfo = await client.pendingTransactionInformation(txid).do();
+        if (pendingInfo['confirmed-round']) {
+            // Got the completed Transaction
+            return pendingInfo;
+        }
+        if (pendingInfo['pool-error']) {
+            // If there was a pool error, then the transaction has been rejected!
+            throw new Error(`Transaction Rejected: ${pendingInfo['pool-error']}`);
+        }
+        await client.statusAfterBlock(currentRound).do();
+        currentRound += 1;
+    }
+    /* eslint-enable no-await-in-loop */
+    throw new Error(`Transaction not confirmed after ${waitRounds} rounds!`);
+}
+//# sourceMappingURL=wait.js.map

package/dist/esm/src/wait.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait.js","sourceRoot":"","sources":["../../../src/wait.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,MAAe,EACf,IAAY,EACZ,UAAkB;IAElB,6EAA6E;IAC7E,gCAAgC;IAEhC,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;IAC1C,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE;QACjC,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;KAC9C;IACD,MAAM,UAAU,GAAG,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;IAC5C,IAAI,YAAY,GAAG,UAAU,CAAC;IAE9B,qCAAqC;IACrC,OAAO,YAAY,GAAG,UAAU,GAAG,UAAU,EAAE;QAC7C,MAAM,WAAW,GAAG,MAAM,MAAM,CAAC,6BAA6B,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,CAAC;QAE1E,IAAI,WAAW,CAAC,iBAAiB,CAAC,EAAE;YAClC,gCAAgC;YAChC,OAAO,WAAW,CAAC;SACpB;QAED,IAAI,WAAW,CAAC,YAAY,CAAC,EAAE;YAC7B,qEAAqE;YACrE,MAAM,IAAI,KAAK,CAAC,yBAAyB,WAAW,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;SACvE;QAED,MAAM,MAAM,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC,EAAE,EAAE,CAAC;QACjD,YAAY,IAAI,CAAC,CAAC;KACnB;IACD,oCAAoC;IACpC,MAAM,IAAI,KAAK,CAAC,mCAAmC,UAAU,UAAU,CAAC,CAAC;AAC3E,CAAC"}

package/dist/types/src/abi/abi_type.d.ts

@@ -0,0 +1,102 @@
+export declare const MAX_LEN: number;
+export declare const ADDR_BYTE_SIZE = 32;
+export declare const SINGLE_BYTE_SIZE = 1;
+export declare const SINGLE_BOOL_SIZE = 1;
+export declare const LENGTH_ENCODE_BYTE_SIZE = 2;
+export declare type ABIValue = boolean | number | bigint | string | Uint8Array | ABIValue[];
+export declare abstract class ABIType {
+    abstract toString(): string;
+    abstract equal(other: ABIType): boolean;
+    abstract isDynamic(): boolean;
+    abstract byteLen(): number;
+    abstract encode(value: ABIValue): Uint8Array;
+    abstract decode(byteString: Uint8Array): ABIValue;
+    static from(str: string): ABIType;
+}
+export declare class ABIUintType extends ABIType {
+    bitSize: number;
+    constructor(size: number);
+    toString(): string;
+    equal(other: ABIUintType): boolean;
+    isDynamic(): boolean;
+    byteLen(): number;
+    encode(value: bigint | number): Uint8Array;
+    decode(byteString: Uint8Array): bigint;
+}
+export declare class ABIUfixedType extends ABIType {
+    bitSize: number;
+    precision: number;
+    constructor(size: number, denominator: number);
+    toString(): string;
+    equal(other: ABIUfixedType): boolean;
+    isDynamic(): boolean;
+    byteLen(): number;
+    encode(value: bigint | number): Uint8Array;
+    decode(byteString: Uint8Array): bigint;
+}
+export declare class ABIAddressType extends ABIType {
+    toString(): string;
+    equal(other: ABIAddressType): boolean;
+    isDynamic(): boolean;
+    byteLen(): number;
+    encode(value: string | Uint8Array): Uint8Array;
+    decode(byteString: Uint8Array): string;
+}
+export declare class ABIBoolType extends ABIType {
+    toString(): string;
+    equal(other: ABIBoolType): boolean;
+    isDynamic(): boolean;
+    byteLen(): number;
+    encode(value: boolean): Uint8Array;
+    decode(byteString: Uint8Array): boolean;
+}
+export declare class ABIByteType extends ABIType {
+    toString(): string;
+    equal(other: ABIByteType): boolean;
+    isDynamic(): boolean;
+    byteLen(): number;
+    encode(value: number): Uint8Array;
+    decode(byteString: Uint8Array): number;
+}
+export declare class ABIStringType extends ABIType {
+    toString(): string;
+    equal(other: ABIStringType): boolean;
+    isDynamic(): boolean;
+    byteLen(): never;
+    encode(value: string): Uint8Array;
+    decode(byteString: Uint8Array): string;
+}
+export declare class ABIArrayStaticType extends ABIType {
+    childType: ABIType;
+    staticLength: number;
+    constructor(argType: ABIType, arrayLength: number);
+    toString(): string;
+    equal(other: ABIArrayStaticType): boolean;
+    isDynamic(): boolean;
+    byteLen(): number;
+    encode(values: ABIValue[]): Uint8Array;
+    decode(byteString: Uint8Array): ABIValue[];
+    toABITupleType(): ABITupleType;
+}
+export declare class ABIArrayDynamicType extends ABIType {
+    childType: ABIType;
+    constructor(argType: ABIType);
+    toString(): string;
+    equal(other: ABIArrayDynamicType): boolean;
+    isDynamic(): boolean;
+    byteLen(): never;
+    encode(values: ABIValue[]): Uint8Array;
+    decode(byteString: Uint8Array): ABIValue[];
+    toABITupleType(length: number): ABITupleType;
+}
+export declare class ABITupleType extends ABIType {
+    childTypes: ABIType[];
+    constructor(argTypes: ABIType[]);
+    toString(): string;
+    equal(other: ABITupleType): boolean;
+    isDynamic(): boolean;
+    byteLen(): number;
+    encode(values: ABIValue[]): Uint8Array;
+    decode(byteString: Uint8Array): ABIValue[];
+    static parseTupleContent(str: string): string[];
+}

package/dist/types/src/abi/contract.d.ts

@@ -0,0 +1,13 @@
+import { ABIMethod, ABIMethodParams } from './method';
+export interface ABIContractParams {
+    name: string;
+    appId: number;
+    methods: ABIMethodParams[];
+}
+export declare class ABIContract {
+    readonly name: string;
+    readonly appId: number;
+    readonly methods: ABIMethod[];
+    constructor(params: ABIContractParams);
+    toJSON(): ABIContractParams;
+}

package/dist/types/src/abi/index.d.ts

@@ -0,0 +1,4 @@
+export * from './abi_type';
+export * from './contract';
+export * from './interface';
+export * from './method';

package/dist/types/src/abi/interface.d.ts

@@ -0,0 +1,11 @@
+import { ABIMethod, ABIMethodParams } from './method';
+export interface ABIInterfaceParams {
+    name: string;
+    methods: ABIMethodParams[];
+}
+export declare class ABIInterface {
+    readonly name: string;
+    readonly methods: ABIMethod[];
+    constructor(params: ABIInterfaceParams);
+    toJSON(): ABIInterfaceParams;
+}

package/dist/types/src/abi/method.d.ts

@@ -0,0 +1,37 @@
+import { TransactionType } from '../types/transactions/base';
+import { ABIType } from './abi_type';
+export declare function abiTypeIsTransaction(type: string): type is TransactionType;
+export interface ABIMethodParams {
+    name: string;
+    desc?: string;
+    args: Array<{
+        type: string;
+        name?: string;
+        desc?: string;
+    }>;
+    returns: {
+        type: string;
+        desc?: string;
+    };
+}
+export declare type ABIArgumentType = ABIType | TransactionType;
+export declare type ABIReturnType = ABIType | 'void';
+export declare class ABIMethod {
+    readonly name: string;
+    readonly description?: string;
+    readonly args: Array<{
+        type: ABIArgumentType;
+        name?: string;
+        description?: string;
+    }>;
+    readonly returns: {
+        type: ABIReturnType;
+        description?: string;
+    };
+    constructor(params: ABIMethodParams);
+    getSignature(): string;
+    getSelector(): Uint8Array;
+    txnCount(): number;
+    toJSON(): ABIMethodParams;
+    static fromSignature(signature: string): ABIMethod;
+}

package/dist/types/src/client/v2/algod/models/types.d.ts

@@ -286,7 +286,7 @@ export declare class ApplicationParams extends BaseModel {
      */
     globalState?: TealKeyValue[];
     /**
-     * [\lsch) global schema
+     * [\gsch) global schema
      */
     globalStateSchema?: ApplicationStateSchema;
     /**
@@ -301,7 +301,7 @@ export declare class ApplicationParams extends BaseModel {
      * parameters and global state for this application can be found.
      * @param extraProgramPages - (epp) the amount of extra program pages available to this app.
      * @param globalState - [\gs) global schema
-     * @param globalStateSchema - [\lsch) global schema
+     * @param globalStateSchema - [\gsch) global schema
      * @param localStateSchema - [\lsch) local schema
      */
     constructor({ approvalProgram, clearStateProgram, creator, extraProgramPages, globalState, globalStateSchema, localStateSchema, }: {
@@ -746,6 +746,10 @@ export declare class DryrunTxnResult extends BaseModel {
     disassembly: string[];
     appCallMessages?: string[];
     appCallTrace?: DryrunState[];
+    /**
+     * Execution cost of app call transaction
+     */
+    cost?: number | bigint;
     /**
      * Application state delta.
      */
@@ -753,24 +757,29 @@ export declare class DryrunTxnResult extends BaseModel {
     localDeltas?: AccountStateDelta[];
     logicSigMessages?: string[];
     logicSigTrace?: DryrunState[];
+    logs?: Uint8Array[];
     /**
      * Creates a new `DryrunTxnResult` object.
      * @param disassembly - Disassembled program line by line.
      * @param appCallMessages -
      * @param appCallTrace -
+     * @param cost - Execution cost of app call transaction
      * @param globalDelta - Application state delta.
      * @param localDeltas -
      * @param logicSigMessages -
      * @param logicSigTrace -
+     * @param logs -
      */
-    constructor({ disassembly, appCallMessages, appCallTrace, globalDelta, localDeltas, logicSigMessages, logicSigTrace, }: {
+    constructor({ disassembly, appCallMessages, appCallTrace, cost, globalDelta, localDeltas, logicSigMessages, logicSigTrace, logs, }: {
         disassembly: string[];
         appCallMessages?: string[];
         appCallTrace?: DryrunState[];
+        cost?: number | bigint;
         globalDelta?: EvalDeltaKeyValue[];
         localDeltas?: AccountStateDelta[];
         logicSigMessages?: string[];
         logicSigTrace?: DryrunState[];
+        logs?: Uint8Array[];
     });
 }
 /**
@@ -939,14 +948,8 @@ export declare class NodeStatusResponse extends BaseModel {
     });
 }
 /**
- * Given a transaction id of a recently submitted transaction, it returns
- * information about it. There are several cases when this might succeed:
- * - transaction committed (committed round > 0)
- * - transaction still in the pool (committed round = 0, pool error = "")
- * - transaction removed from pool due to error (committed round = 0, pool error !=
- * "")
- * Or the transaction may have happened sufficiently long ago that the node no
- * longer remembers it, and this will return an error.
+ * Details about a pending transaction. If the transaction was recently confirmed,
+ * includes confirmation details like the round and reward details.
  */
 export declare class PendingTransactionResponse extends BaseModel {
     /**
@@ -989,11 +992,19 @@ export declare class PendingTransactionResponse extends BaseModel {
      * transaction.
      */
     globalStateDelta?: EvalDeltaKeyValue[];
+    /**
+     * Inner transactions produced by application execution.
+     */
+    innerTxns?: PendingTransactionResponse[];
     /**
      * (ld) Local state key/value changes for the application being executed by this
      * transaction.
      */
     localStateDelta?: AccountStateDelta[];
+    /**
+     * (lg) Logs for the application being executed by this transaction.
+     */
+    logs?: Uint8Array[];
     /**
      * Rewards in microalgos applied to the receiver account.
      */
@@ -1017,12 +1028,14 @@ export declare class PendingTransactionResponse extends BaseModel {
      * @param confirmedRound - The round where this transaction was confirmed, if present.
      * @param globalStateDelta - (gd) Global state key/value changes for the application being executed by this
      * transaction.
+     * @param innerTxns - Inner transactions produced by application execution.
      * @param localStateDelta - (ld) Local state key/value changes for the application being executed by this
      * transaction.
+     * @param logs - (lg) Logs for the application being executed by this transaction.
      * @param receiverRewards - Rewards in microalgos applied to the receiver account.
      * @param senderRewards - Rewards in microalgos applied to the sender account.
      */
-    constructor({ poolError, txn, applicationIndex, assetClosingAmount, assetIndex, closeRewards, closingAmount, confirmedRound, globalStateDelta, localStateDelta, receiverRewards, senderRewards, }: {
+    constructor({ poolError, txn, applicationIndex, assetClosingAmount, assetIndex, closeRewards, closingAmount, confirmedRound, globalStateDelta, innerTxns, localStateDelta, logs, receiverRewards, senderRewards, }: {
         poolError: string;
         txn: EncodedSignedTransaction;
         applicationIndex?: number | bigint;
@@ -1032,7 +1045,9 @@ export declare class PendingTransactionResponse extends BaseModel {
         closingAmount?: number | bigint;
         confirmedRound?: number | bigint;
         globalStateDelta?: EvalDeltaKeyValue[];
+        innerTxns?: PendingTransactionResponse[];
         localStateDelta?: AccountStateDelta[];
+        logs?: Uint8Array[];
         receiverRewards?: number | bigint;
         senderRewards?: number | bigint;
     });
@@ -1141,7 +1156,7 @@ export declare class TealKeyValue extends BaseModel {
  */
 export declare class TealValue extends BaseModel {
     /**
-     * (tt) value type.
+     * (tt) value type. Value `1` refers to **bytes**, value `2` refers to **uint**
      */
     type: number | bigint;
     /**
@@ -1154,7 +1169,7 @@ export declare class TealValue extends BaseModel {
     uint: number | bigint;
     /**
      * Creates a new `TealValue` object.
-     * @param type - (tt) value type.
+     * @param type - (tt) value type. Value `1` refers to **bytes**, value `2` refers to **uint**
      * @param bytes - (tb) bytes value.
      * @param uint - (ui) uint value.
      */

package/dist/types/src/client/v2/indexer/indexer.d.ts

@@ -9,6 +9,7 @@ import LookupTransactionByID from './lookupTransactionByID';
 import LookupAccountByID from './lookupAccountByID';
 import LookupAssetByID from './lookupAssetByID';
 import LookupApplications from './lookupApplications';
+import LookupApplicationLogs from './lookupApplicationLogs';
 import SearchAccounts from './searchAccounts';
 import SearchForTransactions from './searchForTransactions';
 import SearchForAssets from './searchForAssets';
@@ -59,6 +60,11 @@ export default class IndexerClient extends ServiceClient {
      * @param index - The ID of the application to look up.
      */
     lookupApplications(index: number): LookupApplications;
+    /**
+     * Returns log messages generated by the passed in application.
+     * @param appID - The ID of the application which generated the logs.
+     */
+    lookupApplicationLogs(appID: number): LookupApplicationLogs;
     /**
      * Returns information about indexed accounts.
      */

package/dist/types/src/client/v2/indexer/lookupApplicationLogs.d.ts

@@ -0,0 +1,20 @@
+import JSONRequest from '../jsonrequest';
+import HTTPClient from '../../client';
+import IntDecoding from '../../../types/intDecoding';
+export default class LookupApplicationLogs extends JSONRequest {
+    private appID;
+    constructor(c: HTTPClient, intDecoding: IntDecoding, appID: number);
+    path(): string;
+    /** limit for filter, as int */
+    limit(limit: number): this;
+    /** min round to filter with, as int */
+    minRound(round: number): this;
+    /** max round to filter with, as int */
+    maxRound(round: number): this;
+    /** used for pagination */
+    nextToken(nextToken: string): this;
+    /** only include transactions with this sender address */
+    sender(senderAddress: string): this;
+    /** txid to filter with, as string */
+    txid(txid: string): this;
+}

package/dist/types/src/composer.d.ts

@@ -0,0 +1,146 @@
+import { ABIValue, ABIMethod } from './abi';
+import Algodv2 from './client/v2/algod/algod';
+import { TransactionSigner, TransactionWithSigner } from './signer';
+import { OnApplicationComplete, SuggestedParams } from './types/transactions/base';
+export declare type ABIArgument = ABIValue | TransactionWithSigner;
+/** Represents the output from a successful ABI method call. */
+export interface ABIResult {
+    /** The TxID of the transaction that invoked the ABI method call. */
+    txID: string;
+    /**
+     * The raw bytes of the return value from the ABI method call. This will be empty if the method
+     * does not return a value (return type "void").
+     */
+    rawReturnValue: Uint8Array;
+    /**
+     * The return value from the ABI method call. This will be undefined if the method does not return
+     * a value (return type "void"), or if the SDK was unable to decode the returned value.
+     */
+    returnValue?: ABIValue;
+    /** If the SDK was unable to decode a return value, the error will be here. */
+    decodeError?: Error;
+}
+export declare enum AtomicTransactionComposerStatus {
+    /** The atomic group is still under construction. */
+    BUILDING = 0,
+    /** The atomic group has been finalized, but not yet signed. */
+    BUILT = 1,
+    /** The atomic group has been finalized and signed, but not yet submitted to the network. */
+    SIGNED = 2,
+    /** The atomic group has been finalized, signed, and submitted to the network. */
+    SUBMITTED = 3,
+    /** The atomic group has been finalized, signed, submitted, and successfully committed to a block. */
+    COMMITTED = 4
+}
+/** A class used to construct and execute atomic transaction groups */
+export declare class AtomicTransactionComposer {
+    /** The maximum size of an atomic transaction group. */
+    static MAX_GROUP_SIZE: number;
+    private status;
+    private transactions;
+    private methodCalls;
+    private signedTxns;
+    private txIDs;
+    /**
+     * Get the status of this composer's transaction group.
+     */
+    getStatus(): AtomicTransactionComposerStatus;
+    /**
+     * Get the number of transactions currently in this atomic group.
+     */
+    count(): number;
+    /**
+     * Create a new composer with the same underlying transactions. The new composer's status will be
+     * BUILDING, so additional transactions may be added to it.
+     */
+    clone(): AtomicTransactionComposer;
+    /**
+     * Add a transaction to this atomic group.
+     *
+     * An error will be thrown if the transaction has a nonzero group ID, the composer's status is
+     * not BUILDING, or if adding this transaction causes the current group to exceed MAX_GROUP_SIZE.
+     */
+    addTransaction(txnAndSigner: TransactionWithSigner): void;
+    /**
+     * Add a smart contract method call to this atomic group.
+     *
+     * An error will be thrown if the composer's status is not BUILDING, if adding this transaction
+     * causes the current group to exceed MAX_GROUP_SIZE, or if the provided arguments are invalid
+     * for the given method.
+     */
+    addMethodCall({ appId, method, methodArgs, sender, suggestedParams, onComplete, note, lease, rekeyTo, signer, }: {
+        /** The ID of the smart contract to call */
+        appId: number;
+        /** The method to call on the smart contract */
+        method: ABIMethod;
+        /** The arguments to include in the method call. If omitted, no arguments will be passed to the method. */
+        methodArgs?: ABIArgument[];
+        /** The address of the sender of this application call */
+        sender: string;
+        /** Transactions params to use for this application call */
+        suggestedParams: SuggestedParams;
+        /** The OnComplete action to take for this application call. If omitted, OnApplicationComplete.NoOpOC will be used. */
+        onComplete?: OnApplicationComplete;
+        /** The note value for this application call */
+        note?: Uint8Array;
+        /** The lease value for this application call */
+        lease?: Uint8Array;
+        /** If provided, the address that the sender will be rekeyed to at the conclusion of this application call */
+        rekeyTo?: string;
+        /** A transaction signer that can authorize this application call from sender */
+        signer: TransactionSigner;
+    }): void;
+    /**
+     * Finalize the transaction group and returned the finalized transactions.
+     *
+     * The composer's status will be at least BUILT after executing this method.
+     */
+    buildGroup(): TransactionWithSigner[];
+    /**
+     * Obtain signatures for each transaction in this group. If signatures have already been obtained,
+     * this method will return cached versions of the signatures.
+     *
+     * The composer's status will be at least SIGNED after executing this method.
+     *
+     * An error will be thrown if signing any of the transactions fails.
+     *
+     * @returns A promise that resolves to an array of signed transactions.
+     */
+    gatherSignatures(): Promise<Uint8Array[]>;
+    /**
+     * Send the transaction group to the network, but don't wait for it to be committed to a block. An
+     * error will be thrown if submission fails.
+     *
+     * The composer's status must be SUBMITTED or lower before calling this method. If submission is
+     * successful, this composer's status will update to SUBMITTED.
+     *
+     * Note: a group can only be submitted again if it fails.
+     *
+     * @param client - An Algodv2 client
+     *
+     * @returns A promise that, upon success, resolves to a list of TxIDs of the submitted transactions.
+     */
+    submit(client: Algodv2): Promise<string[]>;
+    /**
+     * Send the transaction group to the network and wait until it's committed to a block. An error
+     * will be thrown if submission or execution fails.
+     *
+     * The composer's status must be SUBMITTED or lower before calling this method, since execution is
+     * only allowed once. If submission is successful, this composer's status will update to SUBMITTED.
+     * If the execution is also successful, this composer's status will update to COMMITTED.
+     *
+     * Note: a group can only be submitted again if it fails.
+     *
+     * @param client - An Algodv2 client
+     * @param waitRounds - The maximum number of rounds to wait for transaction confirmation
+     *
+     * @returns A promise that, upon success, resolves to an object containing the confirmed round for
+     *   this transaction, the txIDs of the submitted transactions, and an array of results containing
+     *   one element for each method call transaction in this group.
+     */
+    execute(client: Algodv2, waitRounds: number): Promise<{
+        confirmedRound: number;
+        txIDs: string[];
+        methodResults: ABIResult[];
+    }>;
+}

package/dist/types/src/encoding/address.d.ts

@@ -49,3 +49,9 @@ export declare function fromMultisigPreImgAddrs({ version, threshold, addrs, }:
     threshold: number;
     addrs: string[];
 }): string;
+/**
+ * Get the escrow address of an application.
+ * @param appID - The ID of the application.
+ * @returns The address corresponding to that application's escrow account.
+ */
+export declare function getApplicationAddress(appID: number | bigint): string;

package/dist/types/src/encoding/bigint.d.ts

@@ -0,0 +1,14 @@
+/**
+ * bigIntToBytes converts a BigInt to a big-endian Uint8Array for encoding.
+ * @param bi - The bigint to convert.
+ * @param size - The size of the resulting byte array.
+ * @returns A byte array containing the big-endian encoding of the input bigint
+ */
+export declare function bigIntToBytes(bi: bigint | number, size: number): Uint8Array;
+/**
+ * bytesToBigInt produces a bigint from a binary representation.
+ *
+ * @param bytes - The Uint8Array to convert.
+ * @returns The bigint that was encoded in the input data.
+ */
+export declare function bytesToBigInt(bytes: Uint8Array): bigint;

package/dist/types/src/logic/logic.d.ts

@@ -17,7 +17,7 @@ export declare function readProgram(program: Uint8Array, args?: Uint8Array[]): [
  * @throws
  * @returns true if success
  */
-export declare function checkProgram(program: Uint8Array, args: Uint8Array[]): boolean;
+export declare function checkProgram(program: Uint8Array, args?: Uint8Array[]): boolean;
 export declare function checkIntConstBlock(program: Uint8Array, pc: number): number;
 export declare function checkByteConstBlock(program: Uint8Array, pc: number): number;
 export declare function checkPushIntOp(program: Uint8Array, pc: number): number;