algosdk 1.18.1 → 1.20.0-beta.1

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

@@ -6,22 +6,24 @@ import AccountApplicationInformation from './accountApplicationInformation';
 import Block from './block';
 import Compile from './compile';
 import Dryrun from './dryrun';
+import Genesis from './genesis';
 import GetAssetByID from './getAssetByID';
 import GetApplicationByID from './getApplicationByID';
 import HealthCheck from './healthCheck';
 import PendingTransactionInformation from './pendingTransactionInformation';
 import PendingTransactions from './pendingTransactions';
 import PendingTransactionsByAddress from './pendingTransactionsByAddress';
+import GetTransactionProof from './getTransactionProof';
 import SendRawTransaction from './sendRawTransaction';
 import Status from './status';
 import StatusAfterBlock from './statusAfterBlock';
 import SuggestedParams from './suggestedParams';
 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';
+import LightBlockHeaderProof from './lightBlockHeaderProof';
+import StateProof from './stateproof';
 /**
  * Algod client connects an application to the Algorand blockchain. The algod client requires a valid algod REST endpoint IP address and algod token from an Algorand node that is connected to the network you plan to interact with.
  *
@@ -368,7 +370,7 @@ export default class AlgodClient extends ServiceClient {
      * ```typescript
      * const round = 18038133;
      * const txId = "MEUOC4RQJB23CQZRFRKYEI6WBO73VTTPST5A7B3S5OKBUY6LFUDA";
-     * const proof = await algodClient.getProof(round, txId).do();
+     * const proof = await algodClient.getTransactionProof(round, txId).do();
      * ```
      *
      * [Response data schema details](https://developer.algorand.org/docs/rest-apis/algod/v2/#get-v2blocksroundtransactionstxidproof)
@@ -376,5 +378,31 @@ export default class AlgodClient extends ServiceClient {
      * @param txID - The transaction ID for which to generate a proof.
      * @category GET
      */
-    getProof(round: number, txID: string): Proof;
+    getTransactionProof(round: number, txID: string): GetTransactionProof;
+    /**
+     * Gets a proof for a given light block header inside a state proof commitment.
+     *
+     * #### Example
+     * ```typescript
+     * const round = 11111111;
+     * const lightBlockHeaderProof = await algodClient.getLightBlockHeaderProof(round).do();
+     * ```
+     *
+     * [Response data schema details](https://developer.algorand.org/docs/rest-apis/algod/v2#get-v2blocksroundlightheaderproof)
+     * @param round
+     */
+    getLightBlockHeaderProof(round: number): LightBlockHeaderProof;
+    /**
+     * Gets a state proof that covers a given round.
+     *
+     * #### Example
+     * ```typescript
+     * const round = 11111111;
+     * const stateProof = await algodClient.getStateProof(round).do();
+     * ```
+     *
+     * [Response data schema details](https://developer.algorand.org/docs/rest-apis/algod/v2#get-v2stateproofsround)
+     * @param round
+     */
+    getStateProof(round: number): StateProof;
 }

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

@@ -12,6 +12,7 @@ export default class Compile extends JSONRequest {
     private source;
     constructor(c: HTTPClient, source: string | Uint8Array);
     path(): string;
+    sourcemap(map?: boolean): this;
     /**
      * Executes compile
      * @param headers - A headers object

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

@@ -0,0 +1,27 @@
+import JSONRequest from '../jsonrequest';
+import HTTPClient from '../../client';
+import IntDecoding from '../../../types/intDecoding';
+export default class GetTransactionProof extends JSONRequest {
+    private round;
+    private txID;
+    constructor(c: HTTPClient, intDecoding: IntDecoding, round: number, txID: string);
+    path(): string;
+    /**
+     * Exclude assets and application data from results
+     * The type of hash function used to create the proof, must be one of: "sha512_256", "sha256"
+     *
+     * #### Example
+     * ```typescript
+     * const hashType = "sha256";
+     * const round = 123456;
+     * const txId = "abc123;
+     * const txProof = await algodClient.getTransactionProof(round, txId)
+     *        .hashType(hashType)
+     *        .do();
+     * ```
+     *
+     * @param hashType
+     * @category query
+     */
+    hashType(hashType: string): this;
+}

