@algorandfoundation/algokit-utils 9.2.0-beta.7 → 10.0.0-alpha.1

package/testing/transaction-logger.js.map

@@ -1 +1 @@
-{"version":3,"file":"transaction-logger.js","sources":["../../src/testing/transaction-logger.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { Config } from '../config'\nimport { runWhenIndexerCaughtUp } from './indexer'\nimport Algodv2 = algosdk.Algodv2\nimport decodeSignedTransaction = algosdk.decodeSignedTransaction\nimport Indexer = algosdk.Indexer\n\n/**\n * Allows you to keep track of Algorand transaction IDs by wrapping an `Algodv2` in a proxy.\n * Useful for automated tests.\n */\nexport class TransactionLogger {\n  private _sentTransactionIds: string[] = []\n  private _latestLastValidRound?: bigint\n\n  private _pushTxn(stxn: Uint8Array) {\n    const decoded = decodeSignedTransaction(stxn)\n    if (decoded.txn.lastValid > (this._latestLastValidRound ?? BigInt(0))) {\n      this._latestLastValidRound = BigInt(decoded.txn.lastValid)\n    }\n    this._sentTransactionIds.push(decoded.txn.txID())\n  }\n\n  /**\n   * The list of transaction IDs that has been logged thus far.\n   */\n  get sentTransactionIds(): Readonly<string[]> {\n    return this._sentTransactionIds\n  }\n\n  /**\n   * Clear all logged IDs.\n   */\n  clear() {\n    this._sentTransactionIds = []\n  }\n\n  /**\n   * The method that captures raw transactions and stores the transaction IDs.\n   */\n  logRawTransaction(signedTransactions: Uint8Array | Uint8Array[]) {\n    if (Array.isArray(signedTransactions)) {\n      signedTransactions.forEach((stxn) => this._pushTxn(stxn))\n    } else {\n      this._pushTxn(signedTransactions)\n    }\n  }\n\n  /** Return a proxy that wraps the given Algodv2 with this transaction logger.\n   *\n   * @param algod The `Algodv2` to wrap\n   * @returns The wrapped `Algodv2`, any transactions sent using this algod instance will be logged by this transaction logger\n   */\n  capture(algod: Algodv2): Algodv2 {\n    return new Proxy<Algodv2>(algod, new TransactionLoggingAlgodv2ProxyHandler(this))\n  }\n\n  /** Wait until all logged transactions IDs appear in the given `Indexer`. */\n  async waitForIndexer(indexer: Indexer) {\n    if (this._sentTransactionIds.length === 0) return\n    const lastTxId = this._sentTransactionIds[this._sentTransactionIds.length - 1]\n    await runWhenIndexerCaughtUp(async () => {\n      try {\n        await indexer.lookupTransactionByID(lastTxId).do()\n      } catch (e) {\n        // If the txid lookup failed, then try to look up the last valid round\n        // If that round exists, then we know indexer is caught up\n        if (this._latestLastValidRound) {\n          await indexer.lookupBlock(this._latestLastValidRound).do()\n          Config.getLogger().debug(\n            `waitForIndexer has waited until the last valid round ${this._latestLastValidRound} was indexed, but did not find transaction ${lastTxId} in the indexer.`,\n          )\n        } else {\n          throw e\n        }\n      }\n    })\n  }\n}\n\nclass TransactionLoggingAlgodv2ProxyHandler implements ProxyHandler<Algodv2> {\n  private transactionLogger: TransactionLogger\n\n  constructor(transactionLogger: TransactionLogger) {\n    this.transactionLogger = transactionLogger\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  get(target: Algodv2, property: string | symbol, receiver: any) {\n    if (property === 'sendRawTransaction') {\n      return (stxOrStxs: Uint8Array | Uint8Array[]) => {\n        this.transactionLogger.logRawTransaction(stxOrStxs)\n        return target[property].call(receiver, stxOrStxs)\n      }\n    }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return (target as any)[property]\n  }\n}\n"],"names":["indexer","runWhenIndexerCaughtUp","Config"],"mappings":";;;;;;AAIA,IAAO,uBAAuB,GAAG,OAAO,CAAC,uBAAuB;AAGhE;;;AAGG;MACU,iBAAiB,CAAA;AAA9B,IAAA,WAAA,GAAA;QACU,IAAmB,CAAA,mBAAA,GAAa,EAAE;;AAGlC,IAAA,QAAQ,CAAC,IAAgB,EAAA;AAC/B,QAAA,MAAM,OAAO,GAAG,uBAAuB,CAAC,IAAI,CAAC;AAC7C,QAAA,IAAI,OAAO,CAAC,GAAG,CAAC,SAAS,IAAI,IAAI,CAAC,qBAAqB,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE;YACrE,IAAI,CAAC,qBAAqB,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC;;AAE5D,QAAA,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;;AAGnD;;AAEG;AACH,IAAA,IAAI,kBAAkB,GAAA;QACpB,OAAO,IAAI,CAAC,mBAAmB;;AAGjC;;AAEG;IACH,KAAK,GAAA;AACH,QAAA,IAAI,CAAC,mBAAmB,GAAG,EAAE;;AAG/B;;AAEG;AACH,IAAA,iBAAiB,CAAC,kBAA6C,EAAA;AAC7D,QAAA,IAAI,KAAK,CAAC,OAAO,CAAC,kBAAkB,CAAC,EAAE;AACrC,YAAA,kBAAkB,CAAC,OAAO,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;;aACpD;AACL,YAAA,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC;;;AAIrC;;;;AAIG;AACH,IAAA,OAAO,CAAC,KAAc,EAAA;QACpB,OAAO,IAAI,KAAK,CAAU,KAAK,EAAE,IAAI,qCAAqC,CAAC,IAAI,CAAC,CAAC;;;IAInF,MAAM,cAAc,CAACA,SAAgB,EAAA;AACnC,QAAA,IAAI,IAAI,CAAC,mBAAmB,CAAC,MAAM,KAAK,CAAC;YAAE;AAC3C,QAAA,MAAM,QAAQ,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,mBAAmB,CAAC,MAAM,GAAG,CAAC,CAAC;AAC9E,QAAA,MAAMC,8BAAsB,CAAC,YAAW;AACtC,YAAA,IAAI;gBACF,MAAMD,SAAO,CAAC,qBAAqB,CAAC,QAAQ,CAAC,CAAC,EAAE,EAAE;;YAClD,OAAO,CAAC,EAAE;;;AAGV,gBAAA,IAAI,IAAI,CAAC,qBAAqB,EAAE;oBAC9B,MAAMA,SAAO,CAAC,WAAW,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC,EAAE,EAAE;AAC1D,oBAAAE,aAAM,CAAC,SAAS,EAAE,CAAC,KAAK,CACtB,CAAA,qDAAA,EAAwD,IAAI,CAAC,qBAAqB,CAAA,2CAAA,EAA8C,QAAQ,CAAA,gBAAA,CAAkB,CAC3J;;qBACI;AACL,oBAAA,MAAM,CAAC;;;AAGb,SAAC,CAAC;;AAEL;AAED,MAAM,qCAAqC,CAAA;AAGzC,IAAA,WAAA,CAAY,iBAAoC,EAAA;AAC9C,QAAA,IAAI,CAAC,iBAAiB,GAAG,iBAAiB;;;AAI5C,IAAA,GAAG,CAAC,MAAe,EAAE,QAAyB,EAAE,QAAa,EAAA;AAC3D,QAAA,IAAI,QAAQ,KAAK,oBAAoB,EAAE;YACrC,OAAO,CAAC,SAAoC,KAAI;AAC9C,gBAAA,IAAI,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,SAAS,CAAC;gBACnD,OAAO,MAAM,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC;AACnD,aAAC;;;AAGH,QAAA,OAAQ,MAAc,CAAC,QAAQ,CAAC;;AAEnC;;;;"}
+{"version":3,"file":"transaction-logger.js","names":["decodeSignedTransaction","runWhenIndexerCaughtUp"],"sources":["../../src/testing/transaction-logger.ts"],"sourcesContent":["import { AlgodClient } from '@algorandfoundation/algokit-algod-client'\nimport { IndexerClient } from '@algorandfoundation/algokit-indexer-client'\nimport { decodeSignedTransaction } from '@algorandfoundation/algokit-transact'\nimport { Config } from '../config'\nimport { runWhenIndexerCaughtUp } from './indexer'\n\n/**\n * Allows you to keep track of Algorand transaction IDs by wrapping an `AlgodClient` in a proxy.\n * Useful for automated tests.\n */\nexport class TransactionLogger {\n  private _sentTransactionIds: string[] = []\n  private _latestLastValidRound?: bigint\n\n  private _pushTxn(stxn: Uint8Array) {\n    const decoded = decodeSignedTransaction(stxn)\n    if (decoded.txn.lastValid > (this._latestLastValidRound ?? BigInt(0))) {\n      this._latestLastValidRound = decoded.txn.lastValid\n    }\n    this._sentTransactionIds.push(decoded.txn.txId())\n  }\n\n  /**\n   * The list of transaction IDs that has been logged thus far.\n   */\n  get sentTransactionIds(): Readonly<string[]> {\n    return this._sentTransactionIds\n  }\n\n  /**\n   * Clear all logged IDs.\n   */\n  clear() {\n    this._sentTransactionIds = []\n  }\n\n  /**\n   * The method that captures raw transactions and stores the transaction IDs.\n   */\n  logRawTransaction(signedTransactions: Uint8Array | Uint8Array[]) {\n    if (Array.isArray(signedTransactions)) {\n      signedTransactions.forEach((stxn) => this._pushTxn(stxn))\n    } else {\n      this._pushTxn(signedTransactions)\n    }\n  }\n\n  /** Return a proxy that wraps the given AlgodClient with this transaction logger.\n   *\n   * @param algod The `AlgodClient` to wrap\n   * @returns The wrapped `AlgodClient`, any transactions sent using this algod instance will be logged by this transaction logger\n   */\n  capture(algod: AlgodClient): AlgodClient {\n    return new Proxy<AlgodClient>(algod, new TransactionLoggingAlgodClientProxyHandler(this))\n  }\n\n  /** Wait until all logged transactions IDs appear in the given `Indexer`. */\n  async waitForIndexer(indexer: IndexerClient) {\n    if (this._sentTransactionIds.length === 0) return\n    const lastTxId = this._sentTransactionIds[this._sentTransactionIds.length - 1]\n    await runWhenIndexerCaughtUp(async () => {\n      try {\n        await indexer.lookupTransactionById(lastTxId)\n      } catch (e) {\n        // If the txid lookup failed, then try to look up the last valid round\n        // If that round exists, then we know indexer is caught up\n        if (this._latestLastValidRound) {\n          await indexer.lookupBlock(this._latestLastValidRound)\n          Config.getLogger().debug(\n            `waitForIndexer has waited until the last valid round ${this._latestLastValidRound} was indexed, but did not find transaction ${lastTxId} in the indexer.`,\n          )\n        } else {\n          throw e\n        }\n      }\n    })\n  }\n}\n\nclass TransactionLoggingAlgodClientProxyHandler implements ProxyHandler<AlgodClient> {\n  private transactionLogger: TransactionLogger\n\n  constructor(transactionLogger: TransactionLogger) {\n    this.transactionLogger = transactionLogger\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  get(target: AlgodClient, property: string | symbol, receiver: any) {\n    if (property === 'sendRawTransaction') {\n      return (stxOrStxs: Uint8Array | Uint8Array[]) => {\n        this.transactionLogger.logRawTransaction(stxOrStxs)\n        return target[property].call(receiver, stxOrStxs)\n      }\n    }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return (target as any)[property]\n  }\n}\n"],"mappings":";;;;;;;;;AAUA,IAAa,oBAAb,MAA+B;CAC7B,AAAQ,sBAAgC,EAAE;CAC1C,AAAQ;CAER,AAAQ,SAAS,MAAkB;EACjC,MAAM,UAAUA,mDAAwB,KAAK;AAC7C,MAAI,QAAQ,IAAI,aAAa,KAAK,yBAAyB,OAAO,EAAE,EAClE,MAAK,wBAAwB,QAAQ,IAAI;AAE3C,OAAK,oBAAoB,KAAK,QAAQ,IAAI,MAAM,CAAC;;;;;CAMnD,IAAI,qBAAyC;AAC3C,SAAO,KAAK;;;;;CAMd,QAAQ;AACN,OAAK,sBAAsB,EAAE;;;;;CAM/B,kBAAkB,oBAA+C;AAC/D,MAAI,MAAM,QAAQ,mBAAmB,CACnC,oBAAmB,SAAS,SAAS,KAAK,SAAS,KAAK,CAAC;MAEzD,MAAK,SAAS,mBAAmB;;;;;;;CASrC,QAAQ,OAAiC;AACvC,SAAO,IAAI,MAAmB,OAAO,IAAI,0CAA0C,KAAK,CAAC;;;CAI3F,MAAM,eAAe,SAAwB;AAC3C,MAAI,KAAK,oBAAoB,WAAW,EAAG;EAC3C,MAAM,WAAW,KAAK,oBAAoB,KAAK,oBAAoB,SAAS;AAC5E,QAAMC,uCAAuB,YAAY;AACvC,OAAI;AACF,UAAM,QAAQ,sBAAsB,SAAS;YACtC,GAAG;AAGV,QAAI,KAAK,uBAAuB;AAC9B,WAAM,QAAQ,YAAY,KAAK,sBAAsB;AACrD,2BAAO,WAAW,CAAC,MACjB,wDAAwD,KAAK,sBAAsB,6CAA6C,SAAS,kBAC1I;UAED,OAAM;;IAGV;;;AAIN,IAAM,4CAAN,MAAqF;CACnF,AAAQ;CAER,YAAY,mBAAsC;AAChD,OAAK,oBAAoB;;CAI3B,IAAI,QAAqB,UAA2B,UAAe;AACjE,MAAI,aAAa,qBACf,SAAQ,cAAyC;AAC/C,QAAK,kBAAkB,kBAAkB,UAAU;AACnD,UAAO,OAAO,UAAU,KAAK,UAAU,UAAU;;AAIrD,SAAQ,OAAe"}

