@algorandfoundation/algokit-utils 9.2.0 → 10.0.0-alpha.10

package/types/testing.d.ts

@@ -1,150 +1,156 @@
-import algosdk, { Address } from 'algosdk';
-import { TransactionLogger } from '../testing';
-import { TestLogger } from '../testing/test-logger';
-import { AlgoAmount } from '../types/amount';
-import { MultisigAccount, SigningAccount, TransactionSignerAccount } from './account';
-import { AlgorandClient } from './algorand-client';
-import { AlgoConfig } from './network-client';
-import Account = algosdk.Account;
-import Algodv2 = algosdk.Algodv2;
-import Indexer = algosdk.Indexer;
-import Kmd = algosdk.Kmd;
-import LogicSigAccount = algosdk.LogicSigAccount;
-import Transaction = algosdk.Transaction;
+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 "../testing/test-logger.js";
+import { TransactionLogger } from "../testing/transaction-logger.js";
+
+//#region src/types/testing.d.ts
 /**
  * Test automation context.
  */
-export 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: Algodv2;
-    /** Indexer client instance */
-    indexer: Indexer;
-    /** KMD client instance */
-    kmd: Kmd;
-    /** 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 & TransactionSignerAccount & Account;
-    /** Generate and fund an additional ephemerally created account */
-    generateAccount: (params: GetTestAccountParams) => Promise<Address & Account & TransactionSignerAccount>;
-    /** 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<algosdk.indexerModels.TransactionResponse>;
+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.
  */
-export 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<Account>;
+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<AddressWithSigners>;
 }
 /** Configuration for creating an Algorand testing fixture. */
-export 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?: Algodv2;
-    /** 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?: Indexer;
-    /** 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?: Kmd;
-    /** 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?: (algod: Algodv2, kmd?: Kmd) => Promise<Account>;
+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?: (algod: AlgodClient, kmd?: KmdClient) => Promise<AddressWithSigners>;
 }
 /** An Algorand automated testing fixture */
-export 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>;
+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.
  */
-export 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 | Account | SigningAccount | LogicSigAccount | MultisigAccount | TransactionSignerAccount)[];
-    /** Any app IDs to replace predictably */
-    apps?: (string | number | bigint)[];
-    /** Optional filter predicate to filter out logs */
-    filterPredicate?: (log: string) => boolean;
+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;
 }
-export 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;
+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=testing.d.ts.map

package/types/testing.js

@@ -1,3 +0,0 @@
-'use strict';
-
-//# sourceMappingURL=testing.js.map

package/types/testing.mjs

@@ -1,2 +0,0 @@
-
-//# sourceMappingURL=testing.mjs.map

package/types/transaction.d.ts

