@algorandfoundation/algokit-utils 10.0.0-alpha.31 → 10.0.0-alpha.32

package/testing/types.d.ts

@@ -0,0 +1,156 @@
+import { Address } from "../packages/common/src/address.js";
+import { Transaction } from "../packages/transact/src/transactions/transaction.js";
+import { MultisigAccount } from "../packages/transact/src/multisig.js";
+import { LogicSigAccount } from "../packages/transact/src/logicsig.js";
+import { AddressWithSigners, AddressWithTransactionSigner } from "../packages/transact/src/signer.js";
+import { AlgodClient } from "../packages/algod_client/src/client.js";
+import { AlgoAmount } from "../amount.js";
+import { TransactionResponse } from "../packages/indexer_client/src/models/transaction-response.js";
+import { IndexerClient } from "../packages/indexer_client/src/client.js";
+import { KmdClient } from "../packages/kmd_client/src/client.js";
+import { AlgoConfig } from "../network-client.js";
+import { AlgorandClient } from "../algorand-client.js";
+import { TestLogger } from "./test-logger.js";
+import { TransactionLogger } from "./transaction-logger.js";
+
+//#region src/testing/types.d.ts
+/**
+ * Test automation context.
+ */
+interface AlgorandTestAutomationContext {
+  /** An AlgorandClient instance loaded with the current context, including testAccount and any generated accounts loaded as signers */
+  algorand: AlgorandClient;
+  /** Algod client instance that will log transactions in `transactionLogger` */
+  algod: AlgodClient;
+  /** Indexer client instance */
+  indexer: IndexerClient;
+  /** KMD client instance */
+  kmd: KmdClient;
+  /** Transaction logger that will log transaction IDs for all transactions issued by `algod` */
+  transactionLogger: TransactionLogger;
+  /** Default, funded test account that is ephemerally created */
+  testAccount: Address & AddressWithSigners;
+  /** Generate and fund an additional ephemerally created account */
+  generateAccount: (params: GetTestAccountParams) => Promise<Address & AddressWithSigners>;
+  /** Wait for the indexer to catch up with all transactions logged by `transactionLogger` */
+  waitForIndexer: () => Promise<void>;
+  /** Wait for the indexer to catch up with the given transaction ID */
+  waitForIndexerTransaction: (transactionId: string) => Promise<TransactionResponse>;
+}
+/**
+ * Parameters for the `getTestAccount` function.
+ */
+interface GetTestAccountParams {
+  /** Initial funds to ensure the account has */
+  initialFunds: AlgoAmount;
+  /** Whether to suppress the log (which includes a mnemonic) or not (default: do not suppress the log) */
+  suppressLog?: boolean;
+  /** Optional override for how to get a test account; this allows you to retrieve accounts from a known or cached list of accounts. */
+  accountGetter?: (algorand: AlgorandClient) => Promise<Address & AddressWithSigners>;
+}
+/** Configuration for creating an Algorand testing fixture. */
+interface AlgorandFixtureConfig extends Partial<AlgoConfig> {
+  /** An optional algod client, if not specified then it will create one against `algodConfig` (if present) then environment variables defined network (if present) or default LocalNet. */
+  algod?: AlgodClient;
+  /** An optional indexer client, if not specified then it will create one against `indexerConfig` (if present) then environment variables defined network (if present) or default LocalNet. */
+  indexer?: IndexerClient;
+  /** An optional kmd client, if not specified then it will create one against `kmdConfig` (if present) then environment variables defined network (if present) or default LocalNet. */
+  kmd?: KmdClient;
+  /** The amount of funds to allocate to the default testing account, if not specified then it will get 10 ALGO. */
+  testAccountFunding?: AlgoAmount;
+  /** Optional override for how to get an account; this allows you to retrieve accounts from a known or cached list of accounts. */
+  accountGetter?: (algorand: AlgorandClient) => Promise<Address & AddressWithSigners>;
+}
+/** An Algorand automated testing fixture */
+interface AlgorandFixture {
+  /**
+   * Retrieve the current context.
+   * Useful with destructuring.
+   *
+   * If you haven't called `newScope` then this will throw an error.
+   * @example
+   * ```typescript
+   * test('My test', () => {
+   *     const {algod, indexer, testAccount, ...} = fixture.context
+   * })
+   * ```
+   */
+  get context(): AlgorandTestAutomationContext;
+  /**
+   * Retrieve an `AlgorandClient` loaded with the current context, including testAccount and any generated accounts loaded as signers.
+   */
+  get algorand(): AlgorandClient;
+  /**
+   * @deprecated Use newScope instead.
+   * Testing framework agnostic handler method to run before each test to prepare the `context` for that test with per test isolation.
+   */
+  beforeEach: () => Promise<void>;
+  /**
+   * Creates a new isolated fixture scope (clean transaction logger, AlgorandClient, testAccount, etc.).
+   *
+   * You can call this from any testing framework specific hook method to control when you want a new scope.
+   *
+   * @example Jest / vitest - per test isolation (beforeEach)
+   * ```typescript
+   * describe('MY MODULE', () => {
+   *   const fixture = algorandFixture()
+   *   beforeEach(fixture.newScope)
+   *
+   *   test('MY TEST', async () => {
+   *     const { algorand, testAccount } = fixture.context
+   *
+   *     // Test stuff!
+   *   })
+   * })
+   * ```
+   *
+   * @example Jest / vitest - test suite isolation (beforeAll)
+   * ```typescript
+   * describe('MY MODULE', () => {
+   *   const fixture = algorandFixture()
+   *   beforeAll(fixture.newScope)
+   *
+   *   test('test1', async () => {
+   *     const { algorand, testAccount } = fixture.context
+   *
+   *     // Test stuff!
+   *   })
+   *   test('test2', async () => {
+   *     const { algorand, testAccount } = fixture.context
+   *     // algorand and testAccount are the same as in test1
+   *   })
+   * })
+   * ```
+   *
+   */
+  newScope: () => Promise<void>;
+}
+/** Configuration for preparing a captured log snapshot.
+ * This helps ensure that the provided configuration items won't appear
+ *  with random values in the log snapshot, but rather will get substituted with predictable ids.
+ */
+interface LogSnapshotConfig {
+  /** Any transaction IDs or transactions to replace the ID for predictably */
+  transactions?: (string | Transaction)[];
+  /** Any accounts/addresses to replace the address for predictably */
+  accounts?: (string | Address | LogicSigAccount | MultisigAccount | AddressWithTransactionSigner)[];
+  /** Any app IDs to replace predictably */
+  apps?: (string | number | bigint)[];
+  /** Optional filter predicate to filter out logs */
+  filterPredicate?: (log: string) => boolean;
+}
+interface AlgoKitLogCaptureFixture {
+  /** The test logger instance for the current test */
+  get testLogger(): TestLogger;
+  /**
+   * Testing framework agnostic handler method to run before each test to prepare the `testLogger` for that test.
+   */
+  beforeEach: () => void;
+  /**
+   * Testing framework agnostic handler method to run after each test to reset the logger.
+   */
+  afterEach: () => void;
+}
+//#endregion
+export { AlgoKitLogCaptureFixture, AlgorandFixture, AlgorandFixtureConfig, AlgorandTestAutomationContext, GetTestAccountParams, LogSnapshotConfig };
+//# sourceMappingURL=types.d.ts.map

package/transaction/index.d.ts

@@ -0,0 +1,4 @@
+import { performTransactionComposerSimulate } from "./perform-transaction-composer-simulate.js";
+import { AdditionalTransactionComposerContext, Arc2TransactionNote, ConfirmedTransactionResult, ConfirmedTransactionResults, SendParams, SendSingleTransactionResult, SendTransactionComposerResults, SendTransactionFrom, SendTransactionParams, SendTransactionResult, SendTransactionResults, TransactionComposerToSend, TransactionGroupToSend, TransactionNote, TransactionNoteData, TransactionToSign } from "./types.js";
+import { TransactionWithSigner, encodeLease, populateAppCallResources, prepareGroupForSending, sendTransactionComposer, waitForConfirmation } from "./transaction.js";
+export { AdditionalTransactionComposerContext, Arc2TransactionNote, ConfirmedTransactionResult, ConfirmedTransactionResults, SendParams, SendSingleTransactionResult, SendTransactionComposerResults, SendTransactionFrom, SendTransactionParams, SendTransactionResult, SendTransactionResults, TransactionComposerToSend, TransactionGroupToSend, TransactionNote, TransactionNoteData, TransactionToSign, TransactionWithSigner, encodeLease, performTransactionComposerSimulate, populateAppCallResources, prepareGroupForSending, sendTransactionComposer, waitForConfirmation };

