algosdk 1.12.0 → 1.13.0-beta.1

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, }: {
@@ -1156,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;
     /**
@@ -1169,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/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/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/main.d.ts

@@ -1,6 +1,5 @@
 import * as txnBuilder from './transaction';
 import { BidOptions } from './bid';
-import { MultisigMetadata } from './types/multisig';
 export declare const MULTISIG_BAD_SENDER_ERROR_MSG = "The transaction sender address and multisig preimage do not match.";
 /**
  * signTransaction takes an object with either payment or key registration fields and
@@ -46,50 +45,6 @@ export declare function signBytes(bytes: Uint8Array, sk: Uint8Array): Uint8Array
  * @returns bool
  */
 export declare function verifyBytes(bytes: Uint8Array, signature: Uint8Array, addr: string): boolean;
-/**
- * signMultisigTransaction takes a raw transaction (see signTransaction), a multisig preimage, a secret key, and returns
- * a multisig transaction, which is a blob representing a transaction and multisignature account preimage. The returned
- * multisig txn can accumulate additional signatures through mergeMultisigTransactions or appendMultisigTransaction.
- * @param txn - object with either payment or key registration fields
- * @param version - multisig version
- * @param threshold - multisig threshold
- * @param addrs - a list of Algorand addresses representing possible signers for this multisig. Order is important.
- * @param sk - Algorand secret key. The corresponding pk should be in the pre image.
- * @returns object containing txID, and blob of partially signed multisig transaction (with multisig preimage information)
- * If the final calculated fee is lower than the protocol minimum fee, the fee will be increased to match the minimum.
- */
-export declare function signMultisigTransaction(txn: txnBuilder.TransactionLike, { version, threshold, addrs }: MultisigMetadata, sk: Uint8Array): {
-    txID: string;
-    blob: Uint8Array;
-};
-/**
- * mergeMultisigTransactions takes a list of multisig transaction blobs, and merges them.
- * @param multisigTxnBlobs - a list of blobs representing encoded multisig txns
- * @returns blob representing encoded multisig txn
- */
-export declare function mergeMultisigTransactions(multisigTxnBlobs: Uint8Array[]): Uint8Array;
-/**
- * appendSignMultisigTransaction takes a multisig transaction blob, and appends our signature to it.
- * While we could derive public key preimagery from the partially-signed multisig transaction,
- * we ask the caller to pass it back in, to ensure they know what they are signing.
- * @param multisigTxnBlob - an encoded multisig txn. Supports non-payment txn types.
- * @param version - multisig version
- * @param threshold - multisig threshold
- * @param addrs - a list of Algorand addresses representing possible signers for this multisig. Order is important.
- * @param sk - Algorand secret key
- * @returns object containing txID, and blob representing encoded multisig txn
- */
-export declare function appendSignMultisigTransaction(multisigTxnBlob: Uint8Array, { version, threshold, addrs }: MultisigMetadata, sk: Uint8Array): {
-    txID: string;
-    blob: Uint8Array;
-};
-/**
- * multisigAddress takes multisig metadata (preimage) and returns the corresponding human readable Algorand address.
- * @param version - mutlisig version
- * @param threshold - multisig threshold
- * @param addrs - list of Algorand addresses
- */
-export declare function multisigAddress({ version, threshold, addrs, }: MultisigMetadata): string;
 /**
  * encodeObj takes a javascript object and returns its msgpack encoding
  * Note that the encoding sorts the fields alphabetically
@@ -111,6 +66,7 @@ export { default as Kmd } from './client/kmd';
 export { default as IntDecoding } from './types/intDecoding';
 export { default as Account } from './types/account';
 export { default as Indexer } from './client/v2/indexer/indexer';
+export { waitForConfirmation } from './wait';
 export { isValidAddress, encodeAddress, decodeAddress, getApplicationAddress, } from './encoding/address';
 export { encodeUint64, decodeUint64 } from './encoding/uint64';
 export { default as generateAccount } from './account';
@@ -119,7 +75,11 @@ export { mnemonicToMasterDerivationKey, masterDerivationKeyToMnemonic, secretKey
 export { microalgosToAlgos, algosToMicroalgos, INVALID_MICROALGOS_ERROR_MSG, } from './convert';
 export { computeGroupID, assignGroupID } from './group';
 export { LogicSigAccount, makeLogicSig, signLogicSigTransaction, signLogicSigTransactionObject, logicSigFromByte, tealSign, tealSignFromProgram, } from './logicsig';
+export { signMultisigTransaction, mergeMultisigTransactions, appendSignMultisigTransaction, multisigAddress, } from './multisig';
 export declare const LogicTemplates: any;
 export * from './makeTxn';
 export * from './transaction';
+export * from './signer';
+export * from './composer';
 export * from './types';
+export * from './abi';

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

@@ -455,7 +455,7 @@ export declare function makeApplicationDeleteTxnFromObject(o: Pick<RenamePropert
  * @param lease - Lease a transaction
  * @param rekeyTo - String representation of the Algorand address that will be used to authorize all future transactions
  */
-export declare function makeApplicationOptInTxn(from: AppOptInTxn['from'], suggestedParams: MustHaveSuggestedParams<AppOptInTxn>['suggestedParams'], appIndex: AppOptInTxn['appIndex'], appArgs?: AppOptInTxn['appArgs'], accounts?: AppOptInTxn['appAccounts'], foreignApps?: AppOptInTxn['appForeignApps'], foreignAssets?: AppOptInTxn['appForeignApps'], note?: AppOptInTxn['note'], lease?: AppOptInTxn['lease'], rekeyTo?: AppOptInTxn['reKeyTo']): txnBuilder.Transaction;
+export declare function makeApplicationOptInTxn(from: AppOptInTxn['from'], suggestedParams: MustHaveSuggestedParams<AppOptInTxn>['suggestedParams'], appIndex: AppOptInTxn['appIndex'], appArgs?: AppOptInTxn['appArgs'], accounts?: AppOptInTxn['appAccounts'], foreignApps?: AppOptInTxn['appForeignApps'], foreignAssets?: AppOptInTxn['appForeignAssets'], note?: AppOptInTxn['note'], lease?: AppOptInTxn['lease'], rekeyTo?: AppOptInTxn['reKeyTo']): txnBuilder.Transaction;
 export declare function makeApplicationOptInTxnFromObject(o: Pick<RenameProperties<MustHaveSuggestedParams<AppOptInTxn>, {
     appAccounts: 'accounts';
     appForeignApps: 'foreignApps';
@@ -544,3 +544,20 @@ export declare function makeApplicationNoOpTxnFromObject(o: Pick<RenamePropertie
     reKeyTo: 'rekeyTo';
 }>, 'from' | 'suggestedParams' | 'appIndex' | 'appArgs' | 'accounts' | 'foreignApps' | 'foreignAssets' | 'note' | 'lease' | 'rekeyTo'>): txnBuilder.Transaction;
 export { OnApplicationComplete } from './types/transactions/base';
+/**
+ * Generic function for creating any application call transaction.
+ */
+export declare function makeApplicationCallTxnFromObject(options: Pick<RenameProperties<MustHaveSuggestedParams<AppCreateTxn>, {
+    appOnComplete: 'onComplete';
+    appAccounts: 'accounts';
+    appForeignApps: 'foreignApps';
+    appForeignAssets: 'foreignAssets';
+    reKeyTo: 'rekeyTo';
+}>, 'from' | 'suggestedParams' | 'appIndex' | 'onComplete' | 'appArgs' | 'accounts' | 'foreignApps' | 'foreignAssets' | 'note' | 'lease' | 'rekeyTo' | 'extraPages'> & Partial<Pick<RenameProperties<MustHaveSuggestedParams<AppCreateTxn>, {
+    appApprovalProgram: 'approvalProgram';
+    appClearProgram: 'clearProgram';
+    appLocalInts: 'numLocalInts';
+    appLocalByteSlices: 'numLocalByteSlices';
+    appGlobalInts: 'numGlobalInts';
+    appGlobalByteSlices: 'numGlobalByteSlices';
+}>, 'approvalProgram' | 'clearProgram' | 'numLocalInts' | 'numLocalByteSlices' | 'numGlobalInts' | 'numGlobalByteSlices'>>): txnBuilder.Transaction;

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

@@ -50,4 +50,42 @@ export declare class MultisigTransaction extends txnBuilder.Transaction {
  */
 export declare function mergeMultisigTransactions(multisigTxnBlobs: Uint8Array[]): Uint8Array;
 export declare function verifyMultisig(toBeVerified: Uint8Array, msig: EncodedMultisig, publicKey: Uint8Array): boolean;
-export default MultisigTransaction;
+/**
+ * signMultisigTransaction takes a raw transaction (see signTransaction), a multisig preimage, a secret key, and returns
+ * a multisig transaction, which is a blob representing a transaction and multisignature account preimage. The returned
+ * multisig txn can accumulate additional signatures through mergeMultisigTransactions or appendMultisigTransaction.
+ * @param txn - object with either payment or key registration fields
+ * @param version - multisig version
+ * @param threshold - multisig threshold
+ * @param addrs - a list of Algorand addresses representing possible signers for this multisig. Order is important.
+ * @param sk - Algorand secret key. The corresponding pk should be in the pre image.
+ * @returns object containing txID, and blob of partially signed multisig transaction (with multisig preimage information)
+ * If the final calculated fee is lower than the protocol minimum fee, the fee will be increased to match the minimum.
+ */
+export declare function signMultisigTransaction(txn: txnBuilder.TransactionLike, { version, threshold, addrs }: MultisigMetadata, sk: Uint8Array): {
+    txID: string;
+    blob: Uint8Array;
+};
+/**
+ * appendSignMultisigTransaction takes a multisig transaction blob, and appends our signature to it.
+ * While we could derive public key preimagery from the partially-signed multisig transaction,
+ * we ask the caller to pass it back in, to ensure they know what they are signing.
+ * @param multisigTxnBlob - an encoded multisig txn. Supports non-payment txn types.
+ * @param version - multisig version
+ * @param threshold - multisig threshold
+ * @param addrs - a list of Algorand addresses representing possible signers for this multisig. Order is important.
+ * @param sk - Algorand secret key
+ * @returns object containing txID, and blob representing encoded multisig txn
+ */
+export declare function appendSignMultisigTransaction(multisigTxnBlob: Uint8Array, { version, threshold, addrs }: MultisigMetadata, sk: Uint8Array): {
+    txID: string;
+    blob: Uint8Array;
+};
+/**
+ * multisigAddress takes multisig metadata (preimage) and returns the corresponding human readable Algorand address.
+ * @param version - mutlisig version
+ * @param threshold - multisig threshold
+ * @param addrs - list of Algorand addresses
+ */
+export declare function multisigAddress({ version, threshold, addrs, }: MultisigMetadata): string;
+export {};

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

@@ -0,0 +1,40 @@
+import { Transaction } from './transaction';
+import Account from './types/account';
+import { LogicSigAccount } from './logicsig';
+import { MultisigMetadata } from './types/multisig';
+/**
+ * This type represents a function which can sign transactions from an atomic transaction group.
+ * @param txnGroup - The atomic group containing transactions to be signed
+ * @param indexesToSign - An array of indexes in the atomic transaction group that should be signed
+ * @returns A promise which resolves an array of encoded signed transactions. The length of the
+ *   array will be the same as the length of indexesToSign, and each index i in the array
+ *   corresponds to the signed transaction from txnGroup[indexesToSign[i]]
+ */
+export declare type TransactionSigner = (txnGroup: Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
+/**
+ * Create a TransactionSigner that can sign transactions for the provided basic Account.
+ */
+export declare function makeBasicAccountTransactionSigner(account: Account): TransactionSigner;
+/**
+ * Create a TransactionSigner that can sign transactions for the provided LogicSigAccount.
+ */
+export declare function makeLogicSigAccountTransactionSigner(account: LogicSigAccount): TransactionSigner;
+/**
+ * Create a TransactionSigner that can sign transactions for the provided Multisig account.
+ * @param msig - The Multisig account metadata
+ * @param sks - An array of private keys belonging to the msig which should sign the transactions.
+ */
+export declare function makeMultiSigAccountTransactionSigner(msig: MultisigMetadata, sks: Uint8Array[]): TransactionSigner;
+/** Represents an unsigned transactions and a signer that can authorize that transaction. */
+export interface TransactionWithSigner {
+    /** An unsigned transaction */
+    txn: Transaction;
+    /** A transaction signer that can authorize txn */
+    signer: TransactionSigner;
+}
+/**
+ * Check if a value conforms to the TransactionWithSigner structure.
+ * @param value - The value to check.
+ * @returns True if an only if the value has the structure of a TransactionWithSigner.
+ */
+export declare function isTransactionWithSigner(value: any): value is TransactionWithSigner;

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

@@ -0,0 +1,11 @@
+import Algodv2 from './client/v2/algod/algod';
+/**
+ * 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 declare function waitForConfirmation(client: Algodv2, txid: string, waitRounds: number): Promise<Record<string, any>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "algosdk",
-  "version": "1.12.0",
+  "version": "1.13.0-beta.1",
   "description": "The official JavaScript SDK for Algorand",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -36,7 +36,7 @@
     "@typescript-eslint/eslint-plugin": "^4.26.1",
     "@typescript-eslint/parser": "^4.26.1",
     "assert": "^2.0.0",
-    "chromedriver": "^93.0.1",
+    "chromedriver": "^95.0.0",
     "concurrently": "^6.2.0",
     "coveralls": "^3.1.0",
     "cucumber": "^5.1.0",