@@ -1,148 +1,133 @@
-import algosdk from 'algosdk';
-import { MultisigAccount, SigningAccount, TransactionSignerAccount } from './account';
-import { AlgoAmount } from './amount';
-import { ABIReturn } from './app';
-import { Expand } from './expand';
-import Account = algosdk.Account;
-import AtomicTransactionComposer = algosdk.AtomicTransactionComposer;
-import LogicSigAccount = algosdk.LogicSigAccount;
-import Transaction = algosdk.Transaction;
-import modelsv2 = algosdk.modelsv2;
-export type TransactionNote = Uint8Array | TransactionNoteData | Arc2TransactionNote;
-export type TransactionNoteData = string | null | undefined | number | any[] | Record<string, any>;
+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 { Expand } from "./expand.js";
+import { TransactionComposer } from "./composer.js";
+
+//#region src/types/transaction.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 */
-export type Arc2TransactionNote = {
-    dAppName: string;
-    format: 'm' | 'b' | 'u';
-    data: string;
+type Arc2TransactionNote = {
+  dAppName: string;
+  format: 'm' | 'b' | 'u';
+  data: string;
 } | {
-    dAppName: string;
-    format: 'j';
-    data: TransactionNoteData;
+  dAppName: string;
+  format: 'j';
+  data: TransactionNoteData;
 };
 /** The sending configuration for a transaction */
-export 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 `AtomicTransactionComposer` to add the transaction to, if specified then `skipSending: undefined` has the same effect as `skipSending: true` */
-    atc?: AtomicTransactionComposer;
-    /** 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;
+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. */
-export type SendSingleTransactionResult = Expand<SendAtomicTransactionComposerResults & ConfirmedTransactionResult>;
+type SendSingleTransactionResult = Expand<SendTransactionComposerResults & ConfirmedTransactionResult>;
 /** The result of sending a transaction */
-export interface SendTransactionResult {
-    /** The transaction */
-    transaction: Transaction;
-    /** The response if the transaction was sent and waited for */
-    confirmation?: modelsv2.PendingTransactionResponse;
+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 */
-export 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?: modelsv2.PendingTransactionResponse[];
+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 `AtomicTransactionComposer` */
-export interface SendAtomicTransactionComposerResults extends SendTransactionResults {
-    /** base64 encoded representation of the group ID of the atomic group */
-    groupId: string;
-    /** 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: modelsv2.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 */
-export interface ConfirmedTransactionResult extends SendTransactionResult {
-    /** The response from sending and waiting for the transaction */
-    confirmation: modelsv2.PendingTransactionResponse;
+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 */
-export interface ConfirmedTransactionResults extends SendTransactionResult, SendTransactionResults {
-    /** The response from sending and waiting for the primary transaction */
-    confirmation: modelsv2.PendingTransactionResponse;
-    /** The response from sending and waiting for the transactions */
-    confirmations: modelsv2.PendingTransactionResponse[];
+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[];
 }
-/** Core account abstraction when signing/sending transactions
- *
- * This type is used across the entire AlgoKit Utils library and allows you to pass through
- * many types of accounts, including:
- * * `Account` - The in-built `algosdk.Account` type for mnemonic accounts
- * * `SigningAccount` - An AlgoKit Utils class that wraps Account to provide support for rekeyed accounts
- * * `LogicSigAccount` - The in-built `algosdk.LogicSigAccount` type for logic signatures
- * * `MultisigAccount` - An AlgoKit Utils class that wraps a multisig account and provides mechanisms to get a multisig account
- * * `TransactionSignerAccount` - An AlgoKit Utils class that wraps the in-built `algosdk.TransactionSigner` along with the sender address
+/**
+ * @deprcated Use `SendingAddress` instead
  */
-export type SendTransactionFrom = Account | SigningAccount | LogicSigAccount | MultisigAccount | TransactionSignerAccount;
+type SendTransactionFrom = AddressWithTransactionSigner;
 /** Defines an unsigned transaction that will appear in a group of transactions along with its signing information */
-export 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: SendTransactionFrom;
+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 atomic group
+/** A group of transactions to send together as an group
  * https://dev.algorand.co/concepts/transactions/atomic-txn-groups/
  */
-export 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?: SendTransactionFrom;
+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. */
-export 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;
+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 `AtomicTransactionComposer`. */
-export interface AdditionalAtomicTransactionComposerContext {
-    /** A map of transaction index in the `AtomicTransactionComposer` to the max fee that can be calculated for a transaction in the group */
-    maxFees: Map<number, AlgoAmount>;
-    suggestedParams: Pick<algosdk.SuggestedParams, 'fee' | 'minFee'>;
+/** 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 `AtomicTransactionComposer` with transactions to send. */
-export interface AtomicTransactionComposerToSend extends SendParams {
-    /** The `AtomicTransactionComposer` with transactions loaded to send */
-    atc: AtomicTransactionComposer;
-    /**
-     * @deprecated - set the parameters at the top level instead
-     * Any parameters to control the semantics of the send to the network */
-    sendParams?: Omit<SendTransactionParams, 'fee' | 'maxFee' | 'skipSending' | 'atc'>;
-    /**
-     * Additional `AtomicTransactionComposer` context used when building the transaction group that is sent.
-     * This additional context is used and must be supplied when coverAppCallInnerTransactionFees is set to true.
-     **/
-    additionalAtcContext?: AdditionalAtomicTransactionComposerContext;
+/** 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=transaction.d.ts.map

package/types/transaction.js

@@ -1,3 +0,0 @@
-'use strict';
-
-//# sourceMappingURL=transaction.js.map

package/types/transaction.mjs

@@ -1,2 +0,0 @@
-
-//# sourceMappingURL=transaction.mjs.map