package/transaction/index.js

@@ -0,0 +1,9 @@
+const require_perform_transaction_composer_simulate = require('./perform-transaction-composer-simulate.js');
+const require_transaction = require('./transaction.js');
+
+exports.encodeLease = require_transaction.encodeLease;
+exports.performTransactionComposerSimulate = require_perform_transaction_composer_simulate.performTransactionComposerSimulate;
+exports.populateAppCallResources = require_transaction.populateAppCallResources;
+exports.prepareGroupForSending = require_transaction.prepareGroupForSending;
+exports.sendTransactionComposer = require_transaction.sendTransactionComposer;
+exports.waitForConfirmation = require_transaction.waitForConfirmation;

package/transaction/index.mjs

@@ -0,0 +1,4 @@
+import { performTransactionComposerSimulate } from "./perform-transaction-composer-simulate.mjs";
+import { encodeLease, populateAppCallResources, prepareGroupForSending, sendTransactionComposer, waitForConfirmation } from "./transaction.mjs";
+
+export { encodeLease, performTransactionComposerSimulate, populateAppCallResources, prepareGroupForSending, sendTransactionComposer, waitForConfirmation };

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

@@ -1,5 +1,5 @@
 import { SimulateResponse } from "../packages/algod_client/src/models/simulate-response.js";
-import { RawSimulateOptions, TransactionComposer } from "../types/composer.js";
+import { RawSimulateOptions, TransactionComposer } from "../composer.js";
 
 //#region src/transaction/perform-transaction-composer-simulate.d.ts
 

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

