algosdk 1.10.1 → 1.13.0-beta.1

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

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import * as txnBuilder from './transaction';
-import { EncodedLogicSig, EncodedMultisig } from './types/transactions/encoded';
+import { EncodedLogicSig, EncodedLogicSigAccount, EncodedMultisig } from './types/transactions/encoded';
 import { MultisigMetadata } from './types/multisig';
 interface LogicSigStorageStructure {
     logic: Uint8Array;
@@ -17,7 +17,7 @@ export declare class LogicSig implements LogicSigStorageStructure {
     args: Uint8Array[];
     sig?: Uint8Array;
     msig?: EncodedMultisig;
-    constructor(program: Uint8Array, bufferOrUint8ArrArgs: Array<Uint8Array | Buffer> | undefined);
+    constructor(program: Uint8Array, programArgs?: Array<Uint8Array | Buffer> | null);
     get_obj_for_encoding(): EncodedLogicSig;
     static from_obj_for_encoding(encoded: EncodedLogicSig): LogicSig;
     /**
@@ -35,7 +35,7 @@ export declare class LogicSig implements LogicSigStorageStructure {
      * @param secretKey - Secret key to sign with
      * @param msig - Multisig account as \{version, threshold, addrs\}
      */
-    sign(secretKey: Uint8Array, msig: MultisigMetadata): void;
+    sign(secretKey: Uint8Array, msig?: MultisigMetadata): void;
     /**
      * Appends a signature to multi signature
      * @param secretKey - Secret key to sign with
@@ -46,34 +46,120 @@ export declare class LogicSig implements LogicSigStorageStructure {
     toByte(): Uint8Array;
     static fromByte(encoded: ArrayLike<any>): LogicSig;
 }
+/**
+ * Represents an account that can sign with a LogicSig program.
+ */
+export declare class LogicSigAccount {
+    lsig: LogicSig;
+    sigkey?: Uint8Array;
+    /**
+     * Create a new LogicSigAccount. By default this will create an escrow
+     * LogicSig account. Call `sign` or `signMultisig` on the newly created
+     * LogicSigAccount to make it a delegated account.
+     *
+     * @param program - The compiled TEAL program which contains the logic for
+     *   this LogicSig.
+     * @param args - An optional array of arguments for the program.
+     */
+    constructor(program: Uint8Array, args?: Array<Uint8Array | Buffer> | null);
+    get_obj_for_encoding(): EncodedLogicSigAccount;
+    static from_obj_for_encoding(encoded: EncodedLogicSigAccount): LogicSigAccount;
+    /**
+     * Encode this object into msgpack.
+     */
+    toByte(): Uint8Array;
+    /**
+     * Decode a msgpack object into a LogicSigAccount.
+     * @param encoded - The encoded LogicSigAccount.
+     */
+    static fromByte(encoded: ArrayLike<any>): LogicSigAccount;
+    /**
+     * Check if this LogicSigAccount has been delegated to another account with a
+     * signature.
+     *
+     * Note this function only checks for the presence of a delegation signature.
+     * To verify the delegation signature, use `verify`.
+     */
+    isDelegated(): boolean;
+    /**
+     * Verifies this LogicSig's program and signatures.
+     * @returns true if and only if the LogicSig program and signatures are valid.
+     */
+    verify(): boolean;
+    /**
+     * Get the address of this LogicSigAccount.
+     *
+     * If the LogicSig is delegated to another account, this will return the
+     * address of that account.
+     *
+     * If the LogicSig is not delegated to another account, this will return an
+     *  escrow address that is the hash of the LogicSig's program code.
+     */
+    address(): string;
+    /**
+     * Turns this LogicSigAccount into a delegated LogicSig. This type of LogicSig
+     * has the authority to sign transactions on behalf of another account, called
+     * the delegating account. Use this function if the delegating account is a
+     * multisig account.
+     *
+     * @param msig - The multisig delegating account
+     * @param secretKey - The secret key of one of the members of the delegating
+     *   multisig account. Use `appendToMultisig` to add additional signatures
+     *   from other members.
+     */
+    signMultisig(msig: MultisigMetadata, secretKey: Uint8Array): void;
+    /**
+     * Adds an additional signature from a member of the delegating multisig
+     * account.
+     *
+     * @param secretKey - The secret key of one of the members of the delegating
+     *   multisig account.
+     */
+    appendToMultisig(secretKey: Uint8Array): void;
+    /**
+     * Turns this LogicSigAccount into a delegated LogicSig. This type of LogicSig
+     * has the authority to sign transactions on behalf of another account, called
+     * the delegating account. If the delegating account is a multisig account,
+     * use `signMultisig` instead.
+     *
+     * @param secretKey - The secret key of the delegating account.
+     */
+    sign(secretKey: Uint8Array): void;
+}
 /**
  * makeLogicSig creates LogicSig object from program and arguments
  *
+ * @deprecated Use new LogicSigAccount(...) instead
+ *
  * @param program - Program to make LogicSig from
  * @param args - Arguments as array of Uint8Array
  * @returns LogicSig object
  */
 export declare function makeLogicSig(program: Uint8Array, args?: Uint8Array[]): LogicSig;
 /**
- * signLogicSigTransactionObject takes transaction.Transaction and a LogicSig object and returns a logicsig
- * transaction which is a blob representing a transaction and logicsig object.
- * @param txn - transaction.Transaction
- * @param lsig - logicsig object
+ * signLogicSigTransactionObject takes a transaction and a LogicSig object and
+ * returns a signed transaction.
+ *
+ * @param txn - The transaction to sign.
+ * @param lsigObject - The LogicSig object that will sign the transaction.
+ *
  * @returns Object containing txID and blob representing signed transaction.
  */
-export declare function signLogicSigTransactionObject(txn: txnBuilder.Transaction, lsig: LogicSig): {
+export declare function signLogicSigTransactionObject(txn: txnBuilder.Transaction, lsigObject: LogicSig | LogicSigAccount): {
     txID: string;
     blob: Uint8Array;
 };
 /**
- * signLogicSigTransaction takes a raw transaction and a LogicSig object and returns a logicsig
- * transaction which is a blob representing a transaction and logicsig object.
- * @param txn - containing constructor arguments for a transaction
- * @param lsig -  logicsig object
+ * signLogicSigTransaction takes a transaction and a LogicSig object and returns
+ * a signed transaction.
+ *
+ * @param txn - The transaction to sign.
+ * @param lsigObject - The LogicSig object that will sign the transaction.
+ *
  * @returns Object containing txID and blob representing signed transaction.
  * @throws error on failure
  */
-export declare function signLogicSigTransaction(txn: txnBuilder.TransactionLike, lsig: LogicSig): {
+export declare function signLogicSigTransaction(txn: txnBuilder.TransactionLike, lsigObject: LogicSig | LogicSigAccount): {
     txID: string;
     blob: Uint8Array;
 };
@@ -96,4 +182,4 @@ export declare function tealSign(sk: Uint8Array, data: Uint8Array | Buffer, cont
  * @param program - buffer with teal program
  */
 export declare function tealSignFromProgram(sk: Uint8Array, data: Uint8Array | Buffer, program: Uint8Array): Uint8Array;
-export default LogicSig;
+export {};

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,20 @@ 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 { 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 { makeLogicSig, signLogicSigTransaction, signLogicSigTransactionObject, logicSigFromByte, tealSign, tealSignFromProgram, } from './logicsig';
+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

@@ -7,6 +7,7 @@ import { EncodedMultisig } from './types/transactions/encoded';
  */
 export declare const MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG = "Not enough multisig transactions to merge. Need at least two";
 export declare const MULTISIG_MERGE_MISMATCH_ERROR_MSG = "Cannot merge txs. txIDs differ";
+export declare const MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG = "Cannot merge txs. Auth addrs differ";
 export declare const MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG = "Cannot merge txs. Multisig preimages differ";
 export declare const MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG = "Cannot merge txs. subsigs are mismatched.";
 export declare const MULTISIG_NO_MUTATE_ERROR_MSG = "Cannot mutate a multisig field as it would invalidate all existing signatures.";
@@ -49,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/types/transactions/encoded.d.ts

@@ -238,7 +238,13 @@ export interface EncodedTransaction {
     apep?: number;
 }
 export interface EncodedSubsig {
+    /**
+     *  The public key
+     */
     pk: Uint8Array;
+    /**
+     * The signature provided by the public key, if any
+     */
     s?: Uint8Array;
 }
 /**
@@ -261,6 +267,8 @@ export interface EncodedMultisig {
 }
 /**
  * An encoded multisig blob that contains the encoded multisig as well as a copy of the encoded transaction
+ *
+ * @deprecated Use EncodedSignedTransaction instead.
  */
 export interface EncodedMultisigBlob {
     /**
@@ -278,6 +286,10 @@ export interface EncodedLogicSig {
     sig?: Uint8Array;
     msig?: EncodedMultisig;
 }
+export interface EncodedLogicSigAccount {
+    lsig: EncodedLogicSig;
+    sigkey?: Uint8Array;
+}
 /**
  * A structure for an encoded signed transaction object
  */

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.10.1",
+  "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": "^91.0.0",
+    "chromedriver": "^95.0.0",
     "concurrently": "^6.2.0",
     "coveralls": "^3.1.0",
     "cucumber": "^5.1.0",