algosdk 1.12.0 → 1.13.1

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

@@ -3,12 +3,110 @@ import HTTPClient from '../../client';
 import IntDecoding from '../../../types/intDecoding';
 export default class LookupAssetBalances extends JSONRequest {
     private index;
+    /**
+     * Returns the list of accounts which hold the given asset and their balance.
+     *
+     * #### Example
+     * ```typescript
+     * const assetId = 163650;
+     * const assetBalances = await indexerClient.lookupAssetBalances(assetId).do();
+     * ```
+     *
+     * [Response data schema details](https://developer.algorand.org/docs/rest-apis/indexer/#get-v2assetsasset-idbalances)
+     * @param index - The asset ID to look up.
+     */
     constructor(c: HTTPClient, intDecoding: IntDecoding, index: number);
     path(): string;
+    /**
+     * Add a limit for filter.
+     *
+     * #### Example
+     * ```typescript
+     * const assetId = 163650;
+     * const maxResults = 20;
+     * const assetBalances = await indexerClient
+     *        .lookupAssetBalances(assetId)
+     *        .limit(maxResults)
+     *        .do();
+     * ```
+     *
+     * @param limit - maximum number of results to return.
+     */
     limit(limit: number): this;
+    /**
+     * Specify round to filter with.
+     *
+     * #### Example
+     * ```typescript
+     * const assetId = 163650;
+     * const targetBlock = 18309917;
+     * const assetBalances = await indexerClient
+     *        .lookupAssetBalances(assetId)
+     *        .round(targetBlock)
+     *        .do();
+     * ```
+     * @param round
+     */
     round(round: number): this;
+    /**
+     * Filtered results should have an asset balance greater than this value.
+     *
+     * #### Example
+     * ```typescript
+     * const assetId = 163650;
+     * const minBalance = 1000000;
+     * const assetBalances = await indexerClient
+     *        .lookupAssetBalances(assetId)
+     *        .currencyGreaterThan(minBalance)
+     *        .do();
+     * ```
+     * @param greater
+     */
     currencyGreaterThan(greater: number): this;
+    /**
+     * Filtered results should have an asset balance less than this value.
+     *
+     * #### Example
+     * ```typescript
+     * const assetId = 163650;
+     * const maxBalance = 2000000;
+     * const assetBalances = await indexerClient
+     *        .lookupAssetBalances(assetId)
+     *        .currencyLessThan(maxBalance)
+     *        .do();
+     * ```
+     * @param lesser
+     */
     currencyLessThan(lesser: number): this;
+    /**
+     * Specify the next page of results.
+     *
+     * #### Example
+     * ```typescript
+     * const assetId = 163650;
+     * const maxResults = 20;
+     * const nextToken = "APA6C7C3NCANRPIBUWQOF7WSKLJMK6RPQUVFLLDV4U5WCQE4DEF26D4E3E";
+     * const assetBalances = await indexerClient
+     *        .lookupAssetBalances(assetId)
+     *        .limit(maxResults)
+     *        .next(nextToken)
+     *        .do();
+     * ```
+     * @param nextToken - provided by the previous results.
+     */
     nextToken(nextToken: string): this;
+    /**
+     * Include all items including closed accounts, deleted applications, destroyed assets, opted-out asset holdings, and closed-out application localstates
+     *
+     * #### Example
+     * ```typescript
+     * const assetId = 163650;
+     * const assetBalances = await indexerClient
+     *        .lookupAssetBalances(assetId)
+     *        .includeAll(false)
+     *        .do();
+     * ```
+     * @param value
+     */
     includeAll(value?: boolean): this;
 }

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

@@ -1,13 +1,17 @@
-import HTTPClient, { TokenHeader } from '../client';
+import HTTPClient from '../client';
 import IntDecoding from '../../types/intDecoding';