package/dist/types/src/client/v2/algod/{proof.d.ts → lightBlockHeaderProof.d.ts}

@@ -1,9 +1,8 @@
 import JSONRequest from '../jsonrequest';
 import HTTPClient from '../../client';
 import IntDecoding from '../../../types/intDecoding';
-export default class Proof extends JSONRequest {
+export default class LightBlockHeaderProof extends JSONRequest {
     private round;
-    private txID;
-    constructor(c: HTTPClient, intDecoding: IntDecoding, round: number, txID: string);
+    constructor(c: HTTPClient, intDecoding: IntDecoding, round: number);
     path(): string;
 }

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

@@ -970,6 +970,32 @@ export declare class EvalDeltaKeyValue extends BaseModel {
      */
     constructor(key: string, value: EvalDelta);
 }
+/**
+ * Proof of membership and position of a light block header.
+ */
+export declare class LightBlockHeaderProof extends BaseModel {
+    /**
+     * The index of the light block header in the vector commitment tree
+     */
+    index: number | bigint;
+    /**
+     * The encoded proof.
+     */
+    proof: Uint8Array;
+    /**
+     * Represents the depth of the tree that is being proven, i.e. the number of edges
+     * from a leaf to the root.
+     */
+    treedepth: number | bigint;
+    /**
+     * Creates a new `LightBlockHeaderProof` object.
+     * @param index - The index of the light block header in the vector commitment tree
+     * @param proof - The encoded proof.
+     * @param treedepth - Represents the depth of the tree that is being proven, i.e. the number of edges
+     * from a leaf to the root.
+     */
+    constructor(index: number | bigint, proof: string | Uint8Array, treedepth: number | bigint);
+}
 /**
  *
  */
@@ -1223,49 +1249,66 @@ export declare class PostTransactionsResponse extends BaseModel {
     constructor(txid: string);
 }
 /**
- * Proof of transaction in a block.
+ * Represents a state proof and its corresponding message
  */
-export declare class ProofResponse extends BaseModel {
+export declare class StateProof extends BaseModel {
     /**
-     * Index of the transaction in the block's payset.
+     * Represents the message that the state proofs are attesting to.
      */
-    idx: number | bigint;
+    message: StateProofMessage;
     /**
-     * Merkle proof of transaction membership.
+     * The encoded StateProof for the message.
      */
-    proof: Uint8Array;
+    stateproof: Uint8Array;
     /**
-     * Hash of SignedTxnInBlock for verifying proof.
+     * Creates a new `StateProof` object.
+     * @param message - Represents the message that the state proofs are attesting to.
+     * @param stateproof - The encoded StateProof for the message.
      */
-    stibhash: Uint8Array;
+    constructor(message: StateProofMessage, stateproof: string | Uint8Array);
+}
+/**
+ * Represents the message that the state proofs are attesting to.
+ */
+export declare class StateProofMessage extends BaseModel {
     /**
-     * Represents the depth of the tree that is being proven, i.e. the number of edges
-     * from a leaf to the root.
+     * The vector commitment root on all light block headers within a state proof
+     * interval.
      */
-    treedepth: number | bigint;
+    blockheaderscommitment: Uint8Array;
     /**
-     * The type of hash function used to create the proof, must be one of:
-     * * sha512_256
-     * * sha256
+     * The first round the message attests to.
      */
-    hashtype?: string;
+    firstattestedround: number | bigint;
     /**
-     * Creates a new `ProofResponse` object.
-     * @param idx - Index of the transaction in the block's payset.
-     * @param proof - Merkle proof of transaction membership.
-     * @param stibhash - Hash of SignedTxnInBlock for verifying proof.
-     * @param treedepth - Represents the depth of the tree that is being proven, i.e. the number of edges
-     * from a leaf to the root.
-     * @param hashtype - The type of hash function used to create the proof, must be one of:
-     * * sha512_256
-     * * sha256
+     * The last round the message attests to.
      */
-    constructor({ idx, proof, stibhash, treedepth, hashtype, }: {
-        idx: number | bigint;
-        proof: string | Uint8Array;
-        stibhash: string | Uint8Array;
-        treedepth: number | bigint;
-        hashtype?: string;
+    lastattestedround: number | bigint;
+    /**
+     * An integer value representing the natural log of the proven weight with 16 bits
+     * of precision. This value would be used to verify the next state proof.
+     */
+    lnprovenweight: number | bigint;
+    /**
+     * The vector commitment root of the top N accounts to sign the next StateProof.
+     */
+    voterscommitment: Uint8Array;
+    /**
+     * Creates a new `StateProofMessage` object.
+     * @param blockheaderscommitment - The vector commitment root on all light block headers within a state proof
+     * interval.
+     * @param firstattestedround - The first round the message attests to.
+     * @param lastattestedround - The last round the message attests to.
+     * @param lnprovenweight - An integer value representing the natural log of the proven weight with 16 bits
+     * of precision. This value would be used to verify the next state proof.
+     * @param voterscommitment - The vector commitment root of the top N accounts to sign the next StateProof.
+     */
+    constructor({ blockheaderscommitment, firstattestedround, lastattestedround, lnprovenweight, voterscommitment, }: {
+        blockheaderscommitment: string | Uint8Array;
+        firstattestedround: number | bigint;
+        lastattestedround: number | bigint;
+        lnprovenweight: number | bigint;
+        voterscommitment: string | Uint8Array;
     });
 }
 /**
@@ -1389,6 +1432,52 @@ export declare class TransactionParametersResponse extends BaseModel {
         minFee: number | bigint;
     });
 }
+/**
+ * Proof of transaction in a block.
+ */
+export declare class TransactionProofResponse extends BaseModel {
+    /**
+     * Index of the transaction in the block's payset.
+     */
+    idx: number | bigint;
+    /**
+     * Proof of transaction membership.
+     */
+    proof: Uint8Array;
+    /**
+     * Hash of SignedTxnInBlock for verifying proof.
+     */
+    stibhash: Uint8Array;
+    /**
+     * Represents the depth of the tree that is being proven, i.e. the number of edges
+     * from a leaf to the root.
+     */
+    treedepth: number | bigint;
+    /**
+     * The type of hash function used to create the proof, must be one of:
+     * * sha512_256
+     * * sha256
+     */
+    hashtype?: string;
+    /**
+     * Creates a new `TransactionProofResponse` object.
+     * @param idx - Index of the transaction in the block's payset.
+     * @param proof - Proof of transaction membership.
+     * @param stibhash - Hash of SignedTxnInBlock for verifying proof.
+     * @param treedepth - Represents the depth of the tree that is being proven, i.e. the number of edges
+     * from a leaf to the root.
+     * @param hashtype - The type of hash function used to create the proof, must be one of:
+     * * sha512_256
+     * * sha256
+     */
+    constructor({ idx, proof, stibhash, treedepth, hashtype, }: {
+        idx: number | bigint;
+        proof: string | Uint8Array;
+        stibhash: string | Uint8Array;
+        treedepth: number | bigint;
+        hashtype?: string;
+    });
+}
 /**
  * algod version information.
  */

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

@@ -0,0 +1,8 @@
+import JSONRequest from '../jsonrequest';
+import HTTPClient from '../../client';
+import IntDecoding from '../../../types/intDecoding';
+export default class StateProof extends JSONRequest {
+    private round;
+    constructor(c: HTTPClient, intDecoding: IntDecoding, round: number);
+    path(): string;
+}

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

@@ -55,7 +55,7 @@ export default class LookupAccountTransactions extends JSONRequest {
      *        .do();
      * ```
      *
-     * @param type - one of `pay`, `keyreg`, `acfg`, `axfer`, `afrz`, `appl`
+     * @param type - one of `pay`, `keyreg`, `acfg`, `axfer`, `afrz`, `appl`, `stpf`
      * @category query
      */
     txType(type: string): this;

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

@@ -42,7 +42,7 @@ export default class SearchForTransactions extends JSONRequest {
      *        .do();
      * ```
      *
-     * @param type - one of `pay`, `keyreg`, `acfg`, `axfer`, `afrz`, `appl`
+     * @param type - one of `pay`, `keyreg`, `acfg`, `axfer`, `afrz`, `appl`, `stpf`
      * @category query
      */
     txType(type: string): this;

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

@@ -1,9 +1,16 @@
 /**
  * Utilities for working with program bytes.
  */
+/** @deprecated for langspec.json is deprecated aross all SDKs */
 export declare function parseUvarint(array: Uint8Array): [numberFound: number, size: number];
 /** readProgram validates program for length and running cost,
  * and additionally provides the found int variables and byte blocks
+ *
+ * @deprecated Validation relies on metadata (`langspec.json`) that
+ * does not accurately represent opcode behavior across program versions.
+ * The behavior of `readProgram` relies on `langspec.json`.
+ * Thus, this method is being deprecated.
+ *
  * @param program - Program to check
  * @param args - Program arguments as array of Uint8Array arrays
  * @throws
@@ -12,15 +19,27 @@ export declare function parseUvarint(array: Uint8Array): [numberFound: number, s
 export declare function readProgram(program: Uint8Array, args?: Uint8Array[]): [ints: number[], byteArrays: Uint8Array[], valid: boolean];
 /**
  * checkProgram validates program for length and running cost
+ *
+ * @deprecated Validation relies on metadata (`langspec.json`) that
+ * does not accurately represent opcode behavior across program versions.
+ * The behavior of `checkProgram` relies on `langspec.json`.
+ * Thus, this method is being deprecated.
+ *
  * @param program - Program to check
  * @param args - Program arguments as array of Uint8Array arrays
  * @throws
  * @returns true if success
  */
 export declare function checkProgram(program: Uint8Array, args?: Uint8Array[]): boolean;
+/** @deprecated for langspec.json is deprecated aross all SDKs */
 export declare function checkIntConstBlock(program: Uint8Array, pc: number): number;
+/** @deprecated for langspec.json is deprecated aross all SDKs */
 export declare function checkByteConstBlock(program: Uint8Array, pc: number): number;
+/** @deprecated for langspec.json is deprecated aross all SDKs */
 export declare function checkPushIntOp(program: Uint8Array, pc: number): number;
+/** @deprecated for langspec.json is deprecated aross all SDKs */
 export declare function checkPushByteOp(program: Uint8Array, pc: number): number;
+/** @deprecated for langspec.json is deprecated aross all SDKs */
 export declare const langspecEvalMaxVersion: number;
+/** @deprecated for langspec.json is deprecated aross all SDKs */
 export declare const langspecLogicSigVersion: number;

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

@@ -0,0 +1,20 @@
+export declare class SourceMap {
+    version: number;
+    sources: string[];
+    names: string[];
+    mappings: string;
+    pcToLine: {
+        [key: number]: number;
+    };
+    lineToPc: {
+        [key: number]: number[];
+    };
+    constructor({ version, sources, names, mappings, }: {
+        version: number;
+        sources: string[];
+        names: string[];
+        mappings: string;
+    });
+    getLineForPc(pc: number): number | undefined;
+    getPcsForLine(line: number): number[] | undefined;
+}

package/dist/types/src/logicTemplates/dynamicfee.d.ts

@@ -15,7 +15,7 @@ export class DynamicFee {
      * @param {string} lease: leave undefined to generate a random lease, or supply a lease as base64
      * @returns {DynamicFee}
      */
-    constructor(receiver: string, amount: any, firstValid: any, lastValid: any, closeRemainder: string, lease: string);
+    constructor(receiver: string, amount: int, firstValid: int, lastValid: int, closeRemainder: string, lease: string);
     programBytes: any;
     address: string;
     /**
@@ -44,7 +44,7 @@ export class DynamicFee {
  *
  * @throws on invalid lsig
  */
-export function getDynamicFeeTransactions(txn: any, lsig: any, privateKey: Uint8Array, fee: any): Uint8Array;
+export function getDynamicFeeTransactions(txn: dict, lsig: LogicSig, privateKey: Uint8Array, fee: int): Uint8Array;
 /**
  * signDynamicFee returns the main transaction and signed logic needed to complete the transfer.
  * These should be sent to the fee payer, who can use GetDynamicFeeTransactions

package/dist/types/src/logicTemplates/htlc.d.ts

@@ -22,7 +22,7 @@ export class HTLC {
      * @param {int} maxFee: the maximum fee that can be paid to the network by the account
      * @returns {HTLC}
      */
-    constructor(owner: string, receiver: string, hashFunction: string, hashImage: string, expiryRound: any, maxFee: any);
+    constructor(owner: string, receiver: string, hashFunction: string, hashImage: string, expiryRound: int, maxFee: int);
     programBytes: any;
     address: string;
     /**

package/dist/types/src/logicTemplates/limitorder.d.ts

@@ -32,11 +32,11 @@ export class LimitOrder {
      * @param {int} maxFee: maximum fee used by the limit order transaction
      * @returns {LimitOrder}
      */
-    constructor(owner: string, assetid: any, ratn: any, ratd: any, expiryRound: any, minTrade: any, maxFee: any);
+    constructor(owner: string, assetid: int, ratn: int, ratd: int, expiryRound: int, minTrade: int, maxFee: int);
     programBytes: any;
     address: string;
     owner: string;
-    assetid: any;
+    assetid: int;
     /**
      * returns the program bytes
      * @returns {Uint8Array}
@@ -67,4 +67,4 @@ export class LimitOrder {
  * these transactions will be rejected if they do not meet the restrictions set by the contract
  * @throws error if arguments fail contract validation
  */
-export function getSwapAssetsTransaction(contract: Uint8Array, assetAmount: any, microAlgoAmount: any, secretKey: Uint8Array, fee: any, firstRound: any, lastRound: any, genesisHash: string): Uint8Array;
+export function getSwapAssetsTransaction(contract: Uint8Array, assetAmount: int, microAlgoAmount: int, secretKey: Uint8Array, fee: int, firstRound: int, lastRound: int, genesisHash: string): Uint8Array;

package/dist/types/src/logicTemplates/periodicpayment.d.ts

@@ -22,13 +22,13 @@ export class PeriodicPayment {
      * @param {string} lease: b64 representation of lease to use, or leave undefined to generate one
      * @returns {PeriodicPayment}
      */
-    constructor(receiver: string, amount: any, withdrawalWindow: any, period: any, expiryRound: any, maxFee: any, lease: string);
+    constructor(receiver: string, amount: int, withdrawalWindow: int, period: int, expiryRound: int, maxFee: int, lease: string);
     receiver: string;
-    amount: any;
-    withdrawalWindow: any;
-    period: any;
-    expiryRound: any;
-    maxFee: any;
+    amount: int;
+    withdrawalWindow: int;
+    period: int;
+    expiryRound: int;
+    maxFee: int;
     lease: string;
     programBytes: Uint8Array;
     address: string;
@@ -55,4 +55,4 @@ export class PeriodicPayment {
  * @returns {Object} Object containing txID and blob representing signed transaction
  * @throws error on failure
  */
-export function getPeriodicPaymentWithdrawalTransaction(contract: Uint8Array, fee: any, firstValid: any, genesisHash: string): any;
+export function getPeriodicPaymentWithdrawalTransaction(contract: Uint8Array, fee: int, firstValid: int, genesisHash: string): any;

package/dist/types/src/logicTemplates/split.d.ts

@@ -27,7 +27,7 @@ export class Split {
      * @param {int} maxFee: half of the maximum fee used by each split forwarding group transaction
      * @returns {Split}
      */
-    constructor(owner: string, receiverOne: string, receiverTwo: string, rat1: any, rat2: any, expiryRound: any, minPay: any, maxFee: any);
+    constructor(owner: string, receiverOne: string, receiverTwo: string, rat1: int, rat2: int, expiryRound: int, minPay: int, maxFee: int);
     programBytes: any;
     address: string;
     /**
@@ -54,4 +54,4 @@ export class Split {
  * @param {string} genesisHash: the b64-encoded genesis hash indicating the network for this transaction
  * @returns {Uint8Array}
  */
-export function getSplitFundsTransaction(contract: Uint8Array, amount: any, firstRound: any, lastRound: any, fee: any, genesisHash: string): Uint8Array;
+export function getSplitFundsTransaction(contract: Uint8Array, amount: int, firstRound: int, lastRound: int, fee: int, genesisHash: string): Uint8Array;

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

@@ -8,6 +8,12 @@ interface LogicSigStorageStructure {
     sig?: Uint8Array;
     msig?: EncodedMultisig;
 }
+/** sanityCheckProgram performs heuristic program validation:
+ * check if passed in bytes are Algorand address or is B64 encoded, rather than Teal bytes
+ *
+ * @param program - Program bytes to check
+ */
+export declare function sanityCheckProgram(program: Uint8Array): void;
 /**
  LogicSig implementation
  */
@@ -169,12 +175,12 @@ export declare function signLogicSigTransaction(txn: txnBuilder.TransactionLike,
  */
 export declare function logicSigFromByte(encoded: Uint8Array): LogicSig;
 /**
- * tealSign creates a signature compatible with ed25519verify opcode from contract address
+ * tealSign creates a signature compatible with ed25519verify opcode from program hash
  * @param sk - uint8array with secret key
  * @param data - buffer with data to sign
- * @param contractAddress - string representation of teal contract address (program hash)
+ * @param programHash - string representation of teal program hash (= contract address for LogicSigs)
  */
-export declare function tealSign(sk: Uint8Array, data: Uint8Array | Buffer, contractAddress: string): Uint8Array;
+export declare function tealSign(sk: Uint8Array, data: Uint8Array | Buffer, programHash: string): Uint8Array;
 /**
  * tealSignFromProgram creates a signature compatible with ed25519verify opcode from raw program bytes
  * @param sk - uint8array with secret key

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

@@ -77,7 +77,8 @@ 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 { signMultisigTransaction, mergeMultisigTransactions, appendSignMultisigTransaction, createMultisigTransaction, appendSignRawMultisigSignature, verifyMultisig, multisigAddress, } from './multisig';
+export { SourceMap } from './logic/sourcemap';
 export declare const LogicTemplates: any;
 export * from './dryrun';
 export * from './makeTxn';

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

@@ -12,9 +12,19 @@ export declare const MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG = "Cannot merge txs
 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.";
 export declare const MULTISIG_USE_PARTIAL_SIGN_ERROR_MSG = "Cannot sign a multisig transaction using `signTxn`. Use `partialSignTxn` instead.";
+export declare const MULTISIG_SIGNATURE_LENGTH_ERROR_MSG = "Cannot add multisig signature. Signature is not of the correct length.";
 interface MultisigMetadataWithPks extends Omit<MultisigMetadata, 'addrs'> {
     pks: Uint8Array[];
 }
+/**
+ * createRawMultisigTransaction creates a raw, unsigned multisig transaction blob.
+ * @param txn - the actual transaction.
+ * @param version - multisig version
+ * @param threshold - multisig threshold
+ * @param pks - ordered list of public keys in this multisig
+ * @returns encoded multisig blob
+ */
+export declare function createMultisigTransaction(txn: txnBuilder.Transaction, { version, threshold, addrs }: MultisigMetadata): Uint8Array;
 /**
  * MultisigTransaction is a Transaction that also supports creating partially-signed multisig transactions.
  */
@@ -41,6 +51,15 @@ export declare class MultisigTransaction extends txnBuilder.Transaction {
      * @returns an encoded, partially signed multisig transaction.
      */
     partialSignTxn({ version, threshold, pks }: MultisigMetadataWithPks, sk: Uint8Array): Uint8Array;
+    /**
+     * partialSignWithMultisigSignature partially signs this transaction with an external raw multisig signature and returns
+     * a partially-signed multisig transaction, encoded with msgpack as a typed array.
+     * @param metadata - multisig metadata
+     * @param signerAddr - address of the signer
+     * @param signature - raw multisig signature
+     * @returns an encoded, partially signed multisig transaction.
+     */
+    partialSignWithMultisigSignature(metadata: MultisigMetadataWithPks, signerAddr: string, signature: Uint8Array): Uint8Array;
     static from_obj_for_encoding(txnForEnc: EncodedTransaction): MultisigTransaction;
 }
 /**
@@ -53,7 +72,7 @@ export declare function verifyMultisig(toBeVerified: Uint8Array, msig: EncodedMu
 /**
  * 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.
+ * multisig txn can accumulate additional signatures through mergeMultisigTransactions or appendSignMultisigTransaction.
  * @param txn - object with either payment or key registration fields
  * @param version - multisig version
  * @param threshold - multisig threshold
@@ -81,9 +100,24 @@ export declare function appendSignMultisigTransaction(multisigTxnBlob: Uint8Arra
     txID: string;
     blob: Uint8Array;
 };
+/**
+ * appendMultisigTransactionSignature takes a multisig transaction blob, and appends a given raw signature to it.
+ * This makes it possible to compile a multisig signature using only raw signatures from external methods.
+ * @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 signerAddr - address of the signer
+ * @param signature - raw multisig signature
+ * @returns object containing txID, and blob representing encoded multisig txn
+ */
+export declare function appendSignRawMultisigSignature(multisigTxnBlob: Uint8Array, { version, threshold, addrs }: MultisigMetadata, signerAddr: string, signature: Uint8Array): {
+    txID: string;
+    blob: Uint8Array;
+};
 /**
  * multisigAddress takes multisig metadata (preimage) and returns the corresponding human readable Algorand address.
- * @param version - mutlisig version
+ * @param version - multisig version
  * @param threshold - multisig threshold
  * @param addrs - list of Algorand addresses
  */

package/dist/types/src/nacl/naclWrappers.d.ts

@@ -4,6 +4,7 @@ export declare function genericHash(arr: sha512.Message): number[];
 export declare function randomBytes(length: number): Uint8Array;
 export declare function keyPairFromSeed(seed: Uint8Array): nacl.SignKeyPair;
 export declare function keyPair(): nacl.SignKeyPair;
+export declare function isValidSignatureLength(len: number): boolean;
 export declare function keyPairFromSecretKey(sk: Uint8Array): nacl.SignKeyPair;
 export declare function sign(msg: Uint8Array, secretKey: Uint8Array): Uint8Array;
 export declare function bytesEqual(a: Uint8Array, b: Uint8Array): boolean;

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

@@ -58,6 +58,9 @@ interface TransactionStorageStructure extends Omit<TransactionParams, 'from' | '
     nonParticipation?: boolean;
     group?: Buffer;
     extraPages?: number;
+    stateProofType?: number | bigint;
+    stateProof?: Uint8Array;
+    stateProofMessage?: Uint8Array;
 }
 /**
  * Transaction enables construction of Algorand transactions
@@ -115,6 +118,9 @@ export declare class Transaction implements TransactionStorageStructure {
     nonParticipation?: boolean;
     group?: Buffer;
     extraPages?: number;
+    stateProofType?: number | bigint;
+    stateProof?: Uint8Array;
+    stateProofMessage?: Uint8Array;
     constructor({ ...transaction }: AnyTransaction);
     get_obj_for_encoding(): EncodedTransaction;
     static from_obj_for_encoding(txnForEnc: EncodedTransaction): Transaction;
@@ -123,6 +129,7 @@ export declare class Transaction implements TransactionStorageStructure {
     toByte(): Uint8Array;
     rawSignTxn(sk: Uint8Array): Buffer;
     signTxn(sk: Uint8Array): Uint8Array;
+    attachSignature(signerAddr: string, signature: Uint8Array): Uint8Array;
     rawTxID(): Buffer;
     txID(): string;
     addLease(lease: Uint8Array, feePerByte?: number): void;