package/testing/transaction-logger.mjs

@@ -1,93 +1,77 @@
-import algosdk from 'algosdk';
-import { Config } from '../config.mjs';
-import { runWhenIndexerCaughtUp } from './indexer.mjs';
+import { decodeSignedTransaction } from "../packages/transact/src/transactions/signed-transaction.mjs";
+import { Config } from "../config.mjs";
+import { runWhenIndexerCaughtUp } from "./indexer.mjs";
 
-var decodeSignedTransaction = algosdk.decodeSignedTransaction;
+//#region src/testing/transaction-logger.ts
 /**
- * Allows you to keep track of Algorand transaction IDs by wrapping an `Algodv2` in a proxy.
- * Useful for automated tests.
- */
-class TransactionLogger {
-    constructor() {
-        this._sentTransactionIds = [];
-    }
-    _pushTxn(stxn) {
-        const decoded = decodeSignedTransaction(stxn);
-        if (decoded.txn.lastValid > (this._latestLastValidRound ?? BigInt(0))) {
-            this._latestLastValidRound = BigInt(decoded.txn.lastValid);
-        }
-        this._sentTransactionIds.push(decoded.txn.txID());
-    }
-    /**
-     * The list of transaction IDs that has been logged thus far.
-     */
-    get sentTransactionIds() {
-        return this._sentTransactionIds;
-    }
-    /**
-     * Clear all logged IDs.
-     */
-    clear() {
-        this._sentTransactionIds = [];
-    }
-    /**
-     * The method that captures raw transactions and stores the transaction IDs.
-     */
-    logRawTransaction(signedTransactions) {
-        if (Array.isArray(signedTransactions)) {
-            signedTransactions.forEach((stxn) => this._pushTxn(stxn));
-        }
-        else {
-            this._pushTxn(signedTransactions);
-        }
-    }
-    /** Return a proxy that wraps the given Algodv2 with this transaction logger.
-     *
-     * @param algod The `Algodv2` to wrap
-     * @returns The wrapped `Algodv2`, any transactions sent using this algod instance will be logged by this transaction logger
-     */
-    capture(algod) {
-        return new Proxy(algod, new TransactionLoggingAlgodv2ProxyHandler(this));
-    }
-    /** Wait until all logged transactions IDs appear in the given `Indexer`. */
-    async waitForIndexer(indexer) {
-        if (this._sentTransactionIds.length === 0)
-            return;
-        const lastTxId = this._sentTransactionIds[this._sentTransactionIds.length - 1];
-        await runWhenIndexerCaughtUp(async () => {
-            try {
-                await indexer.lookupTransactionByID(lastTxId).do();
-            }
-            catch (e) {
-                // If the txid lookup failed, then try to look up the last valid round
-                // If that round exists, then we know indexer is caught up
-                if (this._latestLastValidRound) {
-                    await indexer.lookupBlock(this._latestLastValidRound).do();
-                    Config.getLogger().debug(`waitForIndexer has waited until the last valid round ${this._latestLastValidRound} was indexed, but did not find transaction ${lastTxId} in the indexer.`);
-                }
-                else {
-                    throw e;
-                }
-            }
-        });
-    }
-}
-class TransactionLoggingAlgodv2ProxyHandler {
-    constructor(transactionLogger) {
-        this.transactionLogger = transactionLogger;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    get(target, property, receiver) {
-        if (property === 'sendRawTransaction') {
-            return (stxOrStxs) => {
-                this.transactionLogger.logRawTransaction(stxOrStxs);
-                return target[property].call(receiver, stxOrStxs);
-            };
-        }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return target[property];
-    }
-}
+* Allows you to keep track of Algorand transaction IDs by wrapping an `AlgodClient` in a proxy.
+* Useful for automated tests.
+*/
+var TransactionLogger = class {
+	_sentTransactionIds = [];
+	_latestLastValidRound;
+	_pushTxn(stxn) {
+		const decoded = decodeSignedTransaction(stxn);
+		if (decoded.txn.lastValid > (this._latestLastValidRound ?? BigInt(0))) this._latestLastValidRound = decoded.txn.lastValid;
+		this._sentTransactionIds.push(decoded.txn.txId());
+	}
+	/**
+	* The list of transaction IDs that has been logged thus far.
+	*/
+	get sentTransactionIds() {
+		return this._sentTransactionIds;
+	}
+	/**
+	* Clear all logged IDs.
+	*/
+	clear() {
+		this._sentTransactionIds = [];
+	}
+	/**
+	* The method that captures raw transactions and stores the transaction IDs.
+	*/
+	logRawTransaction(signedTransactions) {
+		if (Array.isArray(signedTransactions)) signedTransactions.forEach((stxn) => this._pushTxn(stxn));
+		else this._pushTxn(signedTransactions);
+	}
+	/** Return a proxy that wraps the given AlgodClient with this transaction logger.
+	*
+	* @param algod The `AlgodClient` to wrap
+	* @returns The wrapped `AlgodClient`, any transactions sent using this algod instance will be logged by this transaction logger
+	*/
+	capture(algod) {
+		return new Proxy(algod, new TransactionLoggingAlgodClientProxyHandler(this));
+	}
+	/** Wait until all logged transactions IDs appear in the given `Indexer`. */
+	async waitForIndexer(indexer) {
+		if (this._sentTransactionIds.length === 0) return;
+		const lastTxId = this._sentTransactionIds[this._sentTransactionIds.length - 1];
+		await runWhenIndexerCaughtUp(async () => {
+			try {
+				await indexer.lookupTransactionById(lastTxId);
+			} catch (e) {
+				if (this._latestLastValidRound) {
+					await indexer.lookupBlock(this._latestLastValidRound);
+					Config.getLogger().debug(`waitForIndexer has waited until the last valid round ${this._latestLastValidRound} was indexed, but did not find transaction ${lastTxId} in the indexer.`);
+				} else throw e;
+			}
+		});
+	}
+};
+var TransactionLoggingAlgodClientProxyHandler = class {
+	transactionLogger;
+	constructor(transactionLogger) {
+		this.transactionLogger = transactionLogger;
+	}
+	get(target, property, receiver) {
+		if (property === "sendRawTransaction") return (stxOrStxs) => {
+			this.transactionLogger.logRawTransaction(stxOrStxs);
+			return target[property].call(receiver, stxOrStxs);
+		};
+		return target[property];
+	}
+};
 
+//#endregion
 export { TransactionLogger };
-//# sourceMappingURL=transaction-logger.mjs.map
+//# sourceMappingURL=transaction-logger.mjs.map

package/testing/transaction-logger.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"transaction-logger.mjs","sources":["../../src/testing/transaction-logger.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { Config } from '../config'\nimport { runWhenIndexerCaughtUp } from './indexer'\nimport Algodv2 = algosdk.Algodv2\nimport decodeSignedTransaction = algosdk.decodeSignedTransaction\nimport Indexer = algosdk.Indexer\n\n/**\n * Allows you to keep track of Algorand transaction IDs by wrapping an `Algodv2` in a proxy.\n * Useful for automated tests.\n */\nexport class TransactionLogger {\n  private _sentTransactionIds: string[] = []\n  private _latestLastValidRound?: bigint\n\n  private _pushTxn(stxn: Uint8Array) {\n    const decoded = decodeSignedTransaction(stxn)\n    if (decoded.txn.lastValid > (this._latestLastValidRound ?? BigInt(0))) {\n      this._latestLastValidRound = BigInt(decoded.txn.lastValid)\n    }\n    this._sentTransactionIds.push(decoded.txn.txID())\n  }\n\n  /**\n   * The list of transaction IDs that has been logged thus far.\n   */\n  get sentTransactionIds(): Readonly<string[]> {\n    return this._sentTransactionIds\n  }\n\n  /**\n   * Clear all logged IDs.\n   */\n  clear() {\n    this._sentTransactionIds = []\n  }\n\n  /**\n   * The method that captures raw transactions and stores the transaction IDs.\n   */\n  logRawTransaction(signedTransactions: Uint8Array | Uint8Array[]) {\n    if (Array.isArray(signedTransactions)) {\n      signedTransactions.forEach((stxn) => this._pushTxn(stxn))\n    } else {\n      this._pushTxn(signedTransactions)\n    }\n  }\n\n  /** Return a proxy that wraps the given Algodv2 with this transaction logger.\n   *\n   * @param algod The `Algodv2` to wrap\n   * @returns The wrapped `Algodv2`, any transactions sent using this algod instance will be logged by this transaction logger\n   */\n  capture(algod: Algodv2): Algodv2 {\n    return new Proxy<Algodv2>(algod, new TransactionLoggingAlgodv2ProxyHandler(this))\n  }\n\n  /** Wait until all logged transactions IDs appear in the given `Indexer`. */\n  async waitForIndexer(indexer: Indexer) {\n    if (this._sentTransactionIds.length === 0) return\n    const lastTxId = this._sentTransactionIds[this._sentTransactionIds.length - 1]\n    await runWhenIndexerCaughtUp(async () => {\n      try {\n        await indexer.lookupTransactionByID(lastTxId).do()\n      } catch (e) {\n        // If the txid lookup failed, then try to look up the last valid round\n        // If that round exists, then we know indexer is caught up\n        if (this._latestLastValidRound) {\n          await indexer.lookupBlock(this._latestLastValidRound).do()\n          Config.getLogger().debug(\n            `waitForIndexer has waited until the last valid round ${this._latestLastValidRound} was indexed, but did not find transaction ${lastTxId} in the indexer.`,\n          )\n        } else {\n          throw e\n        }\n      }\n    })\n  }\n}\n\nclass TransactionLoggingAlgodv2ProxyHandler implements ProxyHandler<Algodv2> {\n  private transactionLogger: TransactionLogger\n\n  constructor(transactionLogger: TransactionLogger) {\n    this.transactionLogger = transactionLogger\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  get(target: Algodv2, property: string | symbol, receiver: any) {\n    if (property === 'sendRawTransaction') {\n      return (stxOrStxs: Uint8Array | Uint8Array[]) => {\n        this.transactionLogger.logRawTransaction(stxOrStxs)\n        return target[property].call(receiver, stxOrStxs)\n      }\n    }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return (target as any)[property]\n  }\n}\n"],"names":[],"mappings":";;;;AAIA,IAAO,uBAAuB,GAAG,OAAO,CAAC,uBAAuB;AAGhE;;;AAGG;MACU,iBAAiB,CAAA;AAA9B,IAAA,WAAA,GAAA;QACU,IAAmB,CAAA,mBAAA,GAAa,EAAE;;AAGlC,IAAA,QAAQ,CAAC,IAAgB,EAAA;AAC/B,QAAA,MAAM,OAAO,GAAG,uBAAuB,CAAC,IAAI,CAAC;AAC7C,QAAA,IAAI,OAAO,CAAC,GAAG,CAAC,SAAS,IAAI,IAAI,CAAC,qBAAqB,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE;YACrE,IAAI,CAAC,qBAAqB,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC;;AAE5D,QAAA,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;;AAGnD;;AAEG;AACH,IAAA,IAAI,kBAAkB,GAAA;QACpB,OAAO,IAAI,CAAC,mBAAmB;;AAGjC;;AAEG;IACH,KAAK,GAAA;AACH,QAAA,IAAI,CAAC,mBAAmB,GAAG,EAAE;;AAG/B;;AAEG;AACH,IAAA,iBAAiB,CAAC,kBAA6C,EAAA;AAC7D,QAAA,IAAI,KAAK,CAAC,OAAO,CAAC,kBAAkB,CAAC,EAAE;AACrC,YAAA,kBAAkB,CAAC,OAAO,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;;aACpD;AACL,YAAA,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC;;;AAIrC;;;;AAIG;AACH,IAAA,OAAO,CAAC,KAAc,EAAA;QACpB,OAAO,IAAI,KAAK,CAAU,KAAK,EAAE,IAAI,qCAAqC,CAAC,IAAI,CAAC,CAAC;;;IAInF,MAAM,cAAc,CAAC,OAAgB,EAAA;AACnC,QAAA,IAAI,IAAI,CAAC,mBAAmB,CAAC,MAAM,KAAK,CAAC;YAAE;AAC3C,QAAA,MAAM,QAAQ,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,mBAAmB,CAAC,MAAM,GAAG,CAAC,CAAC;AAC9E,QAAA,MAAM,sBAAsB,CAAC,YAAW;AACtC,YAAA,IAAI;gBACF,MAAM,OAAO,CAAC,qBAAqB,CAAC,QAAQ,CAAC,CAAC,EAAE,EAAE;;YAClD,OAAO,CAAC,EAAE;;;AAGV,gBAAA,IAAI,IAAI,CAAC,qBAAqB,EAAE;oBAC9B,MAAM,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC,EAAE,EAAE;AAC1D,oBAAA,MAAM,CAAC,SAAS,EAAE,CAAC,KAAK,CACtB,CAAA,qDAAA,EAAwD,IAAI,CAAC,qBAAqB,CAAA,2CAAA,EAA8C,QAAQ,CAAA,gBAAA,CAAkB,CAC3J;;qBACI;AACL,oBAAA,MAAM,CAAC;;;AAGb,SAAC,CAAC;;AAEL;AAED,MAAM,qCAAqC,CAAA;AAGzC,IAAA,WAAA,CAAY,iBAAoC,EAAA;AAC9C,QAAA,IAAI,CAAC,iBAAiB,GAAG,iBAAiB;;;AAI5C,IAAA,GAAG,CAAC,MAAe,EAAE,QAAyB,EAAE,QAAa,EAAA;AAC3D,QAAA,IAAI,QAAQ,KAAK,oBAAoB,EAAE;YACrC,OAAO,CAAC,SAAoC,KAAI;AAC9C,gBAAA,IAAI,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,SAAS,CAAC;gBACnD,OAAO,MAAM,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC;AACnD,aAAC;;;AAGH,QAAA,OAAQ,MAAc,CAAC,QAAQ,CAAC;;AAEnC;;;;"}
+{"version":3,"file":"transaction-logger.mjs","names":[],"sources":["../../src/testing/transaction-logger.ts"],"sourcesContent":["import { AlgodClient } from '@algorandfoundation/algokit-algod-client'\nimport { IndexerClient } from '@algorandfoundation/algokit-indexer-client'\nimport { decodeSignedTransaction } from '@algorandfoundation/algokit-transact'\nimport { Config } from '../config'\nimport { runWhenIndexerCaughtUp } from './indexer'\n\n/**\n * Allows you to keep track of Algorand transaction IDs by wrapping an `AlgodClient` in a proxy.\n * Useful for automated tests.\n */\nexport class TransactionLogger {\n  private _sentTransactionIds: string[] = []\n  private _latestLastValidRound?: bigint\n\n  private _pushTxn(stxn: Uint8Array) {\n    const decoded = decodeSignedTransaction(stxn)\n    if (decoded.txn.lastValid > (this._latestLastValidRound ?? BigInt(0))) {\n      this._latestLastValidRound = decoded.txn.lastValid\n    }\n    this._sentTransactionIds.push(decoded.txn.txId())\n  }\n\n  /**\n   * The list of transaction IDs that has been logged thus far.\n   */\n  get sentTransactionIds(): Readonly<string[]> {\n    return this._sentTransactionIds\n  }\n\n  /**\n   * Clear all logged IDs.\n   */\n  clear() {\n    this._sentTransactionIds = []\n  }\n\n  /**\n   * The method that captures raw transactions and stores the transaction IDs.\n   */\n  logRawTransaction(signedTransactions: Uint8Array | Uint8Array[]) {\n    if (Array.isArray(signedTransactions)) {\n      signedTransactions.forEach((stxn) => this._pushTxn(stxn))\n    } else {\n      this._pushTxn(signedTransactions)\n    }\n  }\n\n  /** Return a proxy that wraps the given AlgodClient with this transaction logger.\n   *\n   * @param algod The `AlgodClient` to wrap\n   * @returns The wrapped `AlgodClient`, any transactions sent using this algod instance will be logged by this transaction logger\n   */\n  capture(algod: AlgodClient): AlgodClient {\n    return new Proxy<AlgodClient>(algod, new TransactionLoggingAlgodClientProxyHandler(this))\n  }\n\n  /** Wait until all logged transactions IDs appear in the given `Indexer`. */\n  async waitForIndexer(indexer: IndexerClient) {\n    if (this._sentTransactionIds.length === 0) return\n    const lastTxId = this._sentTransactionIds[this._sentTransactionIds.length - 1]\n    await runWhenIndexerCaughtUp(async () => {\n      try {\n        await indexer.lookupTransactionById(lastTxId)\n      } catch (e) {\n        // If the txid lookup failed, then try to look up the last valid round\n        // If that round exists, then we know indexer is caught up\n        if (this._latestLastValidRound) {\n          await indexer.lookupBlock(this._latestLastValidRound)\n          Config.getLogger().debug(\n            `waitForIndexer has waited until the last valid round ${this._latestLastValidRound} was indexed, but did not find transaction ${lastTxId} in the indexer.`,\n          )\n        } else {\n          throw e\n        }\n      }\n    })\n  }\n}\n\nclass TransactionLoggingAlgodClientProxyHandler implements ProxyHandler<AlgodClient> {\n  private transactionLogger: TransactionLogger\n\n  constructor(transactionLogger: TransactionLogger) {\n    this.transactionLogger = transactionLogger\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  get(target: AlgodClient, property: string | symbol, receiver: any) {\n    if (property === 'sendRawTransaction') {\n      return (stxOrStxs: Uint8Array | Uint8Array[]) => {\n        this.transactionLogger.logRawTransaction(stxOrStxs)\n        return target[property].call(receiver, stxOrStxs)\n      }\n    }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return (target as any)[property]\n  }\n}\n"],"mappings":";;;;;;;;;AAUA,IAAa,oBAAb,MAA+B;CAC7B,AAAQ,sBAAgC,EAAE;CAC1C,AAAQ;CAER,AAAQ,SAAS,MAAkB;EACjC,MAAM,UAAU,wBAAwB,KAAK;AAC7C,MAAI,QAAQ,IAAI,aAAa,KAAK,yBAAyB,OAAO,EAAE,EAClE,MAAK,wBAAwB,QAAQ,IAAI;AAE3C,OAAK,oBAAoB,KAAK,QAAQ,IAAI,MAAM,CAAC;;;;;CAMnD,IAAI,qBAAyC;AAC3C,SAAO,KAAK;;;;;CAMd,QAAQ;AACN,OAAK,sBAAsB,EAAE;;;;;CAM/B,kBAAkB,oBAA+C;AAC/D,MAAI,MAAM,QAAQ,mBAAmB,CACnC,oBAAmB,SAAS,SAAS,KAAK,SAAS,KAAK,CAAC;MAEzD,MAAK,SAAS,mBAAmB;;;;;;;CASrC,QAAQ,OAAiC;AACvC,SAAO,IAAI,MAAmB,OAAO,IAAI,0CAA0C,KAAK,CAAC;;;CAI3F,MAAM,eAAe,SAAwB;AAC3C,MAAI,KAAK,oBAAoB,WAAW,EAAG;EAC3C,MAAM,WAAW,KAAK,oBAAoB,KAAK,oBAAoB,SAAS;AAC5E,QAAM,uBAAuB,YAAY;AACvC,OAAI;AACF,UAAM,QAAQ,sBAAsB,SAAS;YACtC,GAAG;AAGV,QAAI,KAAK,uBAAuB;AAC9B,WAAM,QAAQ,YAAY,KAAK,sBAAsB;AACrD,YAAO,WAAW,CAAC,MACjB,wDAAwD,KAAK,sBAAsB,6CAA6C,SAAS,kBAC1I;UAED,OAAM;;IAGV;;;AAIN,IAAM,4CAAN,MAAqF;CACnF,AAAQ;CAER,YAAY,mBAAsC;AAChD,OAAK,oBAAoB;;CAI3B,IAAI,QAAqB,UAA2B,UAAe;AACjE,MAAI,aAAa,qBACf,SAAQ,cAAyC;AAC/C,QAAK,kBAAkB,kBAAkB,UAAU;AACnD,UAAO,OAAO,UAAU,KAAK,UAAU,UAAU;;AAIrD,SAAQ,OAAe"}

