algosdk 2.1.0 → 2.3.0

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

@@ -426,15 +426,15 @@ export declare class ApplicationParams extends BaseModel {
      */
     extraProgramPages?: number | bigint;
     /**
-     * [\gs) global schema
+     * (gs) global state
      */
     globalState?: TealKeyValue[];
     /**
-     * [\gsch) global schema
+     * (gsch) global schema
      */
     globalStateSchema?: ApplicationStateSchema;
     /**
-     * [\lsch) local schema
+     * (lsch) local schema
      */
     localStateSchema?: ApplicationStateSchema;
     /**
@@ -444,9 +444,9 @@ export declare class ApplicationParams extends BaseModel {
      * @param creator - The address that created this application. This is the address where the
      * 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 - [\gsch) global schema
-     * @param localStateSchema - [\lsch) local schema
+     * @param globalState - (gs) global state
+     * @param globalStateSchema - (gsch) global schema
+     * @param localStateSchema - (lsch) local schema
      */
     constructor({ approvalProgram, clearStateProgram, creator, extraProgramPages, globalState, globalStateSchema, localStateSchema, }: {
         approvalProgram: string | Uint8Array;
@@ -1099,6 +1099,64 @@ export declare class EvalDeltaKeyValue extends BaseModel {
     });
     static from_obj_for_encoding(data: Record<string, any>): EvalDeltaKeyValue;
 }
+/**
+ * Response containing the timestamp offset in seconds
+ */
+export declare class GetBlockTimeStampOffsetResponse extends BaseModel {
+    /**
+     * Timestamp offset in seconds.
+     */
+    offset: number | bigint;
+    /**
+     * Creates a new `GetBlockTimeStampOffsetResponse` object.
+     * @param offset - Timestamp offset in seconds.
+     */
+    constructor({ offset }: {
+        offset: number | bigint;
+    });
+    static from_obj_for_encoding(data: Record<string, any>): GetBlockTimeStampOffsetResponse;
+}
+/**
+ * Response containing the ledger's minimum sync round
+ */
+export declare class GetSyncRoundResponse extends BaseModel {
+    /**
+     * The minimum sync round for the ledger.
+     */
+    round: number | bigint;
+    /**
+     * Creates a new `GetSyncRoundResponse` object.
+     * @param round - The minimum sync round for the ledger.
+     */
+    constructor({ round }: {
+        round: number | bigint;
+    });
+    static from_obj_for_encoding(data: Record<string, any>): GetSyncRoundResponse;
+}
+/**
+ * A single Delta containing the key, the previous value and the current value for
+ * a single round.
+ */
+export declare class KvDelta extends BaseModel {
+    /**
+     * The key, base64 encoded.
+     */
+    key?: Uint8Array;
+    /**
+     * The new value of the KV store entry, base64 encoded.
+     */
+    value?: Uint8Array;
+    /**
+     * Creates a new `KvDelta` object.
+     * @param key - The key, base64 encoded.
+     * @param value - The new value of the KV store entry, base64 encoded.
+     */
+    constructor({ key, value, }: {
+        key?: string | Uint8Array;
+        value?: string | Uint8Array;
+    });
+    static from_obj_for_encoding(data: Record<string, any>): KvDelta;
+}
 /**
  * Proof of membership and position of a light block header.
  */
@@ -1214,6 +1272,38 @@ export declare class NodeStatusResponse extends BaseModel {
      * The last catchpoint seen by the node
      */
     lastCatchpoint?: string;
+    /**
+     * Upgrade delay
+     */
+    upgradeDelay?: number | bigint;
+    /**
+     * Next protocol round
+     */
+    upgradeNextProtocolVoteBefore?: number | bigint;
+    /**
+     * No votes cast for consensus upgrade
+     */
+    upgradeNoVotes?: number | bigint;
+    /**
+     * This node's upgrade vote
+     */
+    upgradeNodeVote?: boolean;
+    /**
+     * Total voting rounds for current upgrade
+     */
+    upgradeVoteRounds?: number | bigint;
+    /**
+     * Total votes cast for consensus upgrade
+     */
+    upgradeVotes?: number | bigint;
+    /**
+     * Yes votes required for consensus upgrade
+     */
+    upgradeVotesRequired?: number | bigint;
+    /**
+     * Yes votes cast for consensus upgrade
+     */
+    upgradeYesVotes?: number | bigint;
     /**
      * Creates a new `NodeStatusResponse` object.
      * @param catchupTime - CatchupTime in nanoseconds
@@ -1242,8 +1332,16 @@ export declare class NodeStatusResponse extends BaseModel {
      * @param catchpointVerifiedKvs - The number of key-values (KVs) from the current catchpoint that have been
      * verified so far as part of the catchup
      * @param lastCatchpoint - The last catchpoint seen by the node
-     */
-    constructor({ catchupTime, lastRound, lastVersion, nextVersion, nextVersionRound, nextVersionSupported, stoppedAtUnsupportedRound, timeSinceLastRound, catchpoint, catchpointAcquiredBlocks, catchpointProcessedAccounts, catchpointProcessedKvs, catchpointTotalAccounts, catchpointTotalBlocks, catchpointTotalKvs, catchpointVerifiedAccounts, catchpointVerifiedKvs, lastCatchpoint, }: {
+     * @param upgradeDelay - Upgrade delay
+     * @param upgradeNextProtocolVoteBefore - Next protocol round
+     * @param upgradeNoVotes - No votes cast for consensus upgrade
+     * @param upgradeNodeVote - This node's upgrade vote
+     * @param upgradeVoteRounds - Total voting rounds for current upgrade
+     * @param upgradeVotes - Total votes cast for consensus upgrade
+     * @param upgradeVotesRequired - Yes votes required for consensus upgrade
+     * @param upgradeYesVotes - Yes votes cast for consensus upgrade
+     */
+    constructor({ catchupTime, lastRound, lastVersion, nextVersion, nextVersionRound, nextVersionSupported, stoppedAtUnsupportedRound, timeSinceLastRound, catchpoint, catchpointAcquiredBlocks, catchpointProcessedAccounts, catchpointProcessedKvs, catchpointTotalAccounts, catchpointTotalBlocks, catchpointTotalKvs, catchpointVerifiedAccounts, catchpointVerifiedKvs, lastCatchpoint, upgradeDelay, upgradeNextProtocolVoteBefore, upgradeNoVotes, upgradeNodeVote, upgradeVoteRounds, upgradeVotes, upgradeVotesRequired, upgradeYesVotes, }: {
         catchupTime: number | bigint;
         lastRound: number | bigint;
         lastVersion: string;
@@ -1262,6 +1360,14 @@ export declare class NodeStatusResponse extends BaseModel {
         catchpointVerifiedAccounts?: number | bigint;
         catchpointVerifiedKvs?: number | bigint;
         lastCatchpoint?: string;
+        upgradeDelay?: number | bigint;
+        upgradeNextProtocolVoteBefore?: number | bigint;
+        upgradeNoVotes?: number | bigint;
+        upgradeNodeVote?: boolean;
+        upgradeVoteRounds?: number | bigint;
+        upgradeVotes?: number | bigint;
+        upgradeVotesRequired?: number | bigint;
+        upgradeYesVotes?: number | bigint;
     });
     static from_obj_for_encoding(data: Record<string, any>): NodeStatusResponse;
 }
@@ -1306,7 +1412,7 @@ export declare class PendingTransactionResponse extends BaseModel {
      */
     confirmedRound?: number | bigint;
     /**
-     * (gd) Global state key/value changes for the application being executed by this
+     * Global state key/value changes for the application being executed by this
      * transaction.
      */
     globalStateDelta?: EvalDeltaKeyValue[];
@@ -1315,12 +1421,12 @@ export declare class PendingTransactionResponse extends BaseModel {
      */
     innerTxns?: PendingTransactionResponse[];
     /**
-     * (ld) Local state key/value changes for the application being executed by this
+     * 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 for the application being executed by this transaction.
      */
     logs?: Uint8Array[];
     /**
@@ -1344,12 +1450,12 @@ export declare class PendingTransactionResponse extends BaseModel {
      * @param closeRewards - Rewards in microalgos applied to the close remainder to account.
      * @param closingAmount - Closing amount for the transaction.
      * @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
+     * @param globalStateDelta - 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
+     * @param localStateDelta - 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 logs - 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.
      */
@@ -1413,6 +1519,210 @@ export declare class PostTransactionsResponse extends BaseModel {
     });
     static from_obj_for_encoding(data: Record<string, any>): PostTransactionsResponse;
 }
+/**
+ * Request type for simulation endpoint.
+ */
+export declare class SimulateRequest extends BaseModel {
+    /**
+     * The transaction groups to simulate.
+     */
+    txnGroups: SimulateRequestTransactionGroup[];
+    /**
+     * Allow transactions without signatures to be simulated as if they had correct
+     * signatures.
+     */
+    allowEmptySignatures?: boolean;
+    /**
+     * Lifts limits on log opcode usage during simulation.
+     */
+    allowMoreLogging?: boolean;
+    /**
+     * Creates a new `SimulateRequest` object.
+     * @param txnGroups - The transaction groups to simulate.
+     * @param allowEmptySignatures - Allow transactions without signatures to be simulated as if they had correct
+     * signatures.
+     * @param allowMoreLogging - Lifts limits on log opcode usage during simulation.
+     */
+    constructor({ txnGroups, allowEmptySignatures, allowMoreLogging, }: {
+        txnGroups: SimulateRequestTransactionGroup[];
+        allowEmptySignatures?: boolean;
+        allowMoreLogging?: boolean;
+    });
+    static from_obj_for_encoding(data: Record<string, any>): SimulateRequest;
+}
+/**
+ * A transaction group to simulate.
+ */
+export declare class SimulateRequestTransactionGroup extends BaseModel {
+    /**
+     * An atomic transaction group.
+     */
+    txns: EncodedSignedTransaction[];
+    /**
+     * Creates a new `SimulateRequestTransactionGroup` object.
+     * @param txns - An atomic transaction group.
+     */
+    constructor({ txns }: {
+        txns: EncodedSignedTransaction[];
+    });
+    static from_obj_for_encoding(data: Record<string, any>): SimulateRequestTransactionGroup;
+}
+/**
+ * Result of a transaction group simulation.
+ */
+export declare class SimulateResponse extends BaseModel {
+    /**
+     * The round immediately preceding this simulation. State changes through this
+     * round were used to run this simulation.
+     */
+    lastRound: number | bigint;
+    /**
+     * A result object for each transaction group that was simulated.
+     */
+    txnGroups: SimulateTransactionGroupResult[];
+    /**
+     * The version of this response object.
+     */
+    version: number | bigint;
+    /**
+     * The set of parameters and limits override during simulation. If this set of
+     * parameters is present, then evaluation parameters may differ from standard
+     * evaluation in certain ways.
+     */
+    evalOverrides?: SimulationEvalOverrides;
+    /**
+     * Creates a new `SimulateResponse` object.
+     * @param lastRound - The round immediately preceding this simulation. State changes through this
+     * round were used to run this simulation.
+     * @param txnGroups - A result object for each transaction group that was simulated.
+     * @param version - The version of this response object.
+     * @param evalOverrides - The set of parameters and limits override during simulation. If this set of
+     * parameters is present, then evaluation parameters may differ from standard
+     * evaluation in certain ways.
+     */
+    constructor({ lastRound, txnGroups, version, evalOverrides, }: {
+        lastRound: number | bigint;
+        txnGroups: SimulateTransactionGroupResult[];
+        version: number | bigint;
+        evalOverrides?: SimulationEvalOverrides;
+    });
+    static from_obj_for_encoding(data: Record<string, any>): SimulateResponse;
+}
+/**
+ * Simulation result for an atomic transaction group
+ */
+export declare class SimulateTransactionGroupResult extends BaseModel {
+    /**
+     * Simulation result for individual transactions
+     */
+    txnResults: SimulateTransactionResult[];
+    /**
+     * Total budget added during execution of app calls in the transaction group.
+     */
+    appBudgetAdded?: number | bigint;
+    /**
+     * Total budget consumed during execution of app calls in the transaction group.
+     */
+    appBudgetConsumed?: number | bigint;
+    /**
+     * If present, indicates which transaction in this group caused the failure. This
+     * array represents the path to the failing transaction. Indexes are zero based,
+     * the first element indicates the top-level transaction, and successive elements
+     * indicate deeper inner transactions.
+     */
+    failedAt?: (number | bigint)[];
+    /**
+     * If present, indicates that the transaction group failed and specifies why that
+     * happened
+     */
+    failureMessage?: string;
+    /**
+     * Creates a new `SimulateTransactionGroupResult` object.
+     * @param txnResults - Simulation result for individual transactions
+     * @param appBudgetAdded - Total budget added during execution of app calls in the transaction group.
+     * @param appBudgetConsumed - Total budget consumed during execution of app calls in the transaction group.
+     * @param failedAt - If present, indicates which transaction in this group caused the failure. This
+     * array represents the path to the failing transaction. Indexes are zero based,
+     * the first element indicates the top-level transaction, and successive elements
+     * indicate deeper inner transactions.
+     * @param failureMessage - If present, indicates that the transaction group failed and specifies why that
+     * happened
+     */
+    constructor({ txnResults, appBudgetAdded, appBudgetConsumed, failedAt, failureMessage, }: {
+        txnResults: SimulateTransactionResult[];
+        appBudgetAdded?: number | bigint;
+        appBudgetConsumed?: number | bigint;
+        failedAt?: (number | bigint)[];
+        failureMessage?: string;
+    });
+    static from_obj_for_encoding(data: Record<string, any>): SimulateTransactionGroupResult;
+}
+/**
+ * Simulation result for an individual transaction
+ */
+export declare class SimulateTransactionResult extends BaseModel {
+    /**
+     * Details about a pending transaction. If the transaction was recently confirmed,
+     * includes confirmation details like the round and reward details.
+     */
+    txnResult: PendingTransactionResponse;
+    /**
+     * Budget used during execution of an app call transaction. This value includes
+     * budged used by inner app calls spawned by this transaction.
+     */
+    appBudgetConsumed?: number | bigint;
+    /**
+     * Budget used during execution of a logic sig transaction.
+     */
+    logicSigBudgetConsumed?: number | bigint;
+    /**
+     * Creates a new `SimulateTransactionResult` object.
+     * @param txnResult - Details about a pending transaction. If the transaction was recently confirmed,
+     * includes confirmation details like the round and reward details.
+     * @param appBudgetConsumed - Budget used during execution of an app call transaction. This value includes
+     * budged used by inner app calls spawned by this transaction.
+     * @param logicSigBudgetConsumed - Budget used during execution of a logic sig transaction.
+     */
+    constructor({ txnResult, appBudgetConsumed, logicSigBudgetConsumed, }: {
+        txnResult: PendingTransactionResponse;
+        appBudgetConsumed?: number | bigint;
+        logicSigBudgetConsumed?: number | bigint;
+    });
+    static from_obj_for_encoding(data: Record<string, any>): SimulateTransactionResult;
+}
+/**
+ * The set of parameters and limits override during simulation. If this set of
+ * parameters is present, then evaluation parameters may differ from standard
+ * evaluation in certain ways.
+ */
+export declare class SimulationEvalOverrides extends BaseModel {
+    /**
+     * If true, transactions without signatures are allowed and simulated as if they
+     * were properly signed.
+     */
+    allowEmptySignatures?: boolean;
+    /**
+     * The maximum log calls one can make during simulation
+     */
+    maxLogCalls?: number | bigint;
+    /**
+     * The maximum byte number to log during simulation
+     */
+    maxLogSize?: number | bigint;
+    /**
+     * Creates a new `SimulationEvalOverrides` object.
+     * @param allowEmptySignatures - If true, transactions without signatures are allowed and simulated as if they
+     * were properly signed.
+     * @param maxLogCalls - The maximum log calls one can make during simulation
+     * @param maxLogSize - The maximum byte number to log during simulation
+     */
+    constructor({ allowEmptySignatures, maxLogCalls, maxLogSize, }: {
+        allowEmptySignatures?: boolean;
+        maxLogCalls?: number | bigint;
+        maxLogSize?: number | bigint;
+    });
+    static from_obj_for_encoding(data: Record<string, any>): SimulationEvalOverrides;
+}
 /**
  * Represents a state proof and its corresponding message
  */

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

@@ -0,0 +1,4 @@
+import JSONRequest from '../jsonrequest';
+export default class Ready extends JSONRequest {
+    path(): string;
+}

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

@@ -0,0 +1,9 @@
+import JSONRequest from '../jsonrequest';
+import HTTPClient from '../../client';
+import IntDecoding from '../../../types/intDecoding';
+export default class SetBlockOffsetTimestamp extends JSONRequest {
+    private offset;
+    constructor(c: HTTPClient, intDecoding: IntDecoding, offset: number);
+    path(): string;
+    do(headers?: {}): Promise<any>;
+}

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

@@ -0,0 +1,9 @@
+import JSONRequest from '../jsonrequest';
+import HTTPClient from '../../client';
+import IntDecoding from '../../../types/intDecoding';
+export default class SetSyncRound extends JSONRequest {
+    private round;
+    constructor(c: HTTPClient, intDecoding: IntDecoding, round: number);
+    path(): string;
+    do(headers?: {}): Promise<any>;
+}

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

@@ -0,0 +1,19 @@
+import HTTPClient from '../../client';
+import JSONRequest from '../jsonrequest';
+import { SimulateRequest, SimulateResponse } from './models/types';
+/**
+ * Sets the default header (if not previously set) for simulating a raw
+ * transaction.
+ * @param headers - A headers object
+ */
+export declare function setSimulateTransactionsHeaders(headers?: {}): {};
+/**
+ * Simulates signed txns.
+ */
+export default class SimulateRawTransactions extends JSONRequest<SimulateResponse, Uint8Array> {
+    private requestBytes;
+    constructor(c: HTTPClient, request: SimulateRequest);
+    path(): string;
+    do(headers?: {}): Promise<SimulateResponse>;
+    prepare(body: Uint8Array): SimulateResponse;
+}

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

@@ -1,9 +1,9 @@
 import JSONRequest from '../jsonrequest';
-import { SuggestedParams } from '../../../types/transactions/base';
+import { SuggestedParamsWithMinFee } from '../../../types/transactions/base';
 /**
  * Returns the common needed parameters for a new transaction, in a format the transaction builder expects
  */
-export default class SuggestedParamsRequest extends JSONRequest<SuggestedParams> {
+export default class SuggestedParamsRequest extends JSONRequest<SuggestedParamsWithMinFee> {
     path(): string;
-    prepare(body: Record<string, any>): SuggestedParams;
+    prepare(body: Record<string, any>): SuggestedParamsWithMinFee;
 }

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

@@ -0,0 +1,5 @@
+import JSONRequest from '../jsonrequest';
+export default class UnsetSyncRound extends JSONRequest {
+    path(): string;
+    do(headers?: {}): Promise<any>;
+}

package/dist/types/composer.d.ts

@@ -1,5 +1,6 @@
-import { ABIValue, ABIMethod } from './abi';
+import { ABIMethod, ABIValue } from './abi';
 import Algodv2 from './client/v2/algod/algod';
+import { SimulateResponse, SimulateRequest } from './client/v2/algod/models/types';
 import { TransactionSigner, TransactionWithSigner } from './signer';
 import { BoxReference, OnApplicationComplete, SuggestedParams } from './types/transactions/base';
 export declare type ABIArgument = ABIValue | TransactionWithSigner;
@@ -149,6 +150,26 @@ export declare class AtomicTransactionComposer {
      * @returns A promise that, upon success, resolves to a list of TxIDs of the submitted transactions.
      */
     submit(client: Algodv2): Promise<string[]>;
+    /**
+     * Simulates the transaction group in the network.
+     *
+     * The composer will try to sign any transactions in the group, then simulate
+     * the results.
+     * Simulating the group will not change the composer's status.
+     *
+     * @param client - An Algodv2 client
+     * @param request - SimulateRequest with options in simulation.
+     *   If provided, the request's transaction group will be overrwritten by the composer's group,
+     *   only simulation related options will be used.
+     *
+     * @returns A promise that, upon success, resolves to an object containing an
+     *   array of results containing one element for each method call transaction
+     *   in this group (ABIResult[]) and the SimulateResponse object.
+     */
+    simulate(client: Algodv2, request?: SimulateRequest): Promise<{
+        methodResults: ABIResult[];
+        simulateResponse: SimulateResponse;
+    }>;
     /**
      * 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.
@@ -171,4 +192,13 @@ export declare class AtomicTransactionComposer {
         txIDs: string[];
         methodResults: ABIResult[];
     }>;
+    /**
+     * Parses a single ABI Method transaction log into a ABI result object.
+     *
+     * @param method
+     * @param methodResult
+     * @param pendingInfo
+     * @returns An ABIResult object
+     */
+    static parseMethodResponse(method: ABIMethod, methodResult: ABIResult, pendingInfo: Record<string, any>): ABIResult;
 }

package/dist/types/encoding/encoding.d.ts

@@ -10,6 +10,13 @@
  *  5. Binary blob should be used for binary data and string for strings
  *  */
 export declare const ERROR_CONTAINS_EMPTY_STRING = "The object contains empty or 0 values. First empty or 0 value encountered during encoding: ";
+/**
+ * rawEncode encodes objects using msgpack, regardless of whether there are
+ * empty or 0 value fields.
+ * @param obj - a dictionary to be encoded. May or may not contain empty or 0 values.
+ * @returns msgpack representation of the object
+ */
+export declare function rawEncode(obj: Record<string | number | symbol, any>): Uint8Array;
 /**
  * encode encodes objects using msgpack
  * @param obj - a dictionary to be encoded. Must not contain empty or 0 values.

package/dist/types/main.d.ts

@@ -66,6 +66,7 @@ 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 { AlgodTokenHeader, IndexerTokenHeader, KMDTokenHeader, CustomTokenHeader, TokenHeader, } from './client/urlTokenBaseHTTPClient';
 export { waitForConfirmation } from './wait';
 export { isValidAddress, encodeAddress, decodeAddress, getApplicationAddress, } from './encoding/address';
 export { bytesToBigInt, bigIntToBytes } from './encoding/bigint';

package/dist/types/makeTxn.d.ts

@@ -49,9 +49,7 @@ export declare function makeKeyRegistrationTxnWithSuggestedParams(from: KeyRegis
 export declare function makeKeyRegistrationTxnWithSuggestedParamsFromObject(o: Expand<Pick<RenameProperty<MustHaveSuggestedParams<KeyRegistrationTxn>, 'reKeyTo', 'rekeyTo'>, 'from' | 'note' | 'voteKey' | 'selectionKey' | 'stateProofKey' | 'voteFirst' | 'voteLast' | 'voteKeyDilution' | 'suggestedParams' | 'rekeyTo'> & {
     nonParticipation?: false;
 }>): txnBuilder.Transaction;
-export declare function makeKeyRegistrationTxnWithSuggestedParamsFromObject(o: Expand<Pick<RenameProperty<MustHaveSuggestedParams<KeyRegistrationTxn>, 'reKeyTo', 'rekeyTo'>, 'from' | 'note' | 'suggestedParams' | 'rekeyTo'> & {
-    nonParticipation: true;
-}>): txnBuilder.Transaction;
+export declare function makeKeyRegistrationTxnWithSuggestedParamsFromObject(o: Expand<Pick<RenameProperty<MustHaveSuggestedParams<KeyRegistrationTxn>, 'reKeyTo', 'rekeyTo'>, 'from' | 'note' | 'suggestedParams' | 'rekeyTo' | 'nonParticipation'>>): txnBuilder.Transaction;
 /** makeAssetCreateTxnWithSuggestedParams takes asset creation arguments and returns a Transaction object
  * for creating that asset
  *

package/dist/types/signer.d.ts

@@ -25,6 +25,11 @@ export declare function makeLogicSigAccountTransactionSigner(account: LogicSigAc
  * @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;
+/**
+ * Create a makeEmptyTransactionSigner that does not specify any signer or
+ * signing capabilities. This should only be used to simulate transactions.
+ */
+export declare function makeEmptyTransactionSigner(): TransactionSigner;
 /** Represents an unsigned transactions and a signer that can authorize that transaction. */
 export interface TransactionWithSigner {
     /** An unsigned transaction */

package/dist/types/transaction.d.ts

@@ -140,6 +140,15 @@ export declare class Transaction implements TransactionStorageStructure {
     prettyPrint(): void;
     toString(): string;
 }
+/**
+ * encodeUnsignedSimulateTransaction takes a txnBuilder.Transaction object,
+ * converts it into a SignedTransaction-like object, and converts it to a Buffer.
+ *
+ * Note: this function should only be used to simulate unsigned transactions.
+ *
+ * @param transactionObject - Transaction object to simulate.
+ */
+export declare function encodeUnsignedSimulateTransaction(transactionObject: Transaction): Uint8Array;
 /**
  * encodeUnsignedTransaction takes a completed txnBuilder.Transaction object, such as from the makeFoo
  * family of transactions, and converts it to a Buffer

package/dist/types/types/transactions/base.d.ts

@@ -101,6 +101,12 @@ export interface SuggestedParams {
      */
     genesisHash: string;
 }
+export declare type SuggestedParamsWithMinFee = SuggestedParams & {
+    /**
+     * Minimum fee (not per byte) required for the transaction to be confirmed
+     */
+    minFee: number;
+};
 /**
  * A grouping of the app ID and name of the box in an Uint8Array
  */

package/dist/types/types/transactions/builder.d.ts

@@ -21,7 +21,7 @@ export declare type TransactionBase = TransactionBaseWithoutSuggestedParams | Tr
  * - A: Additional parameters on top of the base transaction parameters
  * - O: A set of overwrites for transaction parameters
  */
-export declare type ConstructTransaction<A = {}, O = {}> = DistributiveOverwrite<TransactionBase & A, O>;
+export declare type ConstructTransaction<A = {}, O extends Partial<TransactionBase & A> = {}> = DistributiveOverwrite<TransactionBase & A, O>;
 /**
  * Only accept transaction objects that include suggestedParams as an object
  */

package/dist/types/types/utils.d.ts

@@ -16,7 +16,7 @@ export declare type Overwrite<T, U extends Partial<T>> = Pick<T, Exclude<keyof T
 /**
  * Same as Overwrite, but will distribute the Overwrite over unions
  */
-export declare type DistributiveOverwrite<T, K> = T extends unknown ? Overwrite<T, K> : never;
+export declare type DistributiveOverwrite<T, K extends Partial<T>> = T extends unknown ? Overwrite<T, K> : never;
 /**
  * Mark certain keys as prohibited
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "algosdk",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "The official JavaScript SDK for Algorand",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -82,6 +82,6 @@
   "author": "Algorand, llc",
   "license": "MIT",
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=16.0.0"
   }
 }