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

package/composer.d.ts

@@ -0,0 +1,947 @@
+import { ReadableAddress } from "./packages/common/src/address.js";
+import { Expand } from "./packages/common/src/expand.js";
+import { ABIMethod } from "./packages/abi/src/abi-method.js";
+import { Transaction } from "./packages/transact/src/transactions/transaction.js";
+import { TransactionSigner } from "./packages/transact/src/signer.js";
+import { SimulateRequest } from "./packages/algod_client/src/models/simulate-request.js";
+import { SimulateResponse } from "./packages/algod_client/src/models/simulate-response.js";
+import { SuggestedParams } from "./packages/algod_client/src/models/suggested-params.js";
+import { AlgodClient } from "./packages/algod_client/src/client.js";
+import { AlgoAmount } from "./amount.js";
+import { Arc2TransactionNote, SendParams, SendTransactionComposerResults } from "./transaction/types.js";
+import { TransactionWithSigner } from "./transaction/transaction.js";
+import { AppManager } from "./app-manager.js";
+import { CommonTransactionParams } from "./transactions/common.js";
+import { AppCallParams, AppCreateParams, AppDeleteParams, AppMethodCallParams, AppUpdateParams, CommonAppCallParams } from "./transactions/app-call.js";
+import { AssetOptInParams, AssetOptOutParams, AssetTransferParams } from "./transactions/asset-transfer.js";
+import { AssetConfigParams, AssetCreateParams, AssetDestroyParams, AssetFreezeParams } from "./transactions/asset-config.js";
+import { OfflineKeyRegistrationParams, OnlineKeyRegistrationParams } from "./transactions/key-registration.js";
+import { AppCallMethodCall, AppCreateMethodCall, AppDeleteMethodCall, AppMethodCall, AppMethodCallTransactionArgument, AppUpdateMethodCall, ProcessedAppCallMethodCall, ProcessedAppCreateMethodCall, ProcessedAppUpdateMethodCall } from "./transactions/method-call.js";
+import { PaymentParams } from "./transactions/payment.js";
+
+//#region src/composer.d.ts
+
+/** Options to control a simulate request, that does not require transaction signing */
+type SkipSignaturesSimulateOptions = Expand<Omit<RawSimulateOptions, 'fixSigners' | 'allowEmptySignatures'> & {
+  /** Whether or not to skip signatures for all built transactions and use an empty signer instead.
+   * This will set `fixSigners` and `allowEmptySignatures` when sending the request to the algod API.
+   */
+  skipSignatures: boolean;
+}>;
+/** The raw API options to control a simulate request.
+ * See algod API docs for more information: https://dev.algorand.co/reference/rest-apis/algod/#simulatetransaction
+ */
+type RawSimulateOptions = Expand<Omit<SimulateRequest, 'txnGroups'>> & {
+  /** Whether or not to return the result on simulation failure instead of throwing an error */
+  resultOnFailure?: boolean;
+};
+/** All options to control a simulate request */
+type SimulateOptions = Expand<Partial<SkipSignaturesSimulateOptions> & RawSimulateOptions>;
+/**
+ * A function that transforms an error into a new error.
+ *
+ * In most cases, an ErrorTransformer should first check if it can or should transform the error
+ * and return the input error if it cannot or should not transform it.
+ */
+type ErrorTransformer = (error: Error) => Promise<Error>;
+type TransactionComposerConfig = {
+  coverAppCallInnerTransactionFees: boolean;
+  populateAppCallResources: boolean;
+};
+/** Parameters to create an `TransactionComposer`. */
+type TransactionComposerParams = {
+  /** The algod client to use to get suggestedParams and send the transaction group */
+  algod: AlgodClient;
+  /** The function used to get the TransactionSigner for a given address */
+  getSigner: (address: ReadableAddress) => TransactionSigner;
+  /** The method used to get SuggestedParams for transactions in the group */
+  getSuggestedParams?: () => Promise<SuggestedParams>;
+  /** How many rounds a transaction should be valid for by default; if not specified
+   * then will be 10 rounds (or 1000 rounds if issuing transactions to LocalNet).
+   */
+  defaultValidityWindow?: bigint;
+  /** An existing `AppManager` to use to manage app compilation and cache compilation results.
+   *
+   * If not specified then an ephemeral one will be created.
+   */
+  appManager?: AppManager;
+  /**
+   * An array of error transformers to use when an error is caught in simulate or execute
+   * callbacks can later be registered with `registerErrorTransformer`
+   */
+  errorTransformers?: ErrorTransformer[];
+  composerConfig?: TransactionComposerConfig;
+};
+/** Set of transactions built by `TransactionComposer`. */
+interface BuiltTransactions {
+  /** The built transactions */
+  transactions: Transaction[];
+  /** Any `ABIMethod` objects associated with any of the transactions in a map keyed by transaction index. */
+  methodCalls: Map<number, ABIMethod>;
+  /** Any `TransactionSigner` objects associated with any of the transactions in a map keyed by transaction index. */
+  signers: Map<number, TransactionSigner>;
+}
+/** TransactionComposer helps you compose and execute transactions as a transaction group. */
+declare class TransactionComposer {
+  /** Transactions that have not yet been composed */
+  private txns;
+  /** The algod client used by the composer. */
+  private algod;
+  /** An async function that will return suggested params for the transaction. */
+  private getSuggestedParams;
+  /** A function that takes in an address and return a signer function for that address. */
+  private getSigner;
+  /** The default transaction validity window */
+  private defaultValidityWindow;
+  /** Whether the validity window was explicitly set on construction */
+  private defaultValidityWindowIsExplicit;
+  private appManager;
+  private errorTransformers;
+  private composerConfig;
+  private transactionsWithSigners?;
+  private signedTransactions?;
+  private rawBuildTransactions?;
+  private transformError;
+  private validateReferenceParams;
+  /**
+   * Create a `TransactionComposer`.
+   * @param params The configuration for this composer
+   * @returns The `TransactionComposer` instance
+   */
+  constructor(params: TransactionComposerParams);
+  private cloneTransaction;
+  private push;
+  clone(composerConfig?: TransactionComposerConfig): TransactionComposer;
+  /**
+   * Register a function that will be used to transform an error caught when simulating or executing
+   *
+   * @returns The composer so you can chain method calls
+   */
+  registerErrorTransformer(transformer: ErrorTransformer): this;
+  /**
+   * Add a pre-built transaction to the transaction group.
+   * @param transaction The pre-built transaction
+   * @param signer Optional signer override for the transaction
+   * @returns The composer so you can chain method calls
+   * @example
+   * ```typescript
+   * composer.addTransaction(txn)
+   * ```
+   */
+  addTransaction(transaction: Transaction, signer?: TransactionSigner): TransactionComposer;
+  /**
+   * Add another transaction composer to the current transaction composer.
+   * The transaction params of the input transaction composer will be added.
+   * If the input transaction composer is updated, it won't affect the current transaction composer.
+   * @param composer The transaction composer to add
+   * @returns The composer so you can chain method calls
+   * @example
+   * ```typescript
+   * const innerComposer = algorand.newGroup()
+   *   .addPayment({ sender: 'SENDER', receiver: 'RECEIVER', amount: (1).algo() })
+   *   .addPayment({ sender: 'SENDER', receiver: 'RECEIVER', amount: (2).algo() })
+   *
+   * composer.addTransactionComposer(innerComposer)
+   * ```
+   */
+  addTransactionComposer(composer: TransactionComposer): TransactionComposer;
+  /**
+   * Add a payment transaction to the transaction group.
+   * @param params The payment transaction parameters
+   * @returns The composer so you can chain method calls
+   * @example Basic example
+   * ```typescript
+   * composer.addPayment({
+   *   sender: 'SENDERADDRESS',
+   *   receiver: 'RECEIVERADDRESS',
+   *   amount: (4).algo(),
+   * })
+   * ```
+   * @example Advanced example
+   * ```typescript
+   * composer.addPayment({
+   *   amount: (4).algo(),
+   *   receiver: 'RECEIVERADDRESS',
+   *   sender: 'SENDERADDRESS',
+   *   closeRemainderTo: 'CLOSEREMAINDERTOADDRESS',
+   *   lease: 'lease',
+   *   note: 'note',
+   *   // Use this with caution, it's generally better to use algorand.account.rekeyAccount
+   *   rekeyTo: 'REKEYTOADDRESS',
+   *   // You wouldn't normally set this field
+   *   firstValidRound: 1000n,
+   *   validityWindow: 10,
+   *   extraFee: (1000).microAlgo(),
+   *   staticFee: (1000).microAlgo(),
+   *   // Max fee doesn't make sense with extraFee AND staticFee
+   *   //  already specified, but here for completeness
+   *   maxFee: (3000).microAlgo(),
+   * })
+   */
+  addPayment(params: PaymentParams): TransactionComposer;
+  /**
+   * Add an asset create transaction to the transaction group.
+   * @param params The asset create transaction parameters
+   * @returns The composer so you can chain method calls
+   * @example Basic example
+   * ```typescript
+   * composer.addAssetCreate({ sender: "CREATORADDRESS", total: 100n})
+   * ```
+   * @example Advanced example
+   * ```typescript
+   * composer.addAssetCreate({
+   *   sender: 'CREATORADDRESS',
+   *   total: 100n,
+   *   decimals: 2,
+   *   assetName: 'asset',
+   *   unitName: 'unit',
+   *   url: 'url',
+   *   metadataHash: 'metadataHash',
+   *   defaultFrozen: false,
+   *   manager: 'MANAGERADDRESS',
+   *   reserve: 'RESERVEADDRESS',
+   *   freeze: 'FREEZEADDRESS',
+   *   clawback: 'CLAWBACKADDRESS',
+   *   lease: 'lease',
+   *   note: 'note',
+   *   // You wouldn't normally set this field
+   *   firstValidRound: 1000n,
+   *   validityWindow: 10,
+   *   extraFee: (1000).microAlgo(),
+   *   staticFee: (1000).microAlgo(),
+   *   // Max fee doesn't make sense with extraFee AND staticFee
+   *   //  already specified, but here for completeness
+   *   maxFee: (3000).microAlgo(),
+   * })
+   */
+  addAssetCreate(params: AssetCreateParams): TransactionComposer;
+  /**
+   * Add an asset config transaction to the transaction group.
+   * @param params The asset config transaction parameters
+   * @returns The composer so you can chain method calls
+   * @example Basic example
+   * ```typescript
+   * composer.addAssetConfig({ sender: "MANAGERADDRESS", assetId: 123456n, manager: "MANAGERADDRESS" })
+   * ```
+   * @example Advanced example
+   * ```typescript
+   * composer.addAssetConfig({
+   *   sender: 'MANAGERADDRESS',
+   *   assetId: 123456n,
+   *   manager: 'MANAGERADDRESS',
+   *   reserve: 'RESERVEADDRESS',
+   *   freeze: 'FREEZEADDRESS',
+   *   clawback: 'CLAWBACKADDRESS',
+   *   lease: 'lease',
+   *   note: 'note',
+   *   // You wouldn't normally set this field
+   *   firstValidRound: 1000n,
+   *   validityWindow: 10,
+   *   extraFee: (1000).microAlgo(),
+   *   staticFee: (1000).microAlgo(),
+   *   // Max fee doesn't make sense with extraFee AND staticFee
+   *   //  already specified, but here for completeness
+   *   maxFee: (3000).microAlgo(),
+   * })
+   */
+  addAssetConfig(params: AssetConfigParams): TransactionComposer;
+  /**
+   * Add an asset freeze transaction to the transaction group.
+   * @param params The asset freeze transaction parameters
+   * @returns The composer so you can chain method calls
+   * @example Basic example
+   * ```typescript
+   * composer.addAssetFreeze({ sender: "MANAGERADDRESS", assetId: 123456n, account: "ACCOUNTADDRESS", frozen: true })
+   * ```
+   * @example Advanced example
+   * ```typescript
+   * composer.addAssetFreeze({
+   *   sender: 'MANAGERADDRESS',
+   *   assetId: 123456n,
+   *   account: 'ACCOUNTADDRESS',
+   *   frozen: true,
+   *   lease: 'lease',
+   *   note: 'note',
+   *   // You wouldn't normally set this field
+   *   firstValidRound: 1000n,
+   *   validityWindow: 10,
+   *   extraFee: (1000).microAlgo(),
+   *   staticFee: (1000).microAlgo(),
+   *   // Max fee doesn't make sense with extraFee AND staticFee
+   *   //  already specified, but here for completeness
+   *   maxFee: (3000).microAlgo(),
+   * })
+   * ```
+   */
+  addAssetFreeze(params: AssetFreezeParams): TransactionComposer;
+  /**
+   * Add an asset destroy transaction to the transaction group.
+   * @param params The asset destroy transaction parameters
+   * @returns The composer so you can chain method calls
+   * @example Basic example
+   * ```typescript
+   * composer.addAssetDestroy({ sender: "MANAGERADDRESS", assetId: 123456n })
+   * ```
+   * @example Advanced example
+   * ```typescript
+   * composer.addAssetDestroy({
+   *   sender: 'MANAGERADDRESS',
+   *   assetId: 123456n,
+   *   lease: 'lease',
+   *   note: 'note',
+   *   // You wouldn't normally set this field
+   *   firstValidRound: 1000n,
+   *   validityWindow: 10,
+   *   extraFee: (1000).microAlgo(),
+   *   staticFee: (1000).microAlgo(),
+   *   // Max fee doesn't make sense with extraFee AND staticFee
+   *   //  already specified, but here for completeness
+   *   maxFee: (3000).microAlgo(),
+   * })
+   * ```
+   */
+  addAssetDestroy(params: AssetDestroyParams): TransactionComposer;
+  /**
+   * Add an asset transfer transaction to the transaction group.
+   * @param params The asset transfer transaction parameters
+   * @returns The composer so you can chain method calls
+   * @example Basic example
+   * ```typescript
+   * composer.addAssetTransfer({ sender: "HOLDERADDRESS", assetId: 123456n, amount: 1n, receiver: "RECEIVERADDRESS" })
+   * ```
+   * @example Advanced example (with clawback)
+   * ```typescript
+   * composer.addAssetTransfer({
+   *   sender: 'CLAWBACKADDRESS',
+   *   assetId: 123456n,
+   *   amount: 1n,
+   *   receiver: 'RECEIVERADDRESS',
+   *   clawbackTarget: 'HOLDERADDRESS',
+   *   // This field needs to be used with caution
+   *   closeAssetTo: 'ADDRESSTOCLOSETO'
+   *   lease: 'lease',
+   *   note: 'note',
+   *   // You wouldn't normally set this field
+   *   firstValidRound: 1000n,
+   *   validityWindow: 10,
+   *   extraFee: (1000).microAlgo(),
+   *   staticFee: (1000).microAlgo(),
+   *   // Max fee doesn't make sense with extraFee AND staticFee
+   *   //  already specified, but here for completeness
+   *   maxFee: (3000).microAlgo(),
+   * })
+   * ```
+   */
+  addAssetTransfer(params: AssetTransferParams): TransactionComposer;
+  /**
+   * Add an asset opt-in transaction to the transaction group.
+   * @param params The asset opt-in transaction parameters
+   * @returns The composer so you can chain method calls
+   * @example Basic example
+   * ```typescript
+   * composer.addAssetOptIn({ sender: "SENDERADDRESS", assetId: 123456n })
+   * ```
+   * @example Advanced example
+   * ```typescript
+   * composer.addAssetOptIn({
+   *   sender: 'SENDERADDRESS',
+   *   assetId: 123456n,
+   *   lease: 'lease',
+   *   note: 'note',
+   *   // You wouldn't normally set this field
+   *   firstValidRound: 1000n,
+   *   validityWindow: 10,
+   *   extraFee: (1000).microAlgo(),
+   *   staticFee: (1000).microAlgo(),
+   *   // Max fee doesn't make sense with extraFee AND staticFee
+   *   //  already specified, but here for completeness
+   *   maxFee: (3000).microAlgo(),
+   * })
+   * ```
+   */
+  addAssetOptIn(params: AssetOptInParams): TransactionComposer;
+  /**
+   * Add an asset opt-out transaction to the transaction group.
+   * @param params The asset opt-out transaction parameters
+   * @returns The composer so you can chain method calls
+   * @example Basic example (without creator, will be retrieved from algod)
+   * ```typescript
+   * composer.addAssetOptOut({ sender: "SENDERADDRESS", assetId: 123456n, ensureZeroBalance: true })
+   * ```
+   * @example Basic example (with creator)
+   * ```typescript
+   * composer.addAssetOptOut({ sender: "SENDERADDRESS", creator: "CREATORADDRESS", assetId: 123456n, ensureZeroBalance: true })
+   * ```
+   * @example Advanced example
+   * ```typescript
+   * composer.addAssetOptOut({
+   *   sender: 'SENDERADDRESS',
+   *   assetId: 123456n,
+   *   creator: 'CREATORADDRESS',
+   *   ensureZeroBalance: true,
+   *   lease: 'lease',
+   *   note: 'note',
+   *   // You wouldn't normally set this field
+   *   firstValidRound: 1000n,
+   *   validityWindow: 10,
+   *   extraFee: (1000).microAlgo(),
+   *   staticFee: (1000).microAlgo(),
+   *   // Max fee doesn't make sense with extraFee AND staticFee
+   *   //  already specified, but here for completeness
+   *   maxFee: (3000).microAlgo(),
+   * })
+   * ```
+   */
+  addAssetOptOut(params: AssetOptOutParams): TransactionComposer;
+  /**
+   * Add an application create transaction to the transaction group.
+   *
+   * Note: we recommend using app clients to make it easier to make app calls.
+   * @param params The application create transaction parameters
+   * @returns The composer so you can chain method calls
+   * @example Basic example
+   * ```typescript
+   * composer.addAppCreate({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE' })
+   * ```
+   * @example Advanced example
+   * ```typescript
+   * composer.addAppCreate({
+   *  sender: 'CREATORADDRESS',
+   *  approvalProgram: "TEALCODE",
+   *  clearStateProgram: "TEALCODE",
+   *  schema: {
+   *    globalInts: 1,
+   *    globalByteSlices: 2,
+   *    localInts: 3,
+   *    localByteSlices: 4
+   *  },
+   *  extraProgramPages: 1,
+   *  onComplete: OnApplicationComplete.OptIn,
+   *  args: [new Uint8Array(1, 2, 3, 4)]
+   *  accountReferences: ["ACCOUNT_1"]
+   *  appReferences: [123n, 1234n]
+   *  assetReferences: [12345n]
+   *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+   *  accessReferences: [{ appId: 1234n }]
+   *  lease: 'lease',
+   *  note: 'note',
+   *  // You wouldn't normally set this field
+   *  firstValidRound: 1000n,
+   *  validityWindow: 10,
+   *  extraFee: (1000).microAlgo(),
+   *  staticFee: (1000).microAlgo(),
+   *  // Max fee doesn't make sense with extraFee AND staticFee
+   *  //  already specified, but here for completeness
+   *  maxFee: (3000).microAlgo(),
+   *  rejectVersion: 1,
+   *  // Signer only needed if you want to provide one,
+   *  //  generally you'd register it with AlgorandClient
+   *  //  against the sender and not need to pass it in
+   *  signer: transactionSigner,
+   *  maxRoundsToWaitForConfirmation: 5,
+   *  suppressLog: true,
+   *})
+   * ```
+   */
+  addAppCreate(params: AppCreateParams): TransactionComposer;
+  /**
+   * Add an application update transaction to the transaction group.
+   *
+   * Note: we recommend using app clients to make it easier to make app calls.
+   * @param params The application update transaction parameters
+   * @returns The composer so you can chain method calls
+   * @example Basic example
+   * ```typescript
+   * composer.addAppUpdate({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE' })
+   * ```
+   * @example Advanced example
+   * ```typescript
+   * composer.addAppUpdate({
+   *  sender: 'CREATORADDRESS',
+   *  approvalProgram: "TEALCODE",
+   *  clearStateProgram: "TEALCODE",
+   *  onComplete: OnApplicationComplete.UpdateApplication,
+   *  args: [new Uint8Array(1, 2, 3, 4)]
+   *  accountReferences: ["ACCOUNT_1"]
+   *  appReferences: [123n, 1234n]
+   *  assetReferences: [12345n]
+   *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+   *  accessReferences: [{ appId: 1234n }]
+   *  lease: 'lease',
+   *  note: 'note',
+   *  // You wouldn't normally set this field
+   *  firstValidRound: 1000n,
+   *  validityWindow: 10,
+   *  extraFee: (1000).microAlgo(),
+   *  staticFee: (1000).microAlgo(),
+   *  // Max fee doesn't make sense with extraFee AND staticFee
+   *  //  already specified, but here for completeness
+   *  maxFee: (3000).microAlgo(),
+   *  rejectVersion: 1,
+   *})
+   * ```
+   */
+  addAppUpdate(params: AppUpdateParams): TransactionComposer;
+  /**
+   * Add an application delete transaction to the transaction group.
+   *
+   * Note: we recommend using app clients to make it easier to make app calls.
+   * @param params The application delete transaction parameters
+   * @returns The composer so you can chain method calls
+   * @example Basic example
+   * ```typescript
+   * composer.addAppDelete({ sender: 'CREATORADDRESS' })
+   * ```
+   * @example Advanced example
+   * ```typescript
+   * composer.addAppDelete({
+   *  sender: 'CREATORADDRESS',
+   *  onComplete: OnApplicationComplete.DeleteApplication,
+   *  args: [new Uint8Array(1, 2, 3, 4)]
+   *  accountReferences: ["ACCOUNT_1"]
+   *  appReferences: [123n, 1234n]
+   *  assetReferences: [12345n]
+   *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+   *  accessReferences: [{ appId: 1234n }]
+   *  lease: 'lease',
+   *  note: 'note',
+   *  // You wouldn't normally set this field
+   *  firstValidRound: 1000n,
+   *  validityWindow: 10,
+   *  extraFee: (1000).microAlgo(),
+   *  staticFee: (1000).microAlgo(),
+   *  // Max fee doesn't make sense with extraFee AND staticFee
+   *  //  already specified, but here for completeness
+   *  maxFee: (3000).microAlgo(),
+   *  rejectVersion: 1,
+   *})
+   * ```
+   */
+  addAppDelete(params: AppDeleteParams): TransactionComposer;
+  /**
+   * Add an application call transaction to the transaction group.
+   *
+   * If you want to create or update an app use `addAppCreate` or `addAppUpdate`.
+   *
+   * Note: we recommend using app clients to make it easier to make app calls.
+   * @param params The application call transaction parameters
+   * @returns The composer so you can chain method calls
+   * @example Basic example
+   * ```typescript
+   * composer.addAppCall({ sender: 'CREATORADDRESS' })
+   * ```
+   * @example Advanced example
+   * ```typescript
+   * composer.addAppCall({
+   *  sender: 'CREATORADDRESS',
+   *  onComplete: OnApplicationComplete.OptIn,
+   *  args: [new Uint8Array(1, 2, 3, 4)]
+   *  accountReferences: ["ACCOUNT_1"]
+   *  appReferences: [123n, 1234n]
+   *  assetReferences: [12345n]
+   *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+   *  accessReferences: [{ appId: 1234n }]
+   *  lease: 'lease',
+   *  note: 'note',
+   *  // You wouldn't normally set this field
+   *  firstValidRound: 1000n,
+   *  validityWindow: 10,
+   *  extraFee: (1000).microAlgo(),
+   *  staticFee: (1000).microAlgo(),
+   *  // Max fee doesn't make sense with extraFee AND staticFee
+   *  //  already specified, but here for completeness
+   *  maxFee: (3000).microAlgo(),
+   *  rejectVersion: 1,
+   *})
+   * ```
+   */
+  addAppCall(params: AppCallParams): TransactionComposer;
+  /**
+   * Add an ABI method create application call transaction to the transaction group.
+   *
+   * Note: we recommend using app clients to make it easier to make app calls.
+   * @param params The ABI create method application call transaction parameters
+   * @returns The composer so you can chain method calls
+   * @example Basic example
+   * ```typescript
+   * const method = new ABIMethod({
+   *   name: 'method',
+   *   args: [{ name: 'arg1', type: 'string' }],
+   *   returns: { type: 'string' },
+   * })
+   * composer.addAppCreateMethodCall({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE', method: method, args: ["arg1_value"] })
+   * ```
+   * @example Advanced example
+   * ```typescript
+   * const method = new ABIMethod({
+   *   name: 'method',
+   *   args: [{ name: 'arg1', type: 'string' }],
+   *   returns: { type: 'string' },
+   * })
+   * composer.addAppCreateMethodCall({
+   *  sender: 'CREATORADDRESS',
+   *  method: method,
+   *  args: ["arg1_value"],
+   *  approvalProgram: "TEALCODE",
+   *  clearStateProgram: "TEALCODE",
+   *  schema: {
+   *    globalInts: 1,
+   *    globalByteSlices: 2,
+   *    localInts: 3,
+   *    localByteSlices: 4
+   *  },
+   *  extraProgramPages: 1,
+   *  onComplete: OnApplicationComplete.OptIn,
+   *  args: [new Uint8Array(1, 2, 3, 4)]
+   *  accountReferences: ["ACCOUNT_1"]
+   *  appReferences: [123n, 1234n]
+   *  assetReferences: [12345n]
+   *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+   *  accessReferences: [{ appId: 1234n }]
+   *  lease: 'lease',
+   *  note: 'note',
+   *  // You wouldn't normally set this field
+   *  firstValidRound: 1000n,
+   *  validityWindow: 10,
+   *  extraFee: (1000).microAlgo(),
+   *  staticFee: (1000).microAlgo(),
+   *  // Max fee doesn't make sense with extraFee AND staticFee
+   *  //  already specified, but here for completeness
+   *  maxFee: (3000).microAlgo(),
+   *  rejectVersion: 1,
+   *})
+   * ```
+   */
+  addAppCreateMethodCall(params: AppCreateMethodCall): this;
+  /**
+   * Add an ABI method update application call transaction to the transaction group.
+   *
+   * Note: we recommend using app clients to make it easier to make app calls.
+   * @param params The ABI update method application call transaction parameters
+   * @returns The composer so you can chain method calls
+   * @example Basic example
+   * ```typescript
+   * const method = new ABIMethod({
+   *   name: 'method',
+   *   args: [{ name: 'arg1', type: 'string' }],
+   *   returns: { type: 'string' },
+   * })
+   * composer.addAppUpdateMethodCall({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE', method: method, args: ["arg1_value"] })
+   * ```
+   * @example Advanced example
+   * ```typescript
+   * const method = new ABIMethod({
+   *   name: 'method',
+   *   args: [{ name: 'arg1', type: 'string' }],
+   *   returns: { type: 'string' },
+   * })
+   * composer.addAppUpdateMethodCall({
+   *  sender: 'CREATORADDRESS',
+   *  method: method,
+   *  args: ["arg1_value"],
+   *  approvalProgram: "TEALCODE",
+   *  clearStateProgram: "TEALCODE",
+   *  onComplete: OnApplicationComplete.UpdateApplication,
+   *  args: [new Uint8Array(1, 2, 3, 4)]
+   *  accountReferences: ["ACCOUNT_1"]
+   *  appReferences: [123n, 1234n]
+   *  assetReferences: [12345n]
+   *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+   *  accessReferences: [{ appId: 1234n }]
+   *  lease: 'lease',
+   *  note: 'note',
+   *  // You wouldn't normally set this field
+   *  firstValidRound: 1000n,
+   *  validityWindow: 10,
+   *  extraFee: (1000).microAlgo(),
+   *  staticFee: (1000).microAlgo(),
+   *  // Max fee doesn't make sense with extraFee AND staticFee
+   *  //  already specified, but here for completeness
+   *  maxFee: (3000).microAlgo(),
+   *  rejectVersion: 1,
+   *})
+   * ```
+   */
+  addAppUpdateMethodCall(params: AppUpdateMethodCall): this;
+  /**
+   * Add an ABI method delete application call transaction to the transaction group.
+   *
+   * Note: we recommend using app clients to make it easier to make app calls.
+   * @param params The ABI delete method application call transaction parameters
+   * @returns The composer so you can chain method calls
+   * @example Basic example
+   * ```typescript
+   * const method = new ABIMethod({
+   *   name: 'method',
+   *   args: [{ name: 'arg1', type: 'string' }],
+   *   returns: { type: 'string' },
+   * })
+   * composer.addAppDeleteMethodCall({ sender: 'CREATORADDRESS', method: method, args: ["arg1_value"] })
+   * ```
+   * @example Advanced example
+   * ```typescript
+   * const method = new ABIMethod({
+   *   name: 'method',
+   *   args: [{ name: 'arg1', type: 'string' }],
+   *   returns: { type: 'string' },
+   * })
+   * composer.addAppDeleteMethodCall({
+   *  sender: 'CREATORADDRESS',
+   *  method: method,
+   *  args: ["arg1_value"],
+   *  onComplete: OnApplicationComplete.DeleteApplication,
+   *  args: [new Uint8Array(1, 2, 3, 4)]
+   *  accountReferences: ["ACCOUNT_1"]
+   *  appReferences: [123n, 1234n]
+   *  assetReferences: [12345n]
+   *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+   *  accessReferences: [{ appId: 1234n }]
+   *  lease: 'lease',
+   *  note: 'note',
+   *  // You wouldn't normally set this field
+   *  firstValidRound: 1000n,
+   *  validityWindow: 10,
+   *  extraFee: (1000).microAlgo(),
+   *  staticFee: (1000).microAlgo(),
+   *  // Max fee doesn't make sense with extraFee AND staticFee
+   *  //  already specified, but here for completeness
+   *  maxFee: (3000).microAlgo(),
+   *  rejectVersion: 1,
+   *})
+   * ```
+   */
+  addAppDeleteMethodCall(params: AppDeleteMethodCall): this;
+  /**
+   * Add a non-create/non-update ABI method application call transaction to the transaction group.
+   *
+   * Note: we recommend using app clients to make it easier to make app calls.
+   * @param params The ABI method application call transaction parameters
+   * @returns The composer so you can chain method calls
+   * @example Basic example
+   * ```typescript
+   * const method = new ABIMethod({
+   *   name: 'method',
+   *   args: [{ name: 'arg1', type: 'string' }],
+   *   returns: { type: 'string' },
+   * })
+   * composer.addAppCallMethodCall({ sender: 'CREATORADDRESS', method: method, args: ["arg1_value"] })
+   * ```
+   * @example Advanced example
+   * ```typescript
+   * const method = new ABIMethod({
+   *   name: 'method',
+   *   args: [{ name: 'arg1', type: 'string' }],
+   *   returns: { type: 'string' },
+   * })
+   * composer.addAppCallMethodCall({
+   *  sender: 'CREATORADDRESS',
+   *  method: method,
+   *  args: ["arg1_value"],
+   *  onComplete: OnApplicationComplete.OptIn,
+   *  args: [new Uint8Array(1, 2, 3, 4)]
+   *  accountReferences: ["ACCOUNT_1"]
+   *  appReferences: [123n, 1234n]
+   *  assetReferences: [12345n]
+   *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+   *  accessReferences: [{ appId: 1234n }]
+   *  lease: 'lease',
+   *  note: 'note',
+   *  // You wouldn't normally set this field
+   *  firstValidRound: 1000n,
+   *  validityWindow: 10,
+   *  extraFee: (1000).microAlgo(),
+   *  staticFee: (1000).microAlgo(),
+   *  // Max fee doesn't make sense with extraFee AND staticFee
+   *  //  already specified, but here for completeness
+   *  maxFee: (3000).microAlgo(),
+   *  rejectVersion: 1,
+   *})
+   * ```
+   */
+  addAppCallMethodCall(params: AppCallMethodCall): this;
+  /**
+   * Add an online key registration transaction to the transaction group.
+   * @param params The online key registration transaction parameters
+   * @returns The composer so you can chain method calls
+   * @example Basic example
+   * ```typescript
+   * composer.addOnlineKeyRegistration({
+   *   sender: 'SENDERADDRESS',
+   *   voteKey: Uint8Array.from(Buffer.from("voteKeyBase64", 'base64')),
+   *   selectionKey: Uint8Array.from(Buffer.from("selectionKeyBase64", 'base64')),
+   *   stateProofKey: Uint8Array.from(Buffer.from("stateProofKeyBase64", 'base64')),
+   *   voteFirst: 1n,
+   *   voteLast: 1000n,
+   *   voteKeyDilution: 1n,
+   * })
+   * ```
+   * @example Advanced example
+   * ```typescript
+   * composer.addOnlineKeyRegistration({
+   *   sender: 'SENDERADDRESS',
+   *   voteKey: Uint8Array.from(Buffer.from("voteKeyBase64", 'base64')),
+   *   selectionKey: Uint8Array.from(Buffer.from("selectionKeyBase64", 'base64')),
+   *   stateProofKey: Uint8Array.from(Buffer.from("stateProofKeyBase64", 'base64')),
+   *   voteFirst: 1n,
+   *   voteLast: 1000n,
+   *   voteKeyDilution: 1n,
+   *   lease: 'lease',
+   *   note: 'note',
+   *   // Use this with caution, it's generally better to use algorand.account.rekeyAccount
+   *   rekeyTo: 'REKEYTOADDRESS',
+   *   // You wouldn't normally set this field
+   *   firstValidRound: 1000n,
+   *   validityWindow: 10,
+   *   extraFee: (1000).microAlgo(),
+   *   staticFee: (1000).microAlgo(),
+   *   // Max fee doesn't make sense with extraFee AND staticFee
+   *   //  already specified, but here for completeness
+   *   maxFee: (3000).microAlgo(),
+   * })
+   * ```
+   */
+  addOnlineKeyRegistration(params: OnlineKeyRegistrationParams): TransactionComposer;
+  /**
+   * Add an offline key registration transaction to the transaction group.
+   * @param params The offline key registration transaction parameters
+   * @returns The composer so you can chain method calls
+   * @example Basic example
+   * ```typescript
+   * composer.addOfflineKeyRegistration({
+   *   sender: 'SENDERADDRESS',
+   * })
+   * ```
+   * @example Advanced example
+   * ```typescript
+   * composer.addOfflineKeyRegistration({
+   *   sender: 'SENDERADDRESS',
+   *   lease: 'lease',
+   *   note: 'note',
+   *   // Use this with caution, it's generally better to use algorand.account.rekeyAccount
+   *   rekeyTo: 'REKEYTOADDRESS',
+   *   // You wouldn't normally set this field
+   *   firstValidRound: 1000n,
+   *   validityWindow: 10,
+   *   extraFee: (1000).microAlgo(),
+   *   staticFee: (1000).microAlgo(),
+   *   // Max fee doesn't make sense with extraFee AND staticFee
+   *   //  already specified, but here for completeness
+   *   maxFee: (3000).microAlgo(),
+   * })
+   * ```
+   */
+  addOfflineKeyRegistration(params: OfflineKeyRegistrationParams): TransactionComposer;
+  /**
+   * Get the number of transactions currently added to this composer.
+   * @returns The number of transactions currently added to this composer
+   */
+  count(): number;
+  /**
+   * Build the transaction composer.
+   *
+   * This method performs resource population and inner transaction fee coverage if these options are set in the composer.
+   *
+   * Once this method is called, no further transactions will be able to be added.
+   * You can safely call this method multiple times to get the same result.
+   * @returns The built transaction composer, the transactions and any corresponding method calls
+   * @example
+   * ```typescript
+   * const { transactions, methodCalls } = await composer.build()
+   * ```
+   */
+  build(): Promise<{
+    transactions: TransactionWithSigner[];
+    methodCalls: Map<number, ABIMethod>;
+  }>;
+  private _buildTransactions;
+  /**
+   * Builds all transactions in the composer and returns them along with method calls and signers.
+   *
+   * Note: This method only builds the transactions as-is without resource population or automatic grouping.
+   * Use this when you need the raw transactions.
+   * @returns An object containing the array of built transactions, method calls, and signers
+   * @example
+   * ```typescript
+   * const { transactions, methodCalls, signers } = await composer.buildTransactions()
+   * ```
+   */
+  buildTransactions(): Promise<BuiltTransactions>;
+  private populateTransactionAndGroupResources;
+  private analyzeGroupRequirements;
+  /**
+   * Rebuild the group, discarding any previously built transactions.
+   * This will potentially cause new signers and suggested params to be used if the callbacks return a new value compared to the first build.
+   * @returns The newly built transaction composer and the transactions
+   * @example
+   * ```typescript
+   * const { atc, transactions, methodCalls } = await composer.rebuild()
+   * ```
+   */
+  rebuild(): Promise<{
+    transactions: TransactionWithSigner[];
+    methodCalls: Map<number, ABIMethod>;
+  }>;
+  private reset;
+  /**
+   * Compose the transaction group and send it to the network.
+   * @param params The parameters to control execution with
+   * @returns The execution result
+   * @example
+   * ```typescript
+   * const result = await composer.send()
+   * ```
+   */
+  send(params?: SendParams): Promise<SendTransactionComposerResults>;
+  /**
+   * Compose the transaction group and simulate sending it to the network
+   * @returns The simulation result
+   * @example
+   * ```typescript
+   * const result = await composer.simulate()
+   * ```
+   */
+  simulate(): Promise<SendTransactionComposerResults & {
+    simulateResponse: SimulateResponse;
+  }>;
+  /**
+   * Compose the transaction group and simulate sending it to the network
+   * @returns The simulation result
+   * @example
+   * ```typescript
+   * const result = await composer.simulate({
+   *   skipSignatures: true,
+   * })
+   * ```
+   */
+  simulate(options: SkipSignaturesSimulateOptions): Promise<SendTransactionComposerResults & {
+    simulateResponse: SimulateResponse;
+  }>;
+  /**
+   * Compose the transaction group and simulate sending it to the network
+   * @returns The simulation result
+   * @example
+   * ```typescript
+   * const result = await composer.simulate({
+   *   extraOpcodeBudget: 1000,
+   * })
+   * ```
+   */
+  simulate(options: RawSimulateOptions): Promise<SendTransactionComposerResults & {
+    simulateResponse: SimulateResponse;
+  }>;
+  /**
+   * Create an encoded transaction note that follows the ARC-2 spec.
+   *
+   * https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0002.md
+   * @param note The ARC-2 transaction note data
+   * @returns The binary encoded transaction note
+   */
+  static arc2Note(note: Arc2TransactionNote): Uint8Array;
+  gatherSignatures(): Promise<Uint8Array[]>;
+  private signTransactions;
+  private parseAbiReturnValues;
+  setMaxFees(maxFees: Map<number, AlgoAmount>): void;
+}
+//#endregion
+export { type AppCallMethodCall, type AppCallParams, type AppCreateMethodCall, type AppCreateParams, type AppDeleteMethodCall, type AppDeleteParams, type AppMethodCall, type AppMethodCallParams, type AppMethodCallTransactionArgument, type AppUpdateMethodCall, type AppUpdateParams, type AssetConfigParams, type AssetCreateParams, type AssetDestroyParams, type AssetFreezeParams, type AssetOptInParams, type AssetOptOutParams, type AssetTransferParams, BuiltTransactions, type CommonAppCallParams, type CommonTransactionParams, ErrorTransformer, type OfflineKeyRegistrationParams, type OnlineKeyRegistrationParams, type PaymentParams, type ProcessedAppCallMethodCall, type ProcessedAppCreateMethodCall, type ProcessedAppUpdateMethodCall, RawSimulateOptions, SimulateOptions, SkipSignaturesSimulateOptions, TransactionComposer, TransactionComposerConfig, TransactionComposerParams };
+//# sourceMappingURL=composer.d.ts.map