package/transact/index.d.ts

@@ -0,0 +1,17 @@
+import { AccessReference, AppCallTransactionFields, BoxReference, HoldingReference, LocalsReference, OnApplicationComplete, StateSchema, validateAppCallTransaction } from "../packages/transact/src/transactions/app-call.js";
+import { AssetConfigTransactionFields, validateAssetConfigTransaction } from "../packages/transact/src/transactions/asset-config.js";
+import { AssetFreezeTransactionFields, validateAssetFreezeTransaction } from "../packages/transact/src/transactions/asset-freeze.js";
+import { AssetTransferTransactionFields, validateAssetTransferTransaction } from "../packages/transact/src/transactions/asset-transfer.js";
+import { HeartbeatProof, HeartbeatTransactionFields } from "../packages/transact/src/transactions/heartbeat.js";
+import { KeyRegistrationTransactionFields, validateKeyRegistrationTransaction } from "../packages/transact/src/transactions/key-registration.js";
+import { PaymentTransactionFields } from "../packages/transact/src/transactions/payment.js";
+import { FalconSignatureStruct, FalconVerifier, HashFactory, MerkleArrayProof, MerkleSignatureVerifier, Participant, Reveal, SigslotCommit, StateProof, StateProofMessage, StateProofTransactionFields } from "../packages/transact/src/transactions/state-proof.js";
+import { TransactionType } from "../packages/transact/src/transactions/transaction-type.js";
+import { Transaction, TransactionParams, assignFee, calculateFee, decodeTransaction, decodeTransactions, encodeTransaction, encodeTransactionRaw, encodeTransactions, estimateTransactionSize, getEncodedTransactionType, groupTransactions, transactionCodec } from "../packages/transact/src/transactions/transaction.js";
+import { LogicSignature, MultisigSignature, MultisigSubsignature, SignedTransaction, decodeSignedTransaction, decodeSignedTransactions, encodeSignedTransaction, encodeSignedTransactions } from "../packages/transact/src/transactions/signed-transaction.js";
+import { SignedTransactionMeta } from "../packages/transact/src/transactions/signed-transaction-meta.js";
+import { TransactionParamsMeta, transactionParamsCodec } from "../packages/transact/src/transactions/transaction-meta.js";
+import { MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG, MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG, MULTISIG_MERGE_MISMATCH_ERROR_MSG, MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG, MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG, MULTISIG_NO_MUTATE_ERROR_MSG, MULTISIG_SIGNATURE_LENGTH_ERROR_MSG, MULTISIG_USE_PARTIAL_SIGN_ERROR_MSG, MultisigAccount, MultisigMetadata, addressFromMultisigPreImg, addressFromMultisigPreImgAddrs, addressFromMultisigSignature, appendSignRawMultisigSignature, applyMultisigSubsignature, createMultisigTransaction, decodeMultiSignature, mergeMultisigTransactions, mergeMultisignatures, multisigAddress, newMultisigSignature, participantsFromMultisigSignature } from "../packages/transact/src/multisig.js";
+import { DelegatedLsigSigner, LogicSigAccount, ProgramDataSigner, decodeLogicSignature, sanityCheckProgram } from "../packages/transact/src/logicsig.js";
+import { AddressWithDelegatedLsigSigner, AddressWithMxBytesSigner, AddressWithProgramDataSigner, AddressWithSigners, AddressWithTransactionSigner, MxBytesSigner, SendingAddress, TransactionSigner, generateAddressWithSigners, makeEmptyTransactionSigner } from "../packages/transact/src/signer.js";
+export { AccessReference, AddressWithDelegatedLsigSigner, AddressWithMxBytesSigner, AddressWithProgramDataSigner, AddressWithSigners, AddressWithTransactionSigner, AppCallTransactionFields, AssetConfigTransactionFields, AssetFreezeTransactionFields, AssetTransferTransactionFields, BoxReference, DelegatedLsigSigner, FalconSignatureStruct, FalconVerifier, HashFactory, HeartbeatProof, HeartbeatTransactionFields, HoldingReference, KeyRegistrationTransactionFields, LocalsReference, LogicSigAccount, LogicSignature, MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG, MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG, MULTISIG_MERGE_MISMATCH_ERROR_MSG, MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG, MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG, MULTISIG_NO_MUTATE_ERROR_MSG, MULTISIG_SIGNATURE_LENGTH_ERROR_MSG, MULTISIG_USE_PARTIAL_SIGN_ERROR_MSG, MerkleArrayProof, MerkleSignatureVerifier, MultisigAccount, MultisigMetadata, MultisigSignature, MultisigSubsignature, MxBytesSigner, OnApplicationComplete, Participant, PaymentTransactionFields, ProgramDataSigner, Reveal, SendingAddress, SignedTransaction, SignedTransactionMeta, SigslotCommit, StateProof, StateProofMessage, StateProofTransactionFields, StateSchema, Transaction, TransactionParams, TransactionParamsMeta, TransactionSigner, TransactionType, addressFromMultisigPreImg, addressFromMultisigPreImgAddrs, addressFromMultisigSignature, appendSignRawMultisigSignature, applyMultisigSubsignature, assignFee, calculateFee, createMultisigTransaction, decodeLogicSignature, decodeMultiSignature, decodeSignedTransaction, decodeSignedTransactions, decodeTransaction, decodeTransactions, encodeSignedTransaction, encodeSignedTransactions, encodeTransaction, encodeTransactionRaw, encodeTransactions, estimateTransactionSize, generateAddressWithSigners, getEncodedTransactionType, groupTransactions, makeEmptyTransactionSigner, mergeMultisigTransactions, mergeMultisignatures, multisigAddress, newMultisigSignature, participantsFromMultisigSignature, sanityCheckProgram, transactionCodec, transactionParamsCodec, validateAppCallTransaction, validateAssetConfigTransaction, validateAssetFreezeTransaction, validateAssetTransferTransaction, validateKeyRegistrationTransaction };