+import { BaseHTTPClient } from '../baseHTTPClient';
+import { TokenHeader } from '../urlTokenBaseHTTPClient';
 export declare type TokenHeaderIdentifier = 'X-Indexer-API-Token' | 'X-KMD-API-Token' | 'X-Algo-API-Token' | string;
 /**
  * Abstract service client to encapsulate shared AlgodClient and IndexerClient logic
  */
 export default abstract class ServiceClient {
+    /** @ignore */
     c: HTTPClient;
+    /** @ignore */
     intDecoding: IntDecoding;
-    constructor(tokenHeaderIdentifier: TokenHeaderIdentifier, tokenHeaderOrStr: string | TokenHeader, baseServer: string, port?: string | number, defaultHeaders?: Record<string, any>);
+    constructor(tokenHeaderIdentifier: TokenHeaderIdentifier, tokenHeaderOrStrOrBaseClient: string | TokenHeader | BaseHTTPClient, baseServer: string, port?: string | number, defaultHeaders?: Record<string, any>);
     /**
      * Set the default int decoding method for all JSON requests this client creates.
      * @param method - \{"default" | "safe" | "mixed" | "bigint"\} method The method to use when parsing the

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

@@ -0,0 +1,160 @@
+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, approvalProgram, clearProgram, numGlobalInts, numGlobalByteSlices, numLocalInts, numLocalByteSlices, extraPages, note, lease, rekeyTo, signer, }: {
+        /** The ID of the smart contract to call. Set this to 0 to indicate an application creation 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 approval program for this application call. Only set this if this is an application creation call, or if onComplete is OnApplicationComplete.UpdateApplicationOC */
+        approvalProgram?: Uint8Array;
+        /** The clear program for this application call. Only set this if this is an application creation call, or if onComplete is OnApplicationComplete.UpdateApplicationOC */
+        clearProgram?: Uint8Array;
+        /** The global integer schema size. Only set this if this is an application creation call. */
+        numGlobalInts?: number;
+        /** The global byte slice schema size. Only set this if this is an application creation call. */
+        numGlobalByteSlices?: number;
+        /** The local integer schema size. Only set this if this is an application creation call. */
+        numLocalInts?: number;
+        /** The local byte slice schema size. Only set this if this is an application creation call. */
+        numLocalByteSlices?: number;
+        /** The number of extra pages to allocate for the application's programs. Only set this if this is an application creation call. If omitted, defaults to 0. */
+        extraPages?: number;
+        /** 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/dryrun.d.ts

@@ -0,0 +1,20 @@
+import AlgodClient from './client/v2/algod/algod';
+import { DryrunRequest, DryrunSource } from './client/v2/algod/models/types';
+import { SignedTransaction } from './transaction';
+/**
+ * createDryrun takes an Algod Client (from algod.AlgodV2Client) and an array of Signed Transactions
+ * from (transaction.SignedTransaction) and creates a DryrunRequest object with relevant balances
+ * @param client - the AlgodClient to make requests against
+ * @param txns - the array of SignedTransaction to use for generating the DryrunRequest object
+ * @param protocolVersion - the string representing the protocol version to use
+ * @param latestTimestamp - the timestamp
+ * @returns the DryrunRequest object constructed from the SignedTransactions passed
+ */
+export declare function createDryrun({ client, txns, protocolVersion, latestTimestamp, round, sources, }: {
+    client: AlgodClient;
+    txns: SignedTransaction[];
+    protocolVersion?: string;
+    latestTimestamp?: number | bigint;
+    round?: number | bigint;
+    sources?: DryrunSource[];
+}): Promise<DryrunRequest>;

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,8 @@ 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 { BaseHTTPClient, BaseHTTPClientResponse, BaseHTTPClientError, } from './client/baseHTTPClient';
+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 +76,12 @@ 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 './dryrun';
 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.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": "^97.0.0",
     "concurrently": "^6.2.0",
     "coveralls": "^3.1.0",
     "cucumber": "^5.1.0",
@@ -59,7 +59,9 @@
     "source-map-loader": "^2.0.2",
     "ts-loader": "^8.3.0",
     "ts-node": "^10.0.0",
-    "typedoc": "^0.20.36",
+    "typedoc": "^0.22.10",
+    "typedoc-plugin-missing-exports": "^0.22.6",
+    "typedoc-plugin-rename-defaults": "^0.4.0",
     "typescript": "^4.2.3",
     "webpack": "^5.38.1",
     "webpack-cli": "^4.7.2"
@@ -69,7 +71,7 @@
     "prepare": "npm run build",
     "prepare-browser-tests": "npm run build && mkdir -p tests/cucumber/browser/build && cp dist/browser/algosdk.min.* tests/cucumber/browser/build/ && webpack --config tests/cucumber/browser/webpack.config.js",
     "build": "concurrently \"webpack --config webpack.config.js\" \"tsc -p tsconfig-esm.json\" \"tsc -p tsconfig-cjs.json\"",
-    "docs": "typedoc src/main.ts",
+    "docs": "typedoc src/main.ts --options typedoc.config.json",
     "lint": "eslint .",
     "lint:fix": "eslint --fix .",
     "format": "prettier --write .",