algosdk 1.11.0 → 1.13.0-beta.2

package/dist/types/src/client/urlTokenBaseHTTPClient.d.ts

@@ -0,0 +1,44 @@
+import { BaseHTTPClient, BaseHTTPClientResponse, Query } from './baseHTTPClient';
+export interface AlgodTokenHeader {
+    'X-Algo-API-Token': string;
+}
+export interface IndexerTokenHeader {
+    'X-Indexer-API-Token': string;
+}
+export interface KMDTokenHeader {
+    'X-KMD-API-Token': string;
+}
+export interface CustomTokenHeader {
+    [headerName: string]: string;
+}
+export declare type TokenHeader = AlgodTokenHeader | IndexerTokenHeader | KMDTokenHeader | CustomTokenHeader;
+/**
+ * Implementation of BaseHTTPClient that uses a URL and a token
+ * and make the REST queries using superagent.
+ * This is the default implementation of BaseHTTPClient.
+ */
+export declare class URLTokenBaseHTTPClient implements BaseHTTPClient {
+    private defaultHeaders;
+    private readonly baseURL;
+    private readonly tokenHeader;
+    constructor(tokenHeader: TokenHeader, baseServer: string, port?: string | number, defaultHeaders?: Record<string, any>);
+    /**
+     * Compute the URL for a path relative to the instance's address
+     * @param relativePath - A path string
+     * @returns A URL string
+     */
+    private addressWithPath;
+    /**
+     * Convert a superagent response to a valid BaseHTTPClientResponse
+     * Modify the superagent response
+     * @private
+     */
+    private static superagentToHTTPClientResponse;
+    /**
+     * Make a superagent error more readable. For more info, see https://github.com/visionmedia/superagent/issues/1074
+     */
+    private static formatSuperagentError;
+    get(relativePath: string, query?: Query<string>, requestHeaders?: Record<string, string>): Promise<BaseHTTPClientResponse>;
+    post(relativePath: string, data: Uint8Array, query?: Query<string>, requestHeaders?: Record<string, string>): Promise<BaseHTTPClientResponse>;
+    delete(relativePath: string, data: Uint8Array, query?: Query<string>, requestHeaders?: Record<string, string>): Promise<BaseHTTPClientResponse>;
+}

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

@@ -1,5 +1,4 @@
 import ServiceClient from '../serviceClient';
-import { AlgodTokenHeader, CustomTokenHeader } from '../../client';
 import * as modelsv2 from './models/types';
 import AccountInformation from './accountInformation';
 import Block from './block';
@@ -19,8 +18,15 @@ import Supply from './supply';
 import Versions from './versions';
 import Genesis from './genesis';
 import Proof from './proof';
+import { BaseHTTPClient } from '../../baseHTTPClient';
+import { AlgodTokenHeader, CustomTokenHeader } from '../../urlTokenBaseHTTPClient';
 export default class AlgodClient extends ServiceClient {
-    constructor(token: string | AlgodTokenHeader | CustomTokenHeader, baseServer?: string, port?: string | number, headers?: {});
+    /**
+     * Create an AlgodClient from
+     * * either a token, baseServer, port, and optional headers
+     * * or a base client server for interoperability with external dApp wallets
+     */
+    constructor(tokenOrBaseClient: string | AlgodTokenHeader | CustomTokenHeader | BaseHTTPClient, baseServer?: string, port?: string | number, headers?: Record<string, string>);
     healthCheck(): HealthCheck;
     versionsCheck(): Versions;
     sendRawTransaction(stxOrStxs: Uint8Array | Uint8Array[]): SendRawTransaction;

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

@@ -1,5 +1,4 @@
 import ServiceClient from '../serviceClient';
-import { CustomTokenHeader, IndexerTokenHeader } from '../../client';
 import MakeHealthCheck from './makeHealthCheck';
 import LookupAssetBalances from './lookupAssetBalances';
 import LookupAssetTransactions from './lookupAssetTransactions';
@@ -9,12 +8,20 @@ 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';
 import SearchForApplications from './searchForApplications';
+import { BaseHTTPClient } from '../../baseHTTPClient';
+import { CustomTokenHeader, IndexerTokenHeader } from '../../urlTokenBaseHTTPClient';
 export default class IndexerClient extends ServiceClient {
-    constructor(token: string | IndexerTokenHeader | CustomTokenHeader, baseServer?: string, port?: string | number, headers?: {});
+    /**
+     * Create an IndexerClient from
+     * * either a token, baseServer, port, and optional headers
+     * * or a base client server for interoperability with external dApp wallets
+     */
+    constructor(tokenOrBaseClient: string | IndexerTokenHeader | CustomTokenHeader | BaseHTTPClient, baseServer?: string, port?: string | number, headers?: Record<string, string>);
     /**
      * Returns the health object for the service.
      */
@@ -59,6 +66,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/client/v2/serviceClient.d.ts

@@ -1,5 +1,7 @@
-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
@@ -7,7 +9,7 @@ export declare type TokenHeaderIdentifier = 'X-Indexer-API-Token' | 'X-KMD-API-T
 export default abstract class ServiceClient {
     c: HTTPClient;
     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/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/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,16 +66,21 @@ 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 { isValidAddress, encodeAddress, decodeAddress, } from './encoding/address';
+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';
-export { secretKeyToMnemonic, mnemonicToSecretKey } from './mnemonic/mnemonic';
 export * as modelsv2 from './client/v2/algod/models/types';
-export { mnemonicToMasterDerivationKey, masterDerivationKeyToMnemonic, } from './mnemonic/mnemonic';
+export { mnemonicToMasterDerivationKey, masterDerivationKeyToMnemonic, secretKeyToMnemonic, mnemonicToSecretKey, seedFromMnemonic, mnemonicFromSeed, } from './mnemonic/mnemonic';
 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 {};