package/transact/index.js

@@ -0,0 +1,66 @@
+const require_app_call = require('../packages/transact/src/transactions/app-call.js');
+const require_asset_config = require('../packages/transact/src/transactions/asset-config.js');
+const require_asset_freeze = require('../packages/transact/src/transactions/asset-freeze.js');
+const require_asset_transfer = require('../packages/transact/src/transactions/asset-transfer.js');
+const require_key_registration = require('../packages/transact/src/transactions/key-registration.js');
+const require_transaction_type = require('../packages/transact/src/transactions/transaction-type.js');
+const require_transaction_meta = require('../packages/transact/src/transactions/transaction-meta.js');
+const require_transaction = require('../packages/transact/src/transactions/transaction.js');
+const require_signed_transaction_meta = require('../packages/transact/src/transactions/signed-transaction-meta.js');
+const require_signed_transaction = require('../packages/transact/src/transactions/signed-transaction.js');
+const require_signer = require('../packages/transact/src/signer.js');
+const require_multisig = require('../packages/transact/src/multisig.js');
+const require_logicsig = require('../packages/transact/src/logicsig.js');
+
+exports.LogicSigAccount = require_logicsig.LogicSigAccount;
+exports.MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG = require_multisig.MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG;
+exports.MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG = require_multisig.MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG;
+exports.MULTISIG_MERGE_MISMATCH_ERROR_MSG = require_multisig.MULTISIG_MERGE_MISMATCH_ERROR_MSG;
+exports.MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG = require_multisig.MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG;
+exports.MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG = require_multisig.MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG;
+exports.MULTISIG_NO_MUTATE_ERROR_MSG = require_multisig.MULTISIG_NO_MUTATE_ERROR_MSG;
+exports.MULTISIG_SIGNATURE_LENGTH_ERROR_MSG = require_multisig.MULTISIG_SIGNATURE_LENGTH_ERROR_MSG;
+exports.MULTISIG_USE_PARTIAL_SIGN_ERROR_MSG = require_multisig.MULTISIG_USE_PARTIAL_SIGN_ERROR_MSG;
+exports.MultisigAccount = require_multisig.MultisigAccount;
+exports.OnApplicationComplete = require_app_call.OnApplicationComplete;
+exports.SignedTransactionMeta = require_signed_transaction_meta.SignedTransactionMeta;
+exports.Transaction = require_transaction.Transaction;
+exports.TransactionParamsMeta = require_transaction_meta.TransactionParamsMeta;
+exports.TransactionType = require_transaction_type.TransactionType;
+exports.addressFromMultisigPreImg = require_multisig.addressFromMultisigPreImg;
+exports.addressFromMultisigPreImgAddrs = require_multisig.addressFromMultisigPreImgAddrs;
+exports.addressFromMultisigSignature = require_multisig.addressFromMultisigSignature;
+exports.appendSignRawMultisigSignature = require_multisig.appendSignRawMultisigSignature;
+exports.applyMultisigSubsignature = require_multisig.applyMultisigSubsignature;
+exports.assignFee = require_transaction.assignFee;
+exports.calculateFee = require_transaction.calculateFee;
+exports.createMultisigTransaction = require_multisig.createMultisigTransaction;
+exports.decodeLogicSignature = require_logicsig.decodeLogicSignature;
+exports.decodeMultiSignature = require_multisig.decodeMultiSignature;
+exports.decodeSignedTransaction = require_signed_transaction.decodeSignedTransaction;
+exports.decodeSignedTransactions = require_signed_transaction.decodeSignedTransactions;
+exports.decodeTransaction = require_transaction.decodeTransaction;
+exports.decodeTransactions = require_transaction.decodeTransactions;
+exports.encodeSignedTransaction = require_signed_transaction.encodeSignedTransaction;
+exports.encodeSignedTransactions = require_signed_transaction.encodeSignedTransactions;
+exports.encodeTransaction = require_transaction.encodeTransaction;
+exports.encodeTransactionRaw = require_transaction.encodeTransactionRaw;
+exports.encodeTransactions = require_transaction.encodeTransactions;
+exports.estimateTransactionSize = require_transaction.estimateTransactionSize;
+exports.generateAddressWithSigners = require_signer.generateAddressWithSigners;
+exports.getEncodedTransactionType = require_transaction.getEncodedTransactionType;
+exports.groupTransactions = require_transaction.groupTransactions;
+exports.makeEmptyTransactionSigner = require_signer.makeEmptyTransactionSigner;
+exports.mergeMultisigTransactions = require_multisig.mergeMultisigTransactions;
+exports.mergeMultisignatures = require_multisig.mergeMultisignatures;
+exports.multisigAddress = require_multisig.multisigAddress;
+exports.newMultisigSignature = require_multisig.newMultisigSignature;
+exports.participantsFromMultisigSignature = require_multisig.participantsFromMultisigSignature;
+exports.sanityCheckProgram = require_logicsig.sanityCheckProgram;
+exports.transactionCodec = require_transaction.transactionCodec;
+exports.transactionParamsCodec = require_transaction_meta.transactionParamsCodec;
+exports.validateAppCallTransaction = require_app_call.validateAppCallTransaction;
+exports.validateAssetConfigTransaction = require_asset_config.validateAssetConfigTransaction;
+exports.validateAssetFreezeTransaction = require_asset_freeze.validateAssetFreezeTransaction;
+exports.validateAssetTransferTransaction = require_asset_transfer.validateAssetTransferTransaction;
+exports.validateKeyRegistrationTransaction = require_key_registration.validateKeyRegistrationTransaction;