@@ -1 +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"}
+{"version":3,"file":"perform-transaction-composer-simulate.js","names":[],"sources":["../../src/transaction/perform-transaction-composer-simulate.ts"],"sourcesContent":["import { RawSimulateOptions, SimulateOptions, TransactionComposer } from '../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.map

@@ -1 +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"}
+{"version":3,"file":"perform-transaction-composer-simulate.mjs","names":[],"sources":["../../src/transaction/perform-transaction-composer-simulate.ts"],"sourcesContent":["import { RawSimulateOptions, SimulateOptions, TransactionComposer } from '../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/transaction.d.ts

@@ -2,8 +2,8 @@ import { Transaction } from "../packages/transact/src/transactions/transaction.j
 import { TransactionSigner } from "../packages/transact/src/signer.js";
 import { PendingTransactionResponse } from "../packages/algod_client/src/models/pending-transaction-response.js";
 import { AlgodClient } from "../packages/algod_client/src/client.js";
-import { AdditionalTransactionComposerContext, SendParams, SendTransactionComposerResults, TransactionComposerToSend } from "../types/transaction.js";
-import { TransactionComposer } from "../types/composer.js";
+import { AdditionalTransactionComposerContext, SendParams, SendTransactionComposerResults, TransactionComposerToSend } from "./types.js";
+import { TransactionComposer } from "../composer.js";
 
 //#region src/transaction/transaction.d.ts
 /** Represents an unsigned transactions and a signer that can authorize that transaction. */

package/transaction/transaction.js.map

@@ -1 +1 @@
-{"version":3,"file":"transaction.js","names":["e: any","toNumber"],"sources":["../../src/transaction/transaction.ts"],"sourcesContent":["import { AlgodClient, PendingTransactionResponse } from '@algorandfoundation/algokit-algod-client'\nimport { Transaction, TransactionSigner } from '@algorandfoundation/algokit-transact'\nimport { TransactionComposer } from '../types/composer'\nimport {\n  AdditionalTransactionComposerContext,\n  SendParams,\n  SendTransactionComposerResults,\n  TransactionComposerToSend,\n} from '../types/transaction'\nimport { toNumber } from '../util'\n\n/** Represents an unsigned transactions and a signer that can authorize that transaction. */\nexport interface TransactionWithSigner {\n  /** An unsigned transaction */\n  txn: Transaction\n  /** A transaction signer that can authorize txn */\n  signer: TransactionSigner\n}\n\n/** Encodes a transaction lease into a 32-byte array ready to be included in an Algorand transaction.\n *\n * @param lease The transaction lease as a string or binary array or null/undefined if there is no lease\n * @returns the transaction lease ready for inclusion in a transaction or `undefined` if there is no lease\n * @throws if the length of the data is > 32 bytes or empty\n * @example algokit.encodeLease('UNIQUE_ID')\n * @example algokit.encodeLease(new Uint8Array([1, 2, 3]))\n */\nexport function encodeLease(lease?: string | Uint8Array): Uint8Array | undefined {\n  if (lease === null || typeof lease === 'undefined') {\n    return undefined\n  } else if (typeof lease === 'object' && lease.constructor === Uint8Array) {\n    if (lease.length === 0 || lease.length > 32) {\n      throw new Error(\n        `Received invalid lease; expected something with length between 1 and 32, but received bytes with length ${lease.length}`,\n      )\n    }\n    if (lease.length === 32) return lease\n    const lease32 = new Uint8Array(32)\n    lease32.set(lease, 0)\n    return lease32\n  } else if (typeof lease === 'string') {\n    if (lease.length === 0 || lease.length > 32) {\n      throw new Error(\n        `Received invalid lease; expected something with length between 1 and 32, but received '${lease}' with length ${lease.length}`,\n      )\n    }\n    const encoder = new TextEncoder()\n    const lease32 = new Uint8Array(32)\n    lease32.set(encoder.encode(lease), 0)\n    return lease32\n  } else {\n    throw new Error(`Unknown lease type received of ${typeof lease}`)\n  }\n}\n\n/**\n * @deprecated Use `composer.build()` directly\n * Take an existing Transaction Composer and return a new one with the required\n * app call resources populated into it\n *\n * @param algod The algod client to use for the simulation\n * @param composer The composer containing the txn group\n * @returns A new composer with the resources populated into the transactions\n *\n * @privateRemarks\n *\n * This entire function will eventually be implemented in simulate upstream in algod. The simulate endpoint will return\n * an array of refference arrays for each transaction, so this eventually will eventually just call simulate and set the\n * reference arrays in the transactions to the reference arrays returned by simulate.\n *\n * See https://github.com/algorand/go-algorand/pull/5684\n *\n */\nexport async function populateAppCallResources(composer: TransactionComposer) {\n  await composer.build()\n  return composer\n}\n\n/**\n * @deprecated Use `composer.setMaxFees()` instead if you need to set max fees for transactions.\n * Use `composer.build()` instead if you need to build transactions with resource population.\n *\n * Take an existing Transaction Composer and return a new one with changes applied to the transactions\n * based on the supplied sendParams to prepare it for sending.\n *\n * @param composer The Transaction Composer containing the txn group\n * @param sendParams The send params for the transaction group\n * @param additionalContext Additional context used to determine how best to change the transactions in the group\n * @returns A new Transaction Composer with the changes applied\n *\n * @privateRemarks\n * Parts of this function will eventually be implemented in algod. Namely:\n * - Simulate will return information on how to populate reference arrays, see https://github.com/algorand/go-algorand/pull/6015\n */\nexport async function prepareGroupForSending(\n  composer: TransactionComposer,\n  sendParams: SendParams,\n  additionalContext?: AdditionalTransactionComposerContext,\n) {\n  const newComposer = composer.clone({\n    coverAppCallInnerTransactionFees: sendParams.coverAppCallInnerTransactionFees ?? false,\n    populateAppCallResources: sendParams.populateAppCallResources ?? true,\n  })\n\n  if (additionalContext?.maxFees) {\n    newComposer.setMaxFees(additionalContext?.maxFees)\n  }\n\n  await newComposer.build()\n\n  return newComposer\n}\n\n/**\n * @deprecated Use `composer.send()` directly\n * Signs and sends transactions that have been collected by an `TransactionComposer`.\n * @param atcSend The parameters controlling the send, including `atc` The `TransactionComposer` and params to control send behaviour\n * @param algod An algod client\n * @returns An object with transaction IDs, transactions, group transaction ID (`groupTransactionId`) if more than 1 transaction sent, and (if `skipWaiting` is `false` or unset) confirmation (`confirmation`)\n */\nexport const sendTransactionComposer = async function (atcSend: TransactionComposerToSend): Promise<SendTransactionComposerResults> {\n  const { transactionComposer: givenComposer, ...executeParams } = atcSend\n\n  return atcSend.transactionComposer.send({\n    ...executeParams,\n  })\n}\n\n/**\n * Wait until the transaction is confirmed or rejected, or until `timeout`\n * number of rounds have passed.\n *\n * @param algod An algod client\n * @param transactionId The transaction ID to wait for\n * @param maxRoundsToWait Maximum number of rounds to wait\n *\n * @return Pending transaction information\n * @throws Throws an error if the transaction is not confirmed or rejected in the next `timeout` rounds\n */\nexport const waitForConfirmation = async function (\n  transactionId: string,\n  maxRoundsToWait: number | bigint,\n  algod: AlgodClient,\n): Promise<PendingTransactionResponse> {\n  if (maxRoundsToWait < 0) {\n    throw new Error(`Invalid timeout, received ${maxRoundsToWait}, expected > 0`)\n  }\n\n  // Get current round\n  const status = await algod.status()\n  if (status === undefined) {\n    throw new Error('Unable to get node status')\n  }\n\n  // Loop for up to `timeout` rounds looking for a confirmed transaction\n  const startRound = BigInt(status.lastRound) + 1n\n  let currentRound = startRound\n  while (currentRound < startRound + BigInt(maxRoundsToWait)) {\n    try {\n      const pendingInfo = await algod.pendingTransactionInformation(transactionId)\n\n      if (pendingInfo !== undefined) {\n        const confirmedRound = pendingInfo.confirmedRound\n        if (confirmedRound && confirmedRound > 0) {\n          return pendingInfo\n        } else {\n          const poolError = pendingInfo.poolError\n          if (poolError != null && poolError.length > 0) {\n            // If there was a pool error, then the transaction has been rejected!\n            throw new Error(`Transaction ${transactionId} was rejected; pool error: ${poolError}`)\n          }\n        }\n      }\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (e: any) {\n      if ('status' in e && e.status === 404) {\n        currentRound++\n        continue\n      }\n    }\n\n    await algod.statusAfterBlock(toNumber(currentRound))\n    currentRound++\n  }\n\n  throw new Error(`Transaction ${transactionId} not confirmed after ${maxRoundsToWait} rounds`)\n}\n"],"mappings":";;;;;;;;;;;AA2BA,SAAgB,YAAY,OAAqD;AAC/E,KAAI,UAAU,QAAQ,OAAO,UAAU,YACrC;UACS,OAAO,UAAU,YAAY,MAAM,gBAAgB,YAAY;AACxE,MAAI,MAAM,WAAW,KAAK,MAAM,SAAS,GACvC,OAAM,IAAI,MACR,2GAA2G,MAAM,SAClH;AAEH,MAAI,MAAM,WAAW,GAAI,QAAO;EAChC,MAAM,UAAU,IAAI,WAAW,GAAG;AAClC,UAAQ,IAAI,OAAO,EAAE;AACrB,SAAO;YACE,OAAO,UAAU,UAAU;AACpC,MAAI,MAAM,WAAW,KAAK,MAAM,SAAS,GACvC,OAAM,IAAI,MACR,0FAA0F,MAAM,gBAAgB,MAAM,SACvH;EAEH,MAAM,UAAU,IAAI,aAAa;EACjC,MAAM,UAAU,IAAI,WAAW,GAAG;AAClC,UAAQ,IAAI,QAAQ,OAAO,MAAM,EAAE,EAAE;AACrC,SAAO;OAEP,OAAM,IAAI,MAAM,kCAAkC,OAAO,QAAQ;;;;;;;;;;;;;;;;;;;;AAsBrE,eAAsB,yBAAyB,UAA+B;AAC5E,OAAM,SAAS,OAAO;AACtB,QAAO;;;;;;;;;;;;;;;;;;AAmBT,eAAsB,uBACpB,UACA,YACA,mBACA;CACA,MAAM,cAAc,SAAS,MAAM;EACjC,kCAAkC,WAAW,oCAAoC;EACjF,0BAA0B,WAAW,4BAA4B;EAClE,CAAC;AAEF,KAAI,mBAAmB,QACrB,aAAY,WAAW,mBAAmB,QAAQ;AAGpD,OAAM,YAAY,OAAO;AAEzB,QAAO;;;;;;;;;AAUT,MAAa,0BAA0B,eAAgB,SAA6E;CAClI,MAAM,EAAE,qBAAqB,eAAe,GAAG,kBAAkB;AAEjE,QAAO,QAAQ,oBAAoB,KAAK,EACtC,GAAG,eACJ,CAAC;;;;;;;;;;;;;AAcJ,MAAa,sBAAsB,eACjC,eACA,iBACA,OACqC;AACrC,KAAI,kBAAkB,EACpB,OAAM,IAAI,MAAM,6BAA6B,gBAAgB,gBAAgB;CAI/E,MAAM,SAAS,MAAM,MAAM,QAAQ;AACnC,KAAI,WAAW,OACb,OAAM,IAAI,MAAM,4BAA4B;CAI9C,MAAM,aAAa,OAAO,OAAO,UAAU,GAAG;CAC9C,IAAI,eAAe;AACnB,QAAO,eAAe,aAAa,OAAO,gBAAgB,EAAE;AAC1D,MAAI;GACF,MAAM,cAAc,MAAM,MAAM,8BAA8B,cAAc;AAE5E,OAAI,gBAAgB,QAAW;IAC7B,MAAM,iBAAiB,YAAY;AACnC,QAAI,kBAAkB,iBAAiB,EACrC,QAAO;SACF;KACL,MAAM,YAAY,YAAY;AAC9B,SAAI,aAAa,QAAQ,UAAU,SAAS,EAE1C,OAAM,IAAI,MAAM,eAAe,cAAc,6BAA6B,YAAY;;;WAKrFA,GAAQ;AACf,OAAI,YAAY,KAAK,EAAE,WAAW,KAAK;AACrC;AACA;;;AAIJ,QAAM,MAAM,iBAAiBC,sBAAS,aAAa,CAAC;AACpD;;AAGF,OAAM,IAAI,MAAM,eAAe,cAAc,uBAAuB,gBAAgB,SAAS"}
+{"version":3,"file":"transaction.js","names":["e: any","toNumber"],"sources":["../../src/transaction/transaction.ts"],"sourcesContent":["import { AlgodClient, PendingTransactionResponse } from '@algorandfoundation/algokit-algod-client'\nimport { Transaction, TransactionSigner } from '@algorandfoundation/algokit-transact'\nimport { TransactionComposer } from '../composer'\nimport { toNumber } from '../util'\nimport { AdditionalTransactionComposerContext, SendParams, SendTransactionComposerResults, TransactionComposerToSend } from './types'\n\n/** Represents an unsigned transactions and a signer that can authorize that transaction. */\nexport interface TransactionWithSigner {\n  /** An unsigned transaction */\n  txn: Transaction\n  /** A transaction signer that can authorize txn */\n  signer: TransactionSigner\n}\n\n/** Encodes a transaction lease into a 32-byte array ready to be included in an Algorand transaction.\n *\n * @param lease The transaction lease as a string or binary array or null/undefined if there is no lease\n * @returns the transaction lease ready for inclusion in a transaction or `undefined` if there is no lease\n * @throws if the length of the data is > 32 bytes or empty\n * @example algokit.encodeLease('UNIQUE_ID')\n * @example algokit.encodeLease(new Uint8Array([1, 2, 3]))\n */\nexport function encodeLease(lease?: string | Uint8Array): Uint8Array | undefined {\n  if (lease === null || typeof lease === 'undefined') {\n    return undefined\n  } else if (typeof lease === 'object' && lease.constructor === Uint8Array) {\n    if (lease.length === 0 || lease.length > 32) {\n      throw new Error(\n        `Received invalid lease; expected something with length between 1 and 32, but received bytes with length ${lease.length}`,\n      )\n    }\n    if (lease.length === 32) return lease\n    const lease32 = new Uint8Array(32)\n    lease32.set(lease, 0)\n    return lease32\n  } else if (typeof lease === 'string') {\n    if (lease.length === 0 || lease.length > 32) {\n      throw new Error(\n        `Received invalid lease; expected something with length between 1 and 32, but received '${lease}' with length ${lease.length}`,\n      )\n    }\n    const encoder = new TextEncoder()\n    const lease32 = new Uint8Array(32)\n    lease32.set(encoder.encode(lease), 0)\n    return lease32\n  } else {\n    throw new Error(`Unknown lease type received of ${typeof lease}`)\n  }\n}\n\n/**\n * @deprecated Use `composer.build()` directly\n * Take an existing Transaction Composer and return a new one with the required\n * app call resources populated into it\n *\n * @param algod The algod client to use for the simulation\n * @param composer The composer containing the txn group\n * @returns A new composer with the resources populated into the transactions\n *\n * @privateRemarks\n *\n * This entire function will eventually be implemented in simulate upstream in algod. The simulate endpoint will return\n * an array of refference arrays for each transaction, so this eventually will eventually just call simulate and set the\n * reference arrays in the transactions to the reference arrays returned by simulate.\n *\n * See https://github.com/algorand/go-algorand/pull/5684\n *\n */\nexport async function populateAppCallResources(composer: TransactionComposer) {\n  await composer.build()\n  return composer\n}\n\n/**\n * @deprecated Use `composer.setMaxFees()` instead if you need to set max fees for transactions.\n * Use `composer.build()` instead if you need to build transactions with resource population.\n *\n * Take an existing Transaction Composer and return a new one with changes applied to the transactions\n * based on the supplied sendParams to prepare it for sending.\n *\n * @param composer The Transaction Composer containing the txn group\n * @param sendParams The send params for the transaction group\n * @param additionalContext Additional context used to determine how best to change the transactions in the group\n * @returns A new Transaction Composer with the changes applied\n *\n * @privateRemarks\n * Parts of this function will eventually be implemented in algod. Namely:\n * - Simulate will return information on how to populate reference arrays, see https://github.com/algorand/go-algorand/pull/6015\n */\nexport async function prepareGroupForSending(\n  composer: TransactionComposer,\n  sendParams: SendParams,\n  additionalContext?: AdditionalTransactionComposerContext,\n) {\n  const newComposer = composer.clone({\n    coverAppCallInnerTransactionFees: sendParams.coverAppCallInnerTransactionFees ?? false,\n    populateAppCallResources: sendParams.populateAppCallResources ?? true,\n  })\n\n  if (additionalContext?.maxFees) {\n    newComposer.setMaxFees(additionalContext?.maxFees)\n  }\n\n  await newComposer.build()\n\n  return newComposer\n}\n\n/**\n * @deprecated Use `composer.send()` directly\n * Signs and sends transactions that have been collected by an `TransactionComposer`.\n * @param atcSend The parameters controlling the send, including `atc` The `TransactionComposer` and params to control send behaviour\n * @param algod An algod client\n * @returns An object with transaction IDs, transactions, group transaction ID (`groupTransactionId`) if more than 1 transaction sent, and (if `skipWaiting` is `false` or unset) confirmation (`confirmation`)\n */\nexport const sendTransactionComposer = async function (atcSend: TransactionComposerToSend): Promise<SendTransactionComposerResults> {\n  const { transactionComposer: givenComposer, ...executeParams } = atcSend\n\n  return atcSend.transactionComposer.send({\n    ...executeParams,\n  })\n}\n\n/**\n * Wait until the transaction is confirmed or rejected, or until `timeout`\n * number of rounds have passed.\n *\n * @param algod An algod client\n * @param transactionId The transaction ID to wait for\n * @param maxRoundsToWait Maximum number of rounds to wait\n *\n * @return Pending transaction information\n * @throws Throws an error if the transaction is not confirmed or rejected in the next `timeout` rounds\n */\nexport const waitForConfirmation = async function (\n  transactionId: string,\n  maxRoundsToWait: number | bigint,\n  algod: AlgodClient,\n): Promise<PendingTransactionResponse> {\n  if (maxRoundsToWait < 0) {\n    throw new Error(`Invalid timeout, received ${maxRoundsToWait}, expected > 0`)\n  }\n\n  // Get current round\n  const status = await algod.status()\n  if (status === undefined) {\n    throw new Error('Unable to get node status')\n  }\n\n  // Loop for up to `timeout` rounds looking for a confirmed transaction\n  const startRound = BigInt(status.lastRound) + 1n\n  let currentRound = startRound\n  while (currentRound < startRound + BigInt(maxRoundsToWait)) {\n    try {\n      const pendingInfo = await algod.pendingTransactionInformation(transactionId)\n\n      if (pendingInfo !== undefined) {\n        const confirmedRound = pendingInfo.confirmedRound\n        if (confirmedRound && confirmedRound > 0) {\n          return pendingInfo\n        } else {\n          const poolError = pendingInfo.poolError\n          if (poolError != null && poolError.length > 0) {\n            // If there was a pool error, then the transaction has been rejected!\n            throw new Error(`Transaction ${transactionId} was rejected; pool error: ${poolError}`)\n          }\n        }\n      }\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (e: any) {\n      if ('status' in e && e.status === 404) {\n        currentRound++\n        continue\n      }\n    }\n\n    await algod.statusAfterBlock(toNumber(currentRound))\n    currentRound++\n  }\n\n  throw new Error(`Transaction ${transactionId} not confirmed after ${maxRoundsToWait} rounds`)\n}\n"],"mappings":";;;;;;;;;;;AAsBA,SAAgB,YAAY,OAAqD;AAC/E,KAAI,UAAU,QAAQ,OAAO,UAAU,YACrC;UACS,OAAO,UAAU,YAAY,MAAM,gBAAgB,YAAY;AACxE,MAAI,MAAM,WAAW,KAAK,MAAM,SAAS,GACvC,OAAM,IAAI,MACR,2GAA2G,MAAM,SAClH;AAEH,MAAI,MAAM,WAAW,GAAI,QAAO;EAChC,MAAM,UAAU,IAAI,WAAW,GAAG;AAClC,UAAQ,IAAI,OAAO,EAAE;AACrB,SAAO;YACE,OAAO,UAAU,UAAU;AACpC,MAAI,MAAM,WAAW,KAAK,MAAM,SAAS,GACvC,OAAM,IAAI,MACR,0FAA0F,MAAM,gBAAgB,MAAM,SACvH;EAEH,MAAM,UAAU,IAAI,aAAa;EACjC,MAAM,UAAU,IAAI,WAAW,GAAG;AAClC,UAAQ,IAAI,QAAQ,OAAO,MAAM,EAAE,EAAE;AACrC,SAAO;OAEP,OAAM,IAAI,MAAM,kCAAkC,OAAO,QAAQ;;;;;;;;;;;;;;;;;;;;AAsBrE,eAAsB,yBAAyB,UAA+B;AAC5E,OAAM,SAAS,OAAO;AACtB,QAAO;;;;;;;;;;;;;;;;;;AAmBT,eAAsB,uBACpB,UACA,YACA,mBACA;CACA,MAAM,cAAc,SAAS,MAAM;EACjC,kCAAkC,WAAW,oCAAoC;EACjF,0BAA0B,WAAW,4BAA4B;EAClE,CAAC;AAEF,KAAI,mBAAmB,QACrB,aAAY,WAAW,mBAAmB,QAAQ;AAGpD,OAAM,YAAY,OAAO;AAEzB,QAAO;;;;;;;;;AAUT,MAAa,0BAA0B,eAAgB,SAA6E;CAClI,MAAM,EAAE,qBAAqB,eAAe,GAAG,kBAAkB;AAEjE,QAAO,QAAQ,oBAAoB,KAAK,EACtC,GAAG,eACJ,CAAC;;;;;;;;;;;;;AAcJ,MAAa,sBAAsB,eACjC,eACA,iBACA,OACqC;AACrC,KAAI,kBAAkB,EACpB,OAAM,IAAI,MAAM,6BAA6B,gBAAgB,gBAAgB;CAI/E,MAAM,SAAS,MAAM,MAAM,QAAQ;AACnC,KAAI,WAAW,OACb,OAAM,IAAI,MAAM,4BAA4B;CAI9C,MAAM,aAAa,OAAO,OAAO,UAAU,GAAG;CAC9C,IAAI,eAAe;AACnB,QAAO,eAAe,aAAa,OAAO,gBAAgB,EAAE;AAC1D,MAAI;GACF,MAAM,cAAc,MAAM,MAAM,8BAA8B,cAAc;AAE5E,OAAI,gBAAgB,QAAW;IAC7B,MAAM,iBAAiB,YAAY;AACnC,QAAI,kBAAkB,iBAAiB,EACrC,QAAO;SACF;KACL,MAAM,YAAY,YAAY;AAC9B,SAAI,aAAa,QAAQ,UAAU,SAAS,EAE1C,OAAM,IAAI,MAAM,eAAe,cAAc,6BAA6B,YAAY;;;WAKrFA,GAAQ;AACf,OAAI,YAAY,KAAK,EAAE,WAAW,KAAK;AACrC;AACA;;;AAIJ,QAAM,MAAM,iBAAiBC,sBAAS,aAAa,CAAC;AACpD;;AAGF,OAAM,IAAI,MAAM,eAAe,cAAc,uBAAuB,gBAAgB,SAAS"}

package/transaction/transaction.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"transaction.mjs","names":["e: any"],"sources":["../../src/transaction/transaction.ts"],"sourcesContent":["import { AlgodClient, PendingTransactionResponse } from '@algorandfoundation/algokit-algod-client'\nimport { Transaction, TransactionSigner } from '@algorandfoundation/algokit-transact'\nimport { TransactionComposer } from '../types/composer'\nimport {\n  AdditionalTransactionComposerContext,\n  SendParams,\n  SendTransactionComposerResults,\n  TransactionComposerToSend,\n} from '../types/transaction'\nimport { toNumber } from '../util'\n\n/** Represents an unsigned transactions and a signer that can authorize that transaction. */\nexport interface TransactionWithSigner {\n  /** An unsigned transaction */\n  txn: Transaction\n  /** A transaction signer that can authorize txn */\n  signer: TransactionSigner\n}\n\n/** Encodes a transaction lease into a 32-byte array ready to be included in an Algorand transaction.\n *\n * @param lease The transaction lease as a string or binary array or null/undefined if there is no lease\n * @returns the transaction lease ready for inclusion in a transaction or `undefined` if there is no lease\n * @throws if the length of the data is > 32 bytes or empty\n * @example algokit.encodeLease('UNIQUE_ID')\n * @example algokit.encodeLease(new Uint8Array([1, 2, 3]))\n */\nexport function encodeLease(lease?: string | Uint8Array): Uint8Array | undefined {\n  if (lease === null || typeof lease === 'undefined') {\n    return undefined\n  } else if (typeof lease === 'object' && lease.constructor === Uint8Array) {\n    if (lease.length === 0 || lease.length > 32) {\n      throw new Error(\n        `Received invalid lease; expected something with length between 1 and 32, but received bytes with length ${lease.length}`,\n      )\n    }\n    if (lease.length === 32) return lease\n    const lease32 = new Uint8Array(32)\n    lease32.set(lease, 0)\n    return lease32\n  } else if (typeof lease === 'string') {\n    if (lease.length === 0 || lease.length > 32) {\n      throw new Error(\n        `Received invalid lease; expected something with length between 1 and 32, but received '${lease}' with length ${lease.length}`,\n      )\n    }\n    const encoder = new TextEncoder()\n    const lease32 = new Uint8Array(32)\n    lease32.set(encoder.encode(lease), 0)\n    return lease32\n  } else {\n    throw new Error(`Unknown lease type received of ${typeof lease}`)\n  }\n}\n\n/**\n * @deprecated Use `composer.build()` directly\n * Take an existing Transaction Composer and return a new one with the required\n * app call resources populated into it\n *\n * @param algod The algod client to use for the simulation\n * @param composer The composer containing the txn group\n * @returns A new composer with the resources populated into the transactions\n *\n * @privateRemarks\n *\n * This entire function will eventually be implemented in simulate upstream in algod. The simulate endpoint will return\n * an array of refference arrays for each transaction, so this eventually will eventually just call simulate and set the\n * reference arrays in the transactions to the reference arrays returned by simulate.\n *\n * See https://github.com/algorand/go-algorand/pull/5684\n *\n */\nexport async function populateAppCallResources(composer: TransactionComposer) {\n  await composer.build()\n  return composer\n}\n\n/**\n * @deprecated Use `composer.setMaxFees()` instead if you need to set max fees for transactions.\n * Use `composer.build()` instead if you need to build transactions with resource population.\n *\n * Take an existing Transaction Composer and return a new one with changes applied to the transactions\n * based on the supplied sendParams to prepare it for sending.\n *\n * @param composer The Transaction Composer containing the txn group\n * @param sendParams The send params for the transaction group\n * @param additionalContext Additional context used to determine how best to change the transactions in the group\n * @returns A new Transaction Composer with the changes applied\n *\n * @privateRemarks\n * Parts of this function will eventually be implemented in algod. Namely:\n * - Simulate will return information on how to populate reference arrays, see https://github.com/algorand/go-algorand/pull/6015\n */\nexport async function prepareGroupForSending(\n  composer: TransactionComposer,\n  sendParams: SendParams,\n  additionalContext?: AdditionalTransactionComposerContext,\n) {\n  const newComposer = composer.clone({\n    coverAppCallInnerTransactionFees: sendParams.coverAppCallInnerTransactionFees ?? false,\n    populateAppCallResources: sendParams.populateAppCallResources ?? true,\n  })\n\n  if (additionalContext?.maxFees) {\n    newComposer.setMaxFees(additionalContext?.maxFees)\n  }\n\n  await newComposer.build()\n\n  return newComposer\n}\n\n/**\n * @deprecated Use `composer.send()` directly\n * Signs and sends transactions that have been collected by an `TransactionComposer`.\n * @param atcSend The parameters controlling the send, including `atc` The `TransactionComposer` and params to control send behaviour\n * @param algod An algod client\n * @returns An object with transaction IDs, transactions, group transaction ID (`groupTransactionId`) if more than 1 transaction sent, and (if `skipWaiting` is `false` or unset) confirmation (`confirmation`)\n */\nexport const sendTransactionComposer = async function (atcSend: TransactionComposerToSend): Promise<SendTransactionComposerResults> {\n  const { transactionComposer: givenComposer, ...executeParams } = atcSend\n\n  return atcSend.transactionComposer.send({\n    ...executeParams,\n  })\n}\n\n/**\n * Wait until the transaction is confirmed or rejected, or until `timeout`\n * number of rounds have passed.\n *\n * @param algod An algod client\n * @param transactionId The transaction ID to wait for\n * @param maxRoundsToWait Maximum number of rounds to wait\n *\n * @return Pending transaction information\n * @throws Throws an error if the transaction is not confirmed or rejected in the next `timeout` rounds\n */\nexport const waitForConfirmation = async function (\n  transactionId: string,\n  maxRoundsToWait: number | bigint,\n  algod: AlgodClient,\n): Promise<PendingTransactionResponse> {\n  if (maxRoundsToWait < 0) {\n    throw new Error(`Invalid timeout, received ${maxRoundsToWait}, expected > 0`)\n  }\n\n  // Get current round\n  const status = await algod.status()\n  if (status === undefined) {\n    throw new Error('Unable to get node status')\n  }\n\n  // Loop for up to `timeout` rounds looking for a confirmed transaction\n  const startRound = BigInt(status.lastRound) + 1n\n  let currentRound = startRound\n  while (currentRound < startRound + BigInt(maxRoundsToWait)) {\n    try {\n      const pendingInfo = await algod.pendingTransactionInformation(transactionId)\n\n      if (pendingInfo !== undefined) {\n        const confirmedRound = pendingInfo.confirmedRound\n        if (confirmedRound && confirmedRound > 0) {\n          return pendingInfo\n        } else {\n          const poolError = pendingInfo.poolError\n          if (poolError != null && poolError.length > 0) {\n            // If there was a pool error, then the transaction has been rejected!\n            throw new Error(`Transaction ${transactionId} was rejected; pool error: ${poolError}`)\n          }\n        }\n      }\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (e: any) {\n      if ('status' in e && e.status === 404) {\n        currentRound++\n        continue\n      }\n    }\n\n    await algod.statusAfterBlock(toNumber(currentRound))\n    currentRound++\n  }\n\n  throw new Error(`Transaction ${transactionId} not confirmed after ${maxRoundsToWait} rounds`)\n}\n"],"mappings":";;;;;;;;;;;AA2BA,SAAgB,YAAY,OAAqD;AAC/E,KAAI,UAAU,QAAQ,OAAO,UAAU,YACrC;UACS,OAAO,UAAU,YAAY,MAAM,gBAAgB,YAAY;AACxE,MAAI,MAAM,WAAW,KAAK,MAAM,SAAS,GACvC,OAAM,IAAI,MACR,2GAA2G,MAAM,SAClH;AAEH,MAAI,MAAM,WAAW,GAAI,QAAO;EAChC,MAAM,UAAU,IAAI,WAAW,GAAG;AAClC,UAAQ,IAAI,OAAO,EAAE;AACrB,SAAO;YACE,OAAO,UAAU,UAAU;AACpC,MAAI,MAAM,WAAW,KAAK,MAAM,SAAS,GACvC,OAAM,IAAI,MACR,0FAA0F,MAAM,gBAAgB,MAAM,SACvH;EAEH,MAAM,UAAU,IAAI,aAAa;EACjC,MAAM,UAAU,IAAI,WAAW,GAAG;AAClC,UAAQ,IAAI,QAAQ,OAAO,MAAM,EAAE,EAAE;AACrC,SAAO;OAEP,OAAM,IAAI,MAAM,kCAAkC,OAAO,QAAQ;;;;;;;;;;;;;;;;;;;;AAsBrE,eAAsB,yBAAyB,UAA+B;AAC5E,OAAM,SAAS,OAAO;AACtB,QAAO;;;;;;;;;;;;;;;;;;AAmBT,eAAsB,uBACpB,UACA,YACA,mBACA;CACA,MAAM,cAAc,SAAS,MAAM;EACjC,kCAAkC,WAAW,oCAAoC;EACjF,0BAA0B,WAAW,4BAA4B;EAClE,CAAC;AAEF,KAAI,mBAAmB,QACrB,aAAY,WAAW,mBAAmB,QAAQ;AAGpD,OAAM,YAAY,OAAO;AAEzB,QAAO;;;;;;;;;AAUT,MAAa,0BAA0B,eAAgB,SAA6E;CAClI,MAAM,EAAE,qBAAqB,eAAe,GAAG,kBAAkB;AAEjE,QAAO,QAAQ,oBAAoB,KAAK,EACtC,GAAG,eACJ,CAAC;;;;;;;;;;;;;AAcJ,MAAa,sBAAsB,eACjC,eACA,iBACA,OACqC;AACrC,KAAI,kBAAkB,EACpB,OAAM,IAAI,MAAM,6BAA6B,gBAAgB,gBAAgB;CAI/E,MAAM,SAAS,MAAM,MAAM,QAAQ;AACnC,KAAI,WAAW,OACb,OAAM,IAAI,MAAM,4BAA4B;CAI9C,MAAM,aAAa,OAAO,OAAO,UAAU,GAAG;CAC9C,IAAI,eAAe;AACnB,QAAO,eAAe,aAAa,OAAO,gBAAgB,EAAE;AAC1D,MAAI;GACF,MAAM,cAAc,MAAM,MAAM,8BAA8B,cAAc;AAE5E,OAAI,gBAAgB,QAAW;IAC7B,MAAM,iBAAiB,YAAY;AACnC,QAAI,kBAAkB,iBAAiB,EACrC,QAAO;SACF;KACL,MAAM,YAAY,YAAY;AAC9B,SAAI,aAAa,QAAQ,UAAU,SAAS,EAE1C,OAAM,IAAI,MAAM,eAAe,cAAc,6BAA6B,YAAY;;;WAKrFA,GAAQ;AACf,OAAI,YAAY,KAAK,EAAE,WAAW,KAAK;AACrC;AACA;;;AAIJ,QAAM,MAAM,iBAAiB,SAAS,aAAa,CAAC;AACpD;;AAGF,OAAM,IAAI,MAAM,eAAe,cAAc,uBAAuB,gBAAgB,SAAS"}
+{"version":3,"file":"transaction.mjs","names":["e: any"],"sources":["../../src/transaction/transaction.ts"],"sourcesContent":["import { AlgodClient, PendingTransactionResponse } from '@algorandfoundation/algokit-algod-client'\nimport { Transaction, TransactionSigner } from '@algorandfoundation/algokit-transact'\nimport { TransactionComposer } from '../composer'\nimport { toNumber } from '../util'\nimport { AdditionalTransactionComposerContext, SendParams, SendTransactionComposerResults, TransactionComposerToSend } from './types'\n\n/** Represents an unsigned transactions and a signer that can authorize that transaction. */\nexport interface TransactionWithSigner {\n  /** An unsigned transaction */\n  txn: Transaction\n  /** A transaction signer that can authorize txn */\n  signer: TransactionSigner\n}\n\n/** Encodes a transaction lease into a 32-byte array ready to be included in an Algorand transaction.\n *\n * @param lease The transaction lease as a string or binary array or null/undefined if there is no lease\n * @returns the transaction lease ready for inclusion in a transaction or `undefined` if there is no lease\n * @throws if the length of the data is > 32 bytes or empty\n * @example algokit.encodeLease('UNIQUE_ID')\n * @example algokit.encodeLease(new Uint8Array([1, 2, 3]))\n */\nexport function encodeLease(lease?: string | Uint8Array): Uint8Array | undefined {\n  if (lease === null || typeof lease === 'undefined') {\n    return undefined\n  } else if (typeof lease === 'object' && lease.constructor === Uint8Array) {\n    if (lease.length === 0 || lease.length > 32) {\n      throw new Error(\n        `Received invalid lease; expected something with length between 1 and 32, but received bytes with length ${lease.length}`,\n      )\n    }\n    if (lease.length === 32) return lease\n    const lease32 = new Uint8Array(32)\n    lease32.set(lease, 0)\n    return lease32\n  } else if (typeof lease === 'string') {\n    if (lease.length === 0 || lease.length > 32) {\n      throw new Error(\n        `Received invalid lease; expected something with length between 1 and 32, but received '${lease}' with length ${lease.length}`,\n      )\n    }\n    const encoder = new TextEncoder()\n    const lease32 = new Uint8Array(32)\n    lease32.set(encoder.encode(lease), 0)\n    return lease32\n  } else {\n    throw new Error(`Unknown lease type received of ${typeof lease}`)\n  }\n}\n\n/**\n * @deprecated Use `composer.build()` directly\n * Take an existing Transaction Composer and return a new one with the required\n * app call resources populated into it\n *\n * @param algod The algod client to use for the simulation\n * @param composer The composer containing the txn group\n * @returns A new composer with the resources populated into the transactions\n *\n * @privateRemarks\n *\n * This entire function will eventually be implemented in simulate upstream in algod. The simulate endpoint will return\n * an array of refference arrays for each transaction, so this eventually will eventually just call simulate and set the\n * reference arrays in the transactions to the reference arrays returned by simulate.\n *\n * See https://github.com/algorand/go-algorand/pull/5684\n *\n */\nexport async function populateAppCallResources(composer: TransactionComposer) {\n  await composer.build()\n  return composer\n}\n\n/**\n * @deprecated Use `composer.setMaxFees()` instead if you need to set max fees for transactions.\n * Use `composer.build()` instead if you need to build transactions with resource population.\n *\n * Take an existing Transaction Composer and return a new one with changes applied to the transactions\n * based on the supplied sendParams to prepare it for sending.\n *\n * @param composer The Transaction Composer containing the txn group\n * @param sendParams The send params for the transaction group\n * @param additionalContext Additional context used to determine how best to change the transactions in the group\n * @returns A new Transaction Composer with the changes applied\n *\n * @privateRemarks\n * Parts of this function will eventually be implemented in algod. Namely:\n * - Simulate will return information on how to populate reference arrays, see https://github.com/algorand/go-algorand/pull/6015\n */\nexport async function prepareGroupForSending(\n  composer: TransactionComposer,\n  sendParams: SendParams,\n  additionalContext?: AdditionalTransactionComposerContext,\n) {\n  const newComposer = composer.clone({\n    coverAppCallInnerTransactionFees: sendParams.coverAppCallInnerTransactionFees ?? false,\n    populateAppCallResources: sendParams.populateAppCallResources ?? true,\n  })\n\n  if (additionalContext?.maxFees) {\n    newComposer.setMaxFees(additionalContext?.maxFees)\n  }\n\n  await newComposer.build()\n\n  return newComposer\n}\n\n/**\n * @deprecated Use `composer.send()` directly\n * Signs and sends transactions that have been collected by an `TransactionComposer`.\n * @param atcSend The parameters controlling the send, including `atc` The `TransactionComposer` and params to control send behaviour\n * @param algod An algod client\n * @returns An object with transaction IDs, transactions, group transaction ID (`groupTransactionId`) if more than 1 transaction sent, and (if `skipWaiting` is `false` or unset) confirmation (`confirmation`)\n */\nexport const sendTransactionComposer = async function (atcSend: TransactionComposerToSend): Promise<SendTransactionComposerResults> {\n  const { transactionComposer: givenComposer, ...executeParams } = atcSend\n\n  return atcSend.transactionComposer.send({\n    ...executeParams,\n  })\n}\n\n/**\n * Wait until the transaction is confirmed or rejected, or until `timeout`\n * number of rounds have passed.\n *\n * @param algod An algod client\n * @param transactionId The transaction ID to wait for\n * @param maxRoundsToWait Maximum number of rounds to wait\n *\n * @return Pending transaction information\n * @throws Throws an error if the transaction is not confirmed or rejected in the next `timeout` rounds\n */\nexport const waitForConfirmation = async function (\n  transactionId: string,\n  maxRoundsToWait: number | bigint,\n  algod: AlgodClient,\n): Promise<PendingTransactionResponse> {\n  if (maxRoundsToWait < 0) {\n    throw new Error(`Invalid timeout, received ${maxRoundsToWait}, expected > 0`)\n  }\n\n  // Get current round\n  const status = await algod.status()\n  if (status === undefined) {\n    throw new Error('Unable to get node status')\n  }\n\n  // Loop for up to `timeout` rounds looking for a confirmed transaction\n  const startRound = BigInt(status.lastRound) + 1n\n  let currentRound = startRound\n  while (currentRound < startRound + BigInt(maxRoundsToWait)) {\n    try {\n      const pendingInfo = await algod.pendingTransactionInformation(transactionId)\n\n      if (pendingInfo !== undefined) {\n        const confirmedRound = pendingInfo.confirmedRound\n        if (confirmedRound && confirmedRound > 0) {\n          return pendingInfo\n        } else {\n          const poolError = pendingInfo.poolError\n          if (poolError != null && poolError.length > 0) {\n            // If there was a pool error, then the transaction has been rejected!\n            throw new Error(`Transaction ${transactionId} was rejected; pool error: ${poolError}`)\n          }\n        }\n      }\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (e: any) {\n      if ('status' in e && e.status === 404) {\n        currentRound++\n        continue\n      }\n    }\n\n    await algod.statusAfterBlock(toNumber(currentRound))\n    currentRound++\n  }\n\n  throw new Error(`Transaction ${transactionId} not confirmed after ${maxRoundsToWait} rounds`)\n}\n"],"mappings":";;;;;;;;;;;AAsBA,SAAgB,YAAY,OAAqD;AAC/E,KAAI,UAAU,QAAQ,OAAO,UAAU,YACrC;UACS,OAAO,UAAU,YAAY,MAAM,gBAAgB,YAAY;AACxE,MAAI,MAAM,WAAW,KAAK,MAAM,SAAS,GACvC,OAAM,IAAI,MACR,2GAA2G,MAAM,SAClH;AAEH,MAAI,MAAM,WAAW,GAAI,QAAO;EAChC,MAAM,UAAU,IAAI,WAAW,GAAG;AAClC,UAAQ,IAAI,OAAO,EAAE;AACrB,SAAO;YACE,OAAO,UAAU,UAAU;AACpC,MAAI,MAAM,WAAW,KAAK,MAAM,SAAS,GACvC,OAAM,IAAI,MACR,0FAA0F,MAAM,gBAAgB,MAAM,SACvH;EAEH,MAAM,UAAU,IAAI,aAAa;EACjC,MAAM,UAAU,IAAI,WAAW,GAAG;AAClC,UAAQ,IAAI,QAAQ,OAAO,MAAM,EAAE,EAAE;AACrC,SAAO;OAEP,OAAM,IAAI,MAAM,kCAAkC,OAAO,QAAQ;;;;;;;;;;;;;;;;;;;;AAsBrE,eAAsB,yBAAyB,UAA+B;AAC5E,OAAM,SAAS,OAAO;AACtB,QAAO;;;;;;;;;;;;;;;;;;AAmBT,eAAsB,uBACpB,UACA,YACA,mBACA;CACA,MAAM,cAAc,SAAS,MAAM;EACjC,kCAAkC,WAAW,oCAAoC;EACjF,0BAA0B,WAAW,4BAA4B;EAClE,CAAC;AAEF,KAAI,mBAAmB,QACrB,aAAY,WAAW,mBAAmB,QAAQ;AAGpD,OAAM,YAAY,OAAO;AAEzB,QAAO;;;;;;;;;AAUT,MAAa,0BAA0B,eAAgB,SAA6E;CAClI,MAAM,EAAE,qBAAqB,eAAe,GAAG,kBAAkB;AAEjE,QAAO,QAAQ,oBAAoB,KAAK,EACtC,GAAG,eACJ,CAAC;;;;;;;;;;;;;AAcJ,MAAa,sBAAsB,eACjC,eACA,iBACA,OACqC;AACrC,KAAI,kBAAkB,EACpB,OAAM,IAAI,MAAM,6BAA6B,gBAAgB,gBAAgB;CAI/E,MAAM,SAAS,MAAM,MAAM,QAAQ;AACnC,KAAI,WAAW,OACb,OAAM,IAAI,MAAM,4BAA4B;CAI9C,MAAM,aAAa,OAAO,OAAO,UAAU,GAAG;CAC9C,IAAI,eAAe;AACnB,QAAO,eAAe,aAAa,OAAO,gBAAgB,EAAE;AAC1D,MAAI;GACF,MAAM,cAAc,MAAM,MAAM,8BAA8B,cAAc;AAE5E,OAAI,gBAAgB,QAAW;IAC7B,MAAM,iBAAiB,YAAY;AACnC,QAAI,kBAAkB,iBAAiB,EACrC,QAAO;SACF;KACL,MAAM,YAAY,YAAY;AAC9B,SAAI,aAAa,QAAQ,UAAU,SAAS,EAE1C,OAAM,IAAI,MAAM,eAAe,cAAc,6BAA6B,YAAY;;;WAKrFA,GAAQ;AACf,OAAI,YAAY,KAAK,EAAE,WAAW,KAAK;AACrC;AACA;;;AAIJ,QAAM,MAAM,iBAAiB,SAAS,aAAa,CAAC;AACpD;;AAGF,OAAM,IAAI,MAAM,eAAe,cAAc,uBAAuB,gBAAgB,SAAS"}

package/transaction/types.d.ts

@@ -0,0 +1,133 @@
+import { Expand } from "../packages/common/src/expand.js";
+import { ABIReturn } from "../packages/abi/src/abi-method.js";
+import { Transaction } from "../packages/transact/src/transactions/transaction.js";
+import { AddressWithTransactionSigner, SendingAddress, TransactionSigner } from "../packages/transact/src/signer.js";
+import { PendingTransactionResponse } from "../packages/algod_client/src/models/pending-transaction-response.js";
+import { AlgoAmount } from "../amount.js";
+import { TransactionComposer } from "../composer.js";
+
+//#region src/transaction/types.d.ts
+type TransactionNote = Uint8Array | TransactionNoteData | Arc2TransactionNote;
+type TransactionNoteData = string | null | undefined | number | any[] | Record<string, any>;
+/** ARC-0002 compatible transaction note components https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0002.md */
+type Arc2TransactionNote = {
+  dAppName: string;
+  format: 'm' | 'b' | 'u';
+  data: string;
+} | {
+  dAppName: string;
+  format: 'j';
+  data: TransactionNoteData;
+};
+/** The sending configuration for a transaction */
+interface SendTransactionParams {
+  /** Whether to skip signing and sending the transaction to the chain (default: transaction signed and sent to chain, unless `atc` specified)
+   * and instead just return the raw transaction, e.g. so you can add it to a group of transactions */
+  skipSending?: boolean;
+  /** Whether to skip waiting for the submitted transaction (only relevant if `skipSending` is `false` or unset) */
+  skipWaiting?: boolean;
+  /** An optional `TransactionComposer` to add the transaction to, if specified then `skipSending: undefined` has the same effect as `skipSending: true` */
+  transactionComposer?: TransactionComposer;
+  /** Whether to suppress log messages from transaction send, default: do not suppress */
+  suppressLog?: boolean;
+  /** The flat fee you want to pay, useful for covering extra fees in a transaction group or app call */
+  fee?: AlgoAmount;
+  /** The maximum fee that you are happy to pay (default: unbounded) - if this is set it's possible the transaction could get rejected during network congestion */
+  maxFee?: AlgoAmount;
+  /** The maximum number of rounds to wait for confirmation, only applies if `skipWaiting` is `undefined` or `false`, default: wait up to 5 rounds */
+  maxRoundsToWaitForConfirmation?: number;
+  /** Whether to use simulate to automatically populate app call resources in the txn objects. Defaults to true when there are app calls in the group.  */
+  populateAppCallResources?: boolean;
+}
+/** Result from sending a single transaction. */
+type SendSingleTransactionResult = Expand<SendTransactionComposerResults & ConfirmedTransactionResult>;
+/** The result of sending a transaction */
+interface SendTransactionResult {
+  /** The transaction */
+  transaction: Transaction;
+  /** The response if the transaction was sent and waited for */
+  confirmation?: PendingTransactionResponse;
+}
+/** The result of preparing and/or sending multiple transactions */
+interface SendTransactionResults {
+  /** The transactions that have been prepared and/or sent */
+  transactions: Transaction[];
+  /** The responses if the transactions were sent and waited for,
+   * the index of the confirmation will match the index of the underlying transaction
+   */
+  confirmations?: PendingTransactionResponse[];
+}
+/** The result of preparing and/or sending multiple transactions using an `TransactionComposer` */
+interface SendTransactionComposerResults extends Omit<SendTransactionResults, 'confirmations'> {
+  /** base64 encoded representation of the group ID of the group */
+  groupId: string | undefined;
+  /** The transaction IDs that have been prepared and/or sent */
+  txIds: string[];
+  /** If ABI method(s) were called the processed return values */
+  returns?: ABIReturn[];
+  /** The responses if the transactions were sent and waited for,
+   * the index of the confirmation will match the index of the underlying transaction
+   */
+  confirmations: PendingTransactionResponse[];
+}
+/** The result of sending and confirming a transaction */
+interface ConfirmedTransactionResult extends SendTransactionResult {
+  /** The response from sending and waiting for the transaction */
+  confirmation: PendingTransactionResponse;
+}
+/** The result of sending and confirming one or more transactions, but where there is a primary transaction of interest */
+interface ConfirmedTransactionResults extends SendTransactionResult, SendTransactionResults {
+  /** The response from sending and waiting for the primary transaction */
+  confirmation: PendingTransactionResponse;
+  /** The response from sending and waiting for the transactions */
+  confirmations: PendingTransactionResponse[];
+}
+/**
+ * @deprecated Use `SendingAddress` instead
+ */
+type SendTransactionFrom = AddressWithTransactionSigner;
+/** Defines an unsigned transaction that will appear in a group of transactions along with its signing information */
+interface TransactionToSign {
+  /** The unsigned transaction to sign and send */
+  transaction: Transaction;
+  /** The account to use to sign the transaction, either an account (with private key loaded) or a logic signature account */
+  signer: AddressWithTransactionSigner | TransactionSigner;
+}
+/** A group of transactions to send together as an group
+ * https://dev.algorand.co/concepts/transactions/atomic-txn-groups/
+ */
+interface TransactionGroupToSend {
+  /** Any parameters to control the semantics of the send to the network */
+  sendParams?: Omit<SendTransactionParams, 'fee' | 'maxFee' | 'skipSending' | 'atc'>;
+  /** The list of transactions to send, which can either be a raw transaction (in which case `signer` is required),
+   *   the async result of an AlgoKit utils method that returns a `SendTransactionResult` (saves unwrapping the promise, be sure to pass `skipSending: true`, `signer` is also required)
+   *   or the transaction with its signer (`signer` is ignored)
+   **/
+  transactions: (TransactionToSign | Transaction | Promise<SendTransactionResult>)[];
+  /** Optional signer to pass in, required if at least one transaction provided is just the transaction, ignored otherwise */
+  signer?: SendingAddress;
+}
+/** Parameters to configure transaction sending. */
+interface SendParams {
+  /** The number of rounds to wait for confirmation. By default until the latest lastValid has past. */
+  maxRoundsToWaitForConfirmation?: number;
+  /** Whether to suppress log messages from transaction send, default: do not suppress. */
+  suppressLog?: boolean;
+  /** Whether to use simulate to automatically populate app call resources in the txn objects. Defaults to `Config.populateAppCallResources`. */
+  populateAppCallResources?: boolean;
+  /** Whether to use simulate to automatically calculate required app call inner transaction fees and cover them in the parent app call transaction fee */
+  coverAppCallInnerTransactionFees?: boolean;
+}
+/** Additional context about the `TransactionComposer`. */
+interface AdditionalTransactionComposerContext {
+  /** A map of transaction index in the `TransactionComposer` to the max fee that can be calculated for a transaction in the group */
+  maxFees: Map<number, AlgoAmount>;
+}
+/** An `TransactionComposer` with transactions to send. */
+interface TransactionComposerToSend extends SendParams {
+  /** The `TransactionComposer` with transactions loaded to send */
+  transactionComposer: TransactionComposer;
+}
+//#endregion
+export { AdditionalTransactionComposerContext, Arc2TransactionNote, ConfirmedTransactionResult, ConfirmedTransactionResults, SendParams, SendSingleTransactionResult, SendTransactionComposerResults, SendTransactionFrom, SendTransactionParams, SendTransactionResult, SendTransactionResults, TransactionComposerToSend, TransactionGroupToSend, TransactionNote, TransactionNoteData, TransactionToSign };
+//# sourceMappingURL=types.d.ts.map

package/transactions/app-call.d.ts

@@ -1,7 +1,7 @@
 import { ReadableAddress } from "../packages/common/src/address.js";
 import { Expand } from "../packages/common/src/expand.js";
 import { OnApplicationComplete, ResourceReference } from "../packages/transact/src/transactions/app-call.js";
-import { BoxIdentifier, BoxReference } from "../types/app-manager.js";
+import { BoxIdentifier, BoxReference } from "../app-manager.js";
 import { CommonTransactionParams } from "./common.js";
 
 //#region src/transactions/app-call.d.ts

package/transactions/app-call.js

@@ -4,7 +4,7 @@ const require_util = require('../util.js');
 const require_app_call = require('../packages/transact/src/transactions/app-call.js');
 const require_transaction_type = require('../packages/transact/src/transactions/transaction-type.js');
 const require_transaction = require('../packages/transact/src/transactions/transaction.js');
-const require_app_manager = require('../types/app-manager.js');
+const require_app_manager = require('../app-manager.js');
 const require_common = require('./common.js');
 
 //#region src/transactions/app-call.ts