package/transact/index.mjs

@@ -0,0 +1,15 @@
+import { OnApplicationComplete, validateAppCallTransaction } from "../packages/transact/src/transactions/app-call.mjs";
+import { validateAssetConfigTransaction } from "../packages/transact/src/transactions/asset-config.mjs";
+import { validateAssetFreezeTransaction } from "../packages/transact/src/transactions/asset-freeze.mjs";
+import { validateAssetTransferTransaction } from "../packages/transact/src/transactions/asset-transfer.mjs";
+import { validateKeyRegistrationTransaction } from "../packages/transact/src/transactions/key-registration.mjs";
+import { TransactionType } from "../packages/transact/src/transactions/transaction-type.mjs";
+import { TransactionParamsMeta, transactionParamsCodec } from "../packages/transact/src/transactions/transaction-meta.mjs";
+import { Transaction, assignFee, calculateFee, decodeTransaction, decodeTransactions, encodeTransaction, encodeTransactionRaw, encodeTransactions, estimateTransactionSize, getEncodedTransactionType, groupTransactions, transactionCodec } from "../packages/transact/src/transactions/transaction.mjs";
+import { SignedTransactionMeta } from "../packages/transact/src/transactions/signed-transaction-meta.mjs";
+import { decodeSignedTransaction, decodeSignedTransactions, encodeSignedTransaction, encodeSignedTransactions } from "../packages/transact/src/transactions/signed-transaction.mjs";
+import { generateAddressWithSigners, makeEmptyTransactionSigner } from "../packages/transact/src/signer.mjs";
+import { MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG, MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG, MULTISIG_MERGE_MISMATCH_ERROR_MSG, MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG, MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG, MULTISIG_NO_MUTATE_ERROR_MSG, MULTISIG_SIGNATURE_LENGTH_ERROR_MSG, MULTISIG_USE_PARTIAL_SIGN_ERROR_MSG, MultisigAccount, addressFromMultisigPreImg, addressFromMultisigPreImgAddrs, addressFromMultisigSignature, appendSignRawMultisigSignature, applyMultisigSubsignature, createMultisigTransaction, decodeMultiSignature, mergeMultisigTransactions, mergeMultisignatures, multisigAddress, newMultisigSignature, participantsFromMultisigSignature } from "../packages/transact/src/multisig.mjs";
+import { LogicSigAccount, decodeLogicSignature, sanityCheckProgram } from "../packages/transact/src/logicsig.mjs";
+
+export { LogicSigAccount, MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG, MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG, MULTISIG_MERGE_MISMATCH_ERROR_MSG, MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG, MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG, MULTISIG_NO_MUTATE_ERROR_MSG, MULTISIG_SIGNATURE_LENGTH_ERROR_MSG, MULTISIG_USE_PARTIAL_SIGN_ERROR_MSG, MultisigAccount, OnApplicationComplete, SignedTransactionMeta, Transaction, TransactionParamsMeta, TransactionType, addressFromMultisigPreImg, addressFromMultisigPreImgAddrs, addressFromMultisigSignature, appendSignRawMultisigSignature, applyMultisigSubsignature, assignFee, calculateFee, createMultisigTransaction, decodeLogicSignature, decodeMultiSignature, decodeSignedTransaction, decodeSignedTransactions, decodeTransaction, decodeTransactions, encodeSignedTransaction, encodeSignedTransactions, encodeTransaction, encodeTransactionRaw, encodeTransactions, estimateTransactionSize, generateAddressWithSigners, getEncodedTransactionType, groupTransactions, makeEmptyTransactionSigner, mergeMultisigTransactions, mergeMultisignatures, multisigAddress, newMultisigSignature, participantsFromMultisigSignature, sanityCheckProgram, transactionCodec, transactionParamsCodec, validateAppCallTransaction, validateAssetConfigTransaction, validateAssetFreezeTransaction, validateAssetTransferTransaction, validateKeyRegistrationTransaction };

package/transaction/perform-transaction-composer-simulate.d.ts

@@ -0,0 +1,20 @@
+import { SimulateResponse } from "../packages/algod_client/src/models/simulate-response.js";
+import { RawSimulateOptions, TransactionComposer } from "../types/composer.js";
+
+//#region src/transaction/perform-transaction-composer-simulate.d.ts
+
+/**
+ * @deprecated Use `composer.simulate` with
+ *  - `allowEmptySignatures` flag set to true
+ *  - `resultOnFailure` flag set to true
+ *
+ * Performs a simulation of the transactions loaded into the given TransactionComposer.
+ * Uses empty transaction signers for all transactions.
+ *
+ * @param composer The TransactionComposer with transaction(s) loaded.
+ * @returns The simulation result, which includes various details about how the transactions would be processed.
+ */
+declare function performTransactionComposerSimulate(composer: TransactionComposer, options?: RawSimulateOptions): Promise<SimulateResponse>;
+//#endregion
+export { performTransactionComposerSimulate };
+//# sourceMappingURL=perform-transaction-composer-simulate.d.ts.map

package/transaction/perform-transaction-composer-simulate.js

@@ -0,0 +1,33 @@
+
+//#region src/transaction/perform-transaction-composer-simulate.ts
+/**
+* @deprecated Use `composer.simulate` with
+*  - `allowEmptySignatures` flag set to true
+*  - `resultOnFailure` flag set to true
+*
+* Performs a simulation of the transactions loaded into the given TransactionComposer.
+* Uses empty transaction signers for all transactions.
+*
+* @param composer The TransactionComposer with transaction(s) loaded.
+* @returns The simulation result, which includes various details about how the transactions would be processed.
+*/
+async function performTransactionComposerSimulate(composer, options) {
+	const simulateOptions = { ...options ?? {
+		skipSignatures: true,
+		allowEmptySignatures: true,
+		fixSigners: true,
+		allowMoreLogging: true,
+		execTraceConfig: {
+			enable: true,
+			scratchChange: true,
+			stackChange: true,
+			stateChange: true
+		},
+		resultOnFailure: true
+	} };
+	return (await composer.simulate(simulateOptions)).simulateResponse;
+}
+
+//#endregion
+exports.performTransactionComposerSimulate = performTransactionComposerSimulate;
+//# sourceMappingURL=perform-transaction-composer-simulate.js.map

package/transaction/perform-transaction-composer-simulate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"perform-transaction-composer-simulate.js","names":[],"sources":["../../src/transaction/perform-transaction-composer-simulate.ts"],"sourcesContent":["import { RawSimulateOptions, SimulateOptions, TransactionComposer } from '../types/composer'\n\n/**\n * @deprecated Use `composer.simulate` with\n *  - `allowEmptySignatures` flag set to true\n *  - `resultOnFailure` flag set to true\n *\n * Performs a simulation of the transactions loaded into the given TransactionComposer.\n * Uses empty transaction signers for all transactions.\n *\n * @param composer The TransactionComposer with transaction(s) loaded.\n * @returns The simulation result, which includes various details about how the transactions would be processed.\n */\nexport async function performTransactionComposerSimulate(composer: TransactionComposer, options?: RawSimulateOptions) {\n  const simulateOptions = {\n    ...(options ?? {\n      skipSignatures: true,\n      allowEmptySignatures: true,\n      fixSigners: true,\n      allowMoreLogging: true,\n      execTraceConfig: {\n        enable: true,\n        scratchChange: true,\n        stackChange: true,\n        stateChange: true,\n      },\n      resultOnFailure: true,\n    }),\n  } satisfies SimulateOptions\n\n  const simulateResult = await composer.simulate(simulateOptions)\n  return simulateResult.simulateResponse\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,eAAsB,mCAAmC,UAA+B,SAA8B;CACpH,MAAM,kBAAkB,EACtB,GAAI,WAAW;EACb,gBAAgB;EAChB,sBAAsB;EACtB,YAAY;EACZ,kBAAkB;EAClB,iBAAiB;GACf,QAAQ;GACR,eAAe;GACf,aAAa;GACb,aAAa;GACd;EACD,iBAAiB;EAClB,EACF;AAGD,SADuB,MAAM,SAAS,SAAS,gBAAgB,EACzC"}

package/transaction/perform-transaction-composer-simulate.mjs

@@ -0,0 +1,32 @@
+//#region src/transaction/perform-transaction-composer-simulate.ts
+/**
+* @deprecated Use `composer.simulate` with
+*  - `allowEmptySignatures` flag set to true
+*  - `resultOnFailure` flag set to true
+*
+* Performs a simulation of the transactions loaded into the given TransactionComposer.
+* Uses empty transaction signers for all transactions.
+*
+* @param composer The TransactionComposer with transaction(s) loaded.
+* @returns The simulation result, which includes various details about how the transactions would be processed.
+*/
+async function performTransactionComposerSimulate(composer, options) {
+	const simulateOptions = { ...options ?? {
+		skipSignatures: true,
+		allowEmptySignatures: true,
+		fixSigners: true,
+		allowMoreLogging: true,
+		execTraceConfig: {
+			enable: true,
+			scratchChange: true,
+			stackChange: true,
+			stateChange: true
+		},
+		resultOnFailure: true
+	} };
+	return (await composer.simulate(simulateOptions)).simulateResponse;
+}
+
+//#endregion
+export { performTransactionComposerSimulate };
+//# sourceMappingURL=perform-transaction-composer-simulate.mjs.map

package/transaction/perform-transaction-composer-simulate.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"perform-transaction-composer-simulate.mjs","names":[],"sources":["../../src/transaction/perform-transaction-composer-simulate.ts"],"sourcesContent":["import { RawSimulateOptions, SimulateOptions, TransactionComposer } from '../types/composer'\n\n/**\n * @deprecated Use `composer.simulate` with\n *  - `allowEmptySignatures` flag set to true\n *  - `resultOnFailure` flag set to true\n *\n * Performs a simulation of the transactions loaded into the given TransactionComposer.\n * Uses empty transaction signers for all transactions.\n *\n * @param composer The TransactionComposer with transaction(s) loaded.\n * @returns The simulation result, which includes various details about how the transactions would be processed.\n */\nexport async function performTransactionComposerSimulate(composer: TransactionComposer, options?: RawSimulateOptions) {\n  const simulateOptions = {\n    ...(options ?? {\n      skipSignatures: true,\n      allowEmptySignatures: true,\n      fixSigners: true,\n      allowMoreLogging: true,\n      execTraceConfig: {\n        enable: true,\n        scratchChange: true,\n        stackChange: true,\n        stateChange: true,\n      },\n      resultOnFailure: true,\n    }),\n  } satisfies SimulateOptions\n\n  const simulateResult = await composer.simulate(simulateOptions)\n  return simulateResult.simulateResponse\n}\n"],"mappings":";;;;;;;;;;;;AAaA,eAAsB,mCAAmC,UAA+B,SAA8B;CACpH,MAAM,kBAAkB,EACtB,GAAI,WAAW;EACb,gBAAgB;EAChB,sBAAsB;EACtB,YAAY;EACZ,kBAAkB;EAClB,iBAAiB;GACf,QAAQ;GACR,eAAe;GACf,aAAa;GACb,aAAa;GACd;EACD,iBAAiB;EAClB,EACF;AAGD,SADuB,MAAM,SAAS,SAAS,gBAAgB,EACzC"}