@algorandfoundation/algokit-utils 9.2.1-beta.3 → 9.2.2-beta.1

package/package.json

@@ -6,7 +6,7 @@
     "**"
   ],
   "name": "@algorandfoundation/algokit-utils",
-  "version": "9.2.1-beta.3",
+  "version": "9.2.2-beta.1",
   "private": false,
   "description": "A set of core Algorand utilities written in TypeScript and released via npm that make it easier to build solutions on Algorand.",
   "author": "Algorand Foundation",

package/testing/_asset.d.ts

@@ -0,0 +1,3 @@
+import { Address } from 'algosdk';
+import { AlgorandClient } from '../types/algorand-client';
+export declare function generateTestAsset(algorand: AlgorandClient, sender: Address | string, total?: number): Promise<bigint>;

package/testing/account.d.ts

@@ -1,9 +1,10 @@
-import { TransactionSignerAccount } from "../types/account.js";
-import { AlgorandClient } from "../types/algorand-client.js";
-import { GetTestAccountParams } from "../types/testing.js";
-import algosdk, { Address } from "algosdk";
-
-//#region src/testing/account.d.ts
+import algosdk, { Address } from 'algosdk';
+import { AlgorandClient } from '../';
+import { TransactionSignerAccount } from '../types/account';
+import { GetTestAccountParams } from '../types/testing';
+import Account = algosdk.Account;
+import Algodv2 = algosdk.Algodv2;
+import Kmd = algosdk.Kmd;
 /**
  * @deprecated Use `getTestAccount(params, algorandClient)` instead. The `algorandClient` object can be created using `AlgorandClient.fromClients({ algod, kmd })`.
  *
@@ -16,7 +17,7 @@ import algosdk, { Address } from "algosdk";
  * @param kmd A KMD client, if not specified then a default KMD client will be loaded from environment variables and if not found fallback to the default LocalNet KMD client
  * @returns The account, with private key loaded
  */
-declare function getTestAccount(params: GetTestAccountParams, algod: Algodv2, kmd?: Kmd): Promise<Address & Account & TransactionSignerAccount>;
+export declare function getTestAccount(params: GetTestAccountParams, algod: Algodv2, kmd?: Kmd): Promise<Address & Account & TransactionSignerAccount>;
 /**
  * Creates an ephemeral Algorand account for the purposes of testing.
  * Returns a newly created random test account that is funded from the dispenser
@@ -26,7 +27,4 @@ declare function getTestAccount(params: GetTestAccountParams, algod: Algodv2, km
  * @param algorand An AlgorandClient client
  * @returns The account, with private key loaded
  */
-declare function getTestAccount(params: GetTestAccountParams, algorand: AlgorandClient): Promise<Address & Account & TransactionSignerAccount>;
-//#endregion
-export { getTestAccount };
-//# sourceMappingURL=account.d.ts.map
+export declare function getTestAccount(params: GetTestAccountParams, algorand: AlgorandClient): Promise<Address & Account & TransactionSignerAccount>;

package/testing/fixtures/algokit-log-capture-fixture.d.ts

@@ -1,6 +1,4 @@
-import { AlgoKitLogCaptureFixture } from "../../types/testing.js";
-
-//#region src/testing/fixtures/algokit-log-capture-fixture.d.ts
+import { AlgoKitLogCaptureFixture } from '../../types/testing';
 /**
  * Creates a test fixture for capturing AlgoKit logs.
  *
@@ -18,7 +16,4 @@ import { AlgoKitLogCaptureFixture } from "../../types/testing.js";
  *
  * @returns The fixture
  */
-declare const algoKitLogCaptureFixture: () => AlgoKitLogCaptureFixture;
-//#endregion
-export { algoKitLogCaptureFixture };
-//# sourceMappingURL=algokit-log-capture-fixture.d.ts.map
+export declare const algoKitLogCaptureFixture: () => AlgoKitLogCaptureFixture;

package/testing/fixtures/algorand-fixture.d.ts

@@ -1,7 +1,5 @@
-import { AlgoConfig } from "../../types/network-client.js";
-import { AlgorandFixture, AlgorandFixtureConfig } from "../../types/testing.js";
-
-//#region src/testing/fixtures/algorand-fixture.d.ts
+import { AlgoConfig } from '../../types/network-client';
+import { AlgorandFixture, AlgorandFixtureConfig } from '../../types/testing';
 /**
  * Creates a test fixture for automated testing against Algorand.
  * By default it tests against an environment variable specified client
@@ -52,7 +50,7 @@ import { AlgorandFixture, AlgorandFixtureConfig } from "../../types/testing.js";
  * @param fixtureConfig The fixture configuration
  * @returns The fixture
  */
-declare function algorandFixture(fixtureConfig?: AlgorandFixtureConfig): AlgorandFixture;
+export declare function algorandFixture(fixtureConfig?: AlgorandFixtureConfig): AlgorandFixture;
 /**
  * @deprecated Config can be passed in directly to fixture config now.
  *
@@ -66,7 +64,4 @@ declare function algorandFixture(fixtureConfig?: AlgorandFixtureConfig): Algoran
  * @param config The fixture configuration
  * @returns The fixture
  */
-declare function algorandFixture(fixtureConfig: AlgorandFixtureConfig | undefined, config: AlgoConfig): AlgorandFixture;
-//#endregion
-export { algorandFixture };
-//# sourceMappingURL=algorand-fixture.d.ts.map
+export declare function algorandFixture(fixtureConfig: AlgorandFixtureConfig | undefined, config: AlgoConfig): AlgorandFixture;

package/testing/fixtures/index.d.ts

@@ -0,0 +1,2 @@
+export * from './algokit-log-capture-fixture';
+export * from './algorand-fixture';

package/testing/index.d.ts

@@ -1,7 +1,5 @@
-import { TestLogger } from "./test-logger.js";
-import { getTestAccount } from "./account.js";
-import { algoKitLogCaptureFixture } from "./fixtures/algokit-log-capture-fixture.js";
-import { algorandFixture } from "./fixtures/algorand-fixture.js";
-import { runWhenIndexerCaughtUp } from "./indexer.js";
-import { TransactionLogger } from "./transaction-logger.js";
-export { TestLogger, TransactionLogger, algoKitLogCaptureFixture, algorandFixture, getTestAccount, runWhenIndexerCaughtUp };
+export * from './account';
+export * from './fixtures';
+export * from './indexer';
+export * from './test-logger';
+export * from './transaction-logger';

package/testing/indexer.d.ts

@@ -1,4 +1,3 @@
-//#region src/testing/indexer.d.ts
 /**
  * Runs the given indexer call until a 404 error is no longer returned.
  * Tried every 200ms up to 100 times.
@@ -10,7 +9,4 @@
  * @param run The code to run
  * @returns The result (as a promise), or throws if the indexer didn't catch up in time
  */
-declare function runWhenIndexerCaughtUp<T>(run: () => Promise<T>): Promise<T>;
-//#endregion
-export { runWhenIndexerCaughtUp };
-//# sourceMappingURL=indexer.d.ts.map
+export declare function runWhenIndexerCaughtUp<T>(run: () => Promise<T>): Promise<T>;

package/testing/test-logger.d.ts

@@ -1,45 +1,40 @@
-import { Logger } from "../types/logging.js";
-import { LogSnapshotConfig } from "../types/testing.js";
-
-//#region src/testing/test-logger.d.ts
+import { Logger } from '../types/logging';
+import { LogSnapshotConfig } from '../types/testing';
 /** Exposes an AlgoKit logger which captures log messages, while wrapping an original logger.
  * This is useful for automated testing.
  */
-declare class TestLogger implements Logger {
-  private originalLogger;
-  private logs;
-  /**
-   * Create a new test logger that wraps the given logger if provided.
-   * @param originalLogger The optional original logger to wrap.
-   */
-  constructor(originalLogger?: Logger);
-  /** Returns all logs captured thus far. */
-  get capturedLogs(): string[];
-  /** Clears all logs captured so far. */
-  clear(): void;
-  /**
-   * Returns 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.
-   *
-   * https://jestjs.io/docs/snapshot-testing#2-tests-should-be-deterministic
-   *
-   * @example Jest Example
-   * ```typescript
-   * const logger = new TestLogger()
-   * ...
-   * expect(logger.getLogSnapshot()).toMatchSnapshot()
-   * ```
-   * @param config The snapshot configuration
-   * @returns The snapshotted logs.
-   */
-  getLogSnapshot(config?: LogSnapshotConfig): string;
-  error(message: string, ...optionalParams: unknown[]): void;
-  warn(message: string, ...optionalParams: unknown[]): void;
-  info(message: string, ...optionalParams: unknown[]): void;
-  verbose(message: string, ...optionalParams: unknown[]): void;
-  debug(message: string, ...optionalParams: unknown[]): void;
+export declare class TestLogger implements Logger {
+    private originalLogger;
+    private logs;
+    /**
+     * Create a new test logger that wraps the given logger if provided.
+     * @param originalLogger The optional original logger to wrap.
+     */
+    constructor(originalLogger?: Logger);
+    /** Returns all logs captured thus far. */
+    get capturedLogs(): string[];
+    /** Clears all logs captured so far. */
+    clear(): void;
+    /**
+     * Returns 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.
+     *
+     * https://jestjs.io/docs/snapshot-testing#2-tests-should-be-deterministic
+     *
+     * @example Jest Example
+     * ```typescript
+     * const logger = new TestLogger()
+     * ...
+     * expect(logger.getLogSnapshot()).toMatchSnapshot()
+     * ```
+     * @param config The snapshot configuration
+     * @returns The snapshotted logs.
+     */
+    getLogSnapshot(config?: LogSnapshotConfig): string;
+    error(message: string, ...optionalParams: unknown[]): void;
+    warn(message: string, ...optionalParams: unknown[]): void;
+    info(message: string, ...optionalParams: unknown[]): void;
+    verbose(message: string, ...optionalParams: unknown[]): void;
+    debug(message: string, ...optionalParams: unknown[]): void;
 }
-//#endregion
-export { TestLogger };
-//# sourceMappingURL=test-logger.d.ts.map

package/testing/transaction-logger.d.ts

@@ -1,35 +1,32 @@
-import algosdk from "algosdk";
-
-//#region src/testing/transaction-logger.d.ts
+import algosdk from 'algosdk';
+import Algodv2 = algosdk.Algodv2;
+import Indexer = algosdk.Indexer;
 /**
  * Allows you to keep track of Algorand transaction IDs by wrapping an `Algodv2` in a proxy.
  * Useful for automated tests.
  */
-declare class TransactionLogger {
-  private _sentTransactionIds;
-  private _latestLastValidRound?;
-  private _pushTxn;
-  /**
-   * The list of transaction IDs that has been logged thus far.
-   */
-  get sentTransactionIds(): Readonly<string[]>;
-  /**
-   * Clear all logged IDs.
-   */
-  clear(): void;
-  /**
-   * The method that captures raw transactions and stores the transaction IDs.
-   */
-  logRawTransaction(signedTransactions: Uint8Array | Uint8Array[]): void;
-  /** Return a proxy that wraps the given Algodv2 with this transaction logger.
-   *
-   * @param algod The `Algodv2` to wrap
-   * @returns The wrapped `Algodv2`, any transactions sent using this algod instance will be logged by this transaction logger
-   */
-  capture(algod: Algodv2): Algodv2;
-  /** Wait until all logged transactions IDs appear in the given `Indexer`. */
-  waitForIndexer(indexer: Indexer): Promise<void>;
+export declare class TransactionLogger {
+    private _sentTransactionIds;
+    private _latestLastValidRound?;
+    private _pushTxn;
+    /**
+     * The list of transaction IDs that has been logged thus far.
+     */
+    get sentTransactionIds(): Readonly<string[]>;
+    /**
+     * Clear all logged IDs.
+     */
+    clear(): void;
+    /**
+     * The method that captures raw transactions and stores the transaction IDs.
+     */
+    logRawTransaction(signedTransactions: Uint8Array | Uint8Array[]): void;
+    /** Return a proxy that wraps the given Algodv2 with this transaction logger.
+     *
+     * @param algod The `Algodv2` to wrap
+     * @returns The wrapped `Algodv2`, any transactions sent using this algod instance will be logged by this transaction logger
+     */
+    capture(algod: Algodv2): Algodv2;
+    /** Wait until all logged transactions IDs appear in the given `Indexer`. */
+    waitForIndexer(indexer: Indexer): Promise<void>;
 }
-//#endregion
-export { TransactionLogger };
-//# sourceMappingURL=transaction-logger.d.ts.map

package/transaction/index.d.ts

@@ -0,0 +1,2 @@
+export * from './perform-atomic-transaction-composer-simulate';
+export * from './transaction';

package/transaction/legacy-bridge.d.ts

@@ -0,0 +1,35 @@
+import algosdk from 'algosdk';
+import { AlgorandClientTransactionCreator } from '../types/algorand-client-transaction-creator';
+import { AlgorandClientTransactionSender } from '../types/algorand-client-transaction-sender';
+import { ABIAppCallArgs, BoxIdentifier as LegacyBoxIdentifier, BoxReference as LegacyBoxReference, RawAppCallArgs } from '../types/app';
+import { AppCallMethodCall, AppCallParams, AppCreateMethodCall, AppCreateParams, AppDeleteMethodCall, AppDeleteParams, AppUpdateMethodCall, AppUpdateParams, BuiltTransactions, CommonTransactionParams } from '../types/composer';
+import { SendParams, SendSingleTransactionResult, SendTransactionFrom, SendTransactionParams, SendTransactionResult, TransactionNote } from '../types/transaction';
+import Algodv2 = algosdk.Algodv2;
+import Transaction = algosdk.Transaction;
+/** @deprecated Bridges between legacy `sendTransaction` behaviour and new `AlgorandClient` behaviour. */
+export declare function legacySendTransactionBridge<T extends CommonTransactionParams, TResult extends SendSingleTransactionResult>(algod: Algodv2, from: SendTransactionFrom, sendParams: SendTransactionParams, params: T, txn: ((c: AlgorandClientTransactionCreator) => (params: T) => Promise<Transaction>) | ((c: AlgorandClientTransactionCreator) => (params: T) => Promise<BuiltTransactions>), send: (c: AlgorandClientTransactionSender) => (params: T & SendParams) => Promise<TResult>, suggestedParams?: algosdk.SuggestedParams): Promise<(SendTransactionResult | TResult) & {
+    transactions: Transaction[];
+}>;
+/** @deprecated Bridges between legacy `sendTransaction` behaviour for app transactions and new `AlgorandClient` behaviour. */
+export declare function legacySendAppTransactionBridge<T extends AppCreateParams | AppUpdateParams | AppDeleteParams | AppCallParams | AppCreateMethodCall | AppUpdateMethodCall | AppDeleteMethodCall | AppCallMethodCall, TResult extends SendSingleTransactionResult>(algod: Algodv2, from: SendTransactionFrom, appArgs: RawAppCallArgs | ABIAppCallArgs | undefined, sendParams: SendTransactionParams & {
+    note?: TransactionNote;
+}, params: Omit<T, 'accountReferences' | 'appReferences' | 'assetReferences' | 'boxReferences' | 'args' | 'lease' | 'rekeyTo' | 'note'>, txn: ((c: AlgorandClientTransactionCreator) => (params: T) => Promise<Transaction>) | ((c: AlgorandClientTransactionCreator) => (params: T) => Promise<BuiltTransactions>), send: (c: AlgorandClientTransactionSender) => (params: T & SendParams) => Promise<TResult>, suggestedParams?: algosdk.SuggestedParams): Promise<(SendTransactionResult | TResult) & {
+    transactions: Transaction[];
+}>;
+/**
+ * @deprecated
+ */
+export declare function _getAppArgsForABICall(args: ABIAppCallArgs, from: SendTransactionFrom): Promise<{
+    method: algosdk.ABIMethod;
+    sender: string;
+    signer: algosdk.TransactionSigner;
+    boxes: algosdk.BoxReference[] | undefined;
+    lease: Uint8Array<ArrayBufferLike> | undefined;
+    appForeignApps: number[] | undefined;
+    appForeignAssets: number[] | undefined;
+    appAccounts: string[] | undefined;
+    methodArgs: (string | number | bigint | boolean | algosdk.Address | Uint8Array<ArrayBufferLike> | algosdk.ABIValue[] | algosdk.TransactionWithSigner)[];
+    rekeyTo: string | undefined;
+}>;
+/** @deprecated */
+export declare function _getBoxReference(box: LegacyBoxIdentifier | LegacyBoxReference | algosdk.BoxReference): algosdk.BoxReference;

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

@@ -1,6 +1,7 @@
-import algosdk from "algosdk";
-
-//#region src/transaction/perform-atomic-transaction-composer-simulate.d.ts
+import algosdk from 'algosdk';
+import Algodv2 = algosdk.Algodv2;
+import AtomicTransactionComposer = algosdk.AtomicTransactionComposer;
+import modelsv2 = algosdk.modelsv2;
 /**
  * Performs a simulation of the transactions loaded into the given AtomicTransactionComposer.
  * Uses empty transaction signers for all transactions.
@@ -9,7 +10,4 @@ import algosdk from "algosdk";
  * @param algod An Algod client to perform the simulation.
  * @returns The simulation result, which includes various details about how the transactions would be processed.
  */
-declare function performAtomicTransactionComposerSimulate(atc: AtomicTransactionComposer, algod: Algodv2, options?: Omit<ConstructorParameters<typeof modelsv2.SimulateRequest>[0], 'txnGroups'>): Promise<algosdk.modelsv2.SimulateResponse>;
-//#endregion
-export { performAtomicTransactionComposerSimulate };
-//# sourceMappingURL=perform-atomic-transaction-composer-simulate.d.ts.map
+export declare function performAtomicTransactionComposerSimulate(atc: AtomicTransactionComposer, algod: Algodv2, options?: Omit<ConstructorParameters<typeof modelsv2.SimulateRequest>[0], 'txnGroups'>): Promise<algosdk.modelsv2.SimulateResponse>;

package/transaction/resolve-signed-transactions.d.ts

@@ -0,0 +1,16 @@
+import algosdk from 'algosdk';
+import Transaction = algosdk.Transaction;
+/**
+ * Resolve the transactions as they were signed.
+ *
+ * Signers (e.g. wallets) can mutate the transactions they are given, so the signed transactions are the source of truth
+ * for what is actually sent to the network. Without this, a mutated transaction would be reported (and waited for)
+ * under the transaction ID of the transaction that was built, which was never sent.
+ *
+ * The built transaction is returned when it wasn't mutated, so callers keep the exact transaction they built.
+ *
+ * @param builtTransactions The transactions that were given to the signers
+ * @param encodedSignedTransactions The signed transactions returned by the signers
+ * @returns The transactions as they were signed
+ */
+export declare function resolveSignedTransactions(builtTransactions: Transaction[], encodedSignedTransactions: Uint8Array[]): Transaction[];

package/transaction/transaction.d.ts

@@ -1,12 +1,16 @@
-import { AlgoAmount } from "../types/amount.js";
-import { ABIReturn } from "../types/app.js";
-import { AdditionalAtomicTransactionComposerContext, AtomicTransactionComposerToSend, SendAtomicTransactionComposerResults, SendParams, SendTransactionFrom, SendTransactionParams, SendTransactionResult, TransactionGroupToSend, TransactionNote, TransactionToSign } from "../types/transaction.js";
-import algosdk, { ABIReturnType } from "algosdk";
-
-//#region src/transaction/transaction.d.ts
-declare const MAX_TRANSACTION_GROUP_SIZE = 16;
-declare const MAX_APP_CALL_FOREIGN_REFERENCES = 8;
-declare const MAX_APP_CALL_ACCOUNT_REFERENCES = 8;
+import algosdk, { ABIReturnType } from 'algosdk';
+import { AlgoAmount } from '../types/amount';
+import { ABIReturn } from '../types/app';
+import { AdditionalAtomicTransactionComposerContext, AtomicTransactionComposerToSend, SendAtomicTransactionComposerResults, SendParams, SendTransactionFrom, SendTransactionParams, SendTransactionResult, TransactionGroupToSend, TransactionNote, TransactionToSign } from '../types/transaction';
+import Algodv2 = algosdk.Algodv2;
+import AtomicTransactionComposer = algosdk.AtomicTransactionComposer;
+import modelsv2 = algosdk.modelsv2;
+import SuggestedParams = algosdk.SuggestedParams;
+import Transaction = algosdk.Transaction;
+import TransactionWithSigner = algosdk.TransactionWithSigner;
+export declare const MAX_TRANSACTION_GROUP_SIZE = 16;
+export declare const MAX_APP_CALL_FOREIGN_REFERENCES = 8;
+export declare const MAX_APP_CALL_ACCOUNT_REFERENCES = 8;
 /**
  * @deprecated Convert your data to a `string` or `Uint8Array`, if using ARC-2 use `TransactionComposer.arc2Note`.
  *
@@ -22,7 +26,7 @@ declare const MAX_APP_CALL_ACCOUNT_REFERENCES = 8;
  *   * Arc2TransactionNote object: ARC-0002 compatible transaction note
  *   * Else: The object/value converted into a JSON string representation
  */
-declare function encodeTransactionNote(note?: TransactionNote): Uint8Array | undefined;
+export declare function encodeTransactionNote(note?: TransactionNote): Uint8Array | undefined;
 /** Encodes a transaction lease into a 32-byte array ready to be included in an Algorand transaction.
  *
  * @param lease The transaction lease as a string or binary array or null/undefined if there is no lease
@@ -31,7 +35,7 @@ declare function encodeTransactionNote(note?: TransactionNote): Uint8Array | und
  * @example algokit.encodeLease('UNIQUE_ID')
  * @example algokit.encodeLease(new Uint8Array([1, 2, 3]))
  */
-declare function encodeLease(lease?: string | Uint8Array): Uint8Array | undefined;
+export declare function encodeLease(lease?: string | Uint8Array): Uint8Array | undefined;
 /**
  * @deprecated Use `algorand.client` to interact with accounts, and use `.addr` to get the address
  * and/or move from using `SendTransactionFrom` to `TransactionSignerAccount` and use `.addr` instead.
@@ -40,7 +44,7 @@ declare function encodeLease(lease?: string | Uint8Array): Uint8Array | undefine
  * @param sender A transaction sender
  * @returns The public address
  */
-declare const getSenderAddress: (sender: string | SendTransactionFrom) => string;
+export declare const getSenderAddress: (sender: string | SendTransactionFrom) => string;
 /**
  * @deprecated Use `AlgorandClient` / `TransactionComposer` to construct transactions instead or
  * construct an `algosdk.TransactionWithSigner` manually instead.
@@ -54,7 +58,7 @@ declare const getSenderAddress: (sender: string | SendTransactionFrom) => string
  * include a signer.
  * @returns A TransactionWithSigner object.
  */
-declare const getTransactionWithSigner: (transaction: TransactionWithSigner | TransactionToSign | Transaction | Promise<SendTransactionResult>, defaultSender?: SendTransactionFrom) => Promise<TransactionWithSigner>;
+export declare const getTransactionWithSigner: (transaction: TransactionWithSigner | TransactionToSign | Transaction | Promise<SendTransactionResult>, defaultSender?: SendTransactionFrom) => Promise<TransactionWithSigner>;
 /**
  * @deprecated Use `TransactionSignerAccount` instead of `SendTransactionFrom` or use
  * `algosdk.makeBasicAccountTransactionSigner` / `algosdk.makeLogicSigAccountTransactionSigner`.
@@ -64,7 +68,7 @@ declare const getTransactionWithSigner: (transaction: TransactionWithSigner | Tr
  * @param sender A transaction sender
  * @returns A transaction signer
  */
-declare const getSenderTransactionSigner: (val: SendTransactionFrom) => algosdk.TransactionSigner;
+export declare const getSenderTransactionSigner: (val: SendTransactionFrom) => algosdk.TransactionSigner;
 /**
  * @deprecated Use `AlgorandClient` / `TransactionComposer` to sign transactions
  * or use the relevant underlying `account.signTxn` / `algosdk.signLogicSigTransactionObject`
@@ -75,7 +79,7 @@ declare const getSenderTransactionSigner: (val: SendTransactionFrom) => algosdk.
  * @param signer The signer to sign
  * @returns The signed transaction as a `Uint8Array`
  */
-declare const signTransaction: (transaction: Transaction, signer: SendTransactionFrom) => Promise<Uint8Array<ArrayBufferLike>>;
+export declare const signTransaction: (transaction: Transaction, signer: SendTransactionFrom) => Promise<Uint8Array<ArrayBufferLike>>;
 /**
  * @deprecated Use `AlgorandClient` / `TransactionComposer` to send transactions.
  *
@@ -89,10 +93,10 @@ declare const signTransaction: (transaction: Transaction, signer: SendTransactio
  *
  * @returns An object with transaction (`transaction`) and (if `skipWaiting` is `false` or `undefined`) confirmation (`confirmation`)
  */
-declare const sendTransaction: (send: {
-  transaction: Transaction;
-  from: SendTransactionFrom;
-  sendParams?: SendTransactionParams;
+export declare const sendTransaction: (send: {
+    transaction: Transaction;
+    from: SendTransactionFrom;
+    sendParams?: SendTransactionParams;
 }, algod: Algodv2) => Promise<SendTransactionResult>;
 /**
  * Take an existing Atomic Transaction Composer and return a new one with the required
@@ -111,7 +115,7 @@ declare const sendTransaction: (send: {
  * See https://github.com/algorand/go-algorand/pull/5684
  *
  */
-declare function populateAppCallResources(atc: algosdk.AtomicTransactionComposer, algod: algosdk.Algodv2): Promise<algosdk.AtomicTransactionComposer>;
+export declare function populateAppCallResources(atc: algosdk.AtomicTransactionComposer, algod: algosdk.Algodv2): Promise<algosdk.AtomicTransactionComposer>;
 /**
  * Take an existing Atomic Transaction Composer and return a new one with changes applied to the transactions
  * based on the supplied sendParams to prepare it for sending.
@@ -127,20 +131,20 @@ declare function populateAppCallResources(atc: algosdk.AtomicTransactionComposer
  * Parts of this function will eventually be implemented in algod. Namely:
  * - Simulate will return information on how to populate reference arrays, see https://github.com/algorand/go-algorand/pull/6015
  */
-declare function prepareGroupForSending(atc: algosdk.AtomicTransactionComposer, algod: algosdk.Algodv2, sendParams: SendParams, additionalAtcContext?: AdditionalAtomicTransactionComposerContext): Promise<algosdk.AtomicTransactionComposer>;
+export declare function prepareGroupForSending(atc: algosdk.AtomicTransactionComposer, algod: algosdk.Algodv2, sendParams: SendParams, additionalAtcContext?: AdditionalAtomicTransactionComposerContext): Promise<algosdk.AtomicTransactionComposer>;
 /**
  * Signs and sends transactions that have been collected by an `AtomicTransactionComposer`.
  * @param atcSend The parameters controlling the send, including `atc` The `AtomicTransactionComposer` and params to control send behaviour
  * @param algod An algod client
  * @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`)
  */
-declare const sendAtomicTransactionComposer: (atcSend: AtomicTransactionComposerToSend, algod: Algodv2) => Promise<SendAtomicTransactionComposerResults>;
+export declare const sendAtomicTransactionComposer: (atcSend: AtomicTransactionComposerToSend, algod: Algodv2) => Promise<SendAtomicTransactionComposerResults>;
 /**
  * Takes an algosdk `ABIResult` and converts it to an `ABIReturn`.
  * Converts `bigint`'s for Uint's < 64 to `number` for easier use.
  * @param result The `ABIReturn`
  */
-declare function getABIReturnValue(result: algosdk.ABIResult, type: ABIReturnType): ABIReturn;
+export declare function getABIReturnValue(result: algosdk.ABIResult, type: ABIReturnType): ABIReturn;
 /**
  * @deprecated Use `TransactionComposer` (`algorand.newGroup()`) or `AtomicTransactionComposer` to construct and send group transactions instead.
  *
@@ -152,7 +156,7 @@ declare function getABIReturnValue(result: algosdk.ABIResult, type: ABIReturnTyp
  * @param algod An algod client
  * @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`)
  */
-declare const sendGroupOfTransactions: (groupSend: TransactionGroupToSend, algod: Algodv2) => Promise<Omit<SendAtomicTransactionComposerResults, "returns">>;
+export declare const sendGroupOfTransactions: (groupSend: TransactionGroupToSend, algod: Algodv2) => Promise<Omit<SendAtomicTransactionComposerResults, "returns">>;
 /**
  * Wait until the transaction is confirmed or rejected, or until `timeout`
  * number of rounds have passed.
@@ -164,7 +168,7 @@ declare const sendGroupOfTransactions: (groupSend: TransactionGroupToSend, algod
  * @return Pending transaction information
  * @throws Throws an error if the transaction is not confirmed or rejected in the next `timeout` rounds
  */
-declare const waitForConfirmation: (transactionId: string, maxRoundsToWait: number | bigint, algod: Algodv2) => Promise<modelsv2.PendingTransactionResponse>;
+export declare const waitForConfirmation: (transactionId: string, maxRoundsToWait: number | bigint, algod: Algodv2) => Promise<modelsv2.PendingTransactionResponse>;
 /**
  * @deprecated Use `TransactionComposer` and the `maxFee` field in the transaction params instead.
  *
@@ -174,7 +178,7 @@ declare const waitForConfirmation: (transactionId: string, maxRoundsToWait: numb
  * @param transaction The transaction to cap or suggested params object about to be used to create a transaction
  * @param maxAcceptableFee The maximum acceptable fee to pay
  */
-declare function capTransactionFee(transaction: algosdk.Transaction | SuggestedParams, maxAcceptableFee: AlgoAmount): void;
+export declare function capTransactionFee(transaction: algosdk.Transaction | SuggestedParams, maxAcceptableFee: AlgoAmount): void;
 /**
  * @deprecated Use `TransactionComposer` and the `maxFee` and `staticFee` fields in the transaction params instead.
  *
@@ -182,9 +186,9 @@ declare function capTransactionFee(transaction: algosdk.Transaction | SuggestedP
  * @param transaction The transaction or suggested params
  * @param feeControl The fee control parameters
  */
-declare function controlFees<T extends SuggestedParams | Transaction>(transaction: T, feeControl: {
-  fee?: AlgoAmount;
-  maxFee?: AlgoAmount;
+export declare function controlFees<T extends SuggestedParams | Transaction>(transaction: T, feeControl: {
+    fee?: AlgoAmount;
+    maxFee?: AlgoAmount;
 }): T;
 /**
  * @deprecated Use `suggestedParams ? { ...suggestedParams } : await algod.getTransactionParams().do()` instead
@@ -194,7 +198,7 @@ declare function controlFees<T extends SuggestedParams | Transaction>(transactio
  * @param algod Algod algod
  * @returns The suggested transaction parameters
  */
-declare function getTransactionParams(params: SuggestedParams | undefined, algod: Algodv2): Promise<SuggestedParams>;
+export declare function getTransactionParams(params: SuggestedParams | undefined, algod: Algodv2): Promise<SuggestedParams>;
 /**
  * @deprecated Use `atc.clone().buildGroup()` instead.
  *
@@ -202,7 +206,4 @@ declare function getTransactionParams(params: SuggestedParams | undefined, algod
  * @param atc The atomic transaction composer
  * @returns The array of transactions with signers
  */
-declare function getAtomicTransactionComposerTransactions(atc: AtomicTransactionComposer): algosdk.TransactionWithSigner[];
-//#endregion
-export { MAX_APP_CALL_ACCOUNT_REFERENCES, MAX_APP_CALL_FOREIGN_REFERENCES, MAX_TRANSACTION_GROUP_SIZE, capTransactionFee, controlFees, encodeLease, encodeTransactionNote, getABIReturnValue, getAtomicTransactionComposerTransactions, getSenderAddress, getSenderTransactionSigner, getTransactionParams, getTransactionWithSigner, populateAppCallResources, prepareGroupForSending, sendAtomicTransactionComposer, sendGroupOfTransactions, sendTransaction, signTransaction, waitForConfirmation };
-//# sourceMappingURL=transaction.d.ts.map
+export declare function getAtomicTransactionComposerTransactions(atc: AtomicTransactionComposer): algosdk.TransactionWithSigner[];

package/transfer/index.d.ts

@@ -0,0 +1,2 @@
+export * from './transfer';
+export * from './transfer-algos';

package/transfer/transfer-algos.d.ts

@@ -1,8 +1,7 @@
-import { SendTransactionResult } from "../types/transaction.js";
-import { AlgoTransferParams } from "../types/transfer.js";
-import algosdk from "algosdk";
-
-//#region src/transfer/transfer-algos.d.ts
+import algosdk from 'algosdk';
+import { SendTransactionResult } from '../types/transaction';
+import { AlgoTransferParams } from '../types/transfer';
+import Algodv2 = algosdk.Algodv2;
 /**
  * @deprecated Use `algorand.send.payment()` / `algorand.createTransaction.payment()` instead
  *
@@ -16,7 +15,4 @@ import algosdk from "algosdk";
  * await algokit.transferAlgos({ from, to, amount: algokit.algo(1) }, algod)
  * ```
  */
-declare function transferAlgos(transfer: AlgoTransferParams, algod: Algodv2): Promise<SendTransactionResult>;
-//#endregion
-export { transferAlgos };
-//# sourceMappingURL=transfer-algos.d.ts.map
+export declare function transferAlgos(transfer: AlgoTransferParams, algod: Algodv2): Promise<SendTransactionResult>;

package/transfer/transfer.d.ts

@@ -1,8 +1,8 @@
-import { SendTransactionResult } from "../types/transaction.js";
-import { AlgoRekeyParams, EnsureFundedParams, EnsureFundedReturnType, TransferAssetParams } from "../types/transfer.js";
-import algosdk from "algosdk";
-
-//#region src/transfer/transfer.d.ts
+import algosdk from 'algosdk';
+import { SendTransactionResult } from '../types/transaction';
+import { AlgoRekeyParams, EnsureFundedParams, EnsureFundedReturnType, TransferAssetParams } from '../types/transfer';
+import Algodv2 = algosdk.Algodv2;
+import Kmd = algosdk.Kmd;
 /**
  * @deprecated Use `algorand.account.ensureFunded()` / `algorand.account.ensureFundedFromEnvironment()`
  * / `algorand.account.ensureFundedFromTestNetDispenserApi()` instead
@@ -18,7 +18,7 @@ import algosdk from "algosdk";
  * - `EnsureFundedReturnType` if funds were transferred.
  * - `undefined` if no funds were needed.
  */
-declare function ensureFunded<T extends EnsureFundedParams>(funding: T, algod: Algodv2, kmd?: Kmd): Promise<EnsureFundedReturnType | undefined>;
+export declare function ensureFunded<T extends EnsureFundedParams>(funding: T, algod: Algodv2, kmd?: Kmd): Promise<EnsureFundedReturnType | undefined>;
 /**
  * @deprecated Use `algorand.send.assetTransfer()` / `algorand.createTransaction.assetTransfer()` instead
  *
@@ -32,7 +32,7 @@ declare function ensureFunded<T extends EnsureFundedParams>(funding: T, algod: A
  * await algokit.transferAsset({ from, to, assetId, amount }, algod)
  * ```
  */
-declare function transferAsset(transfer: TransferAssetParams, algod: Algodv2): Promise<SendTransactionResult>;
+export declare function transferAsset(transfer: TransferAssetParams, algod: Algodv2): Promise<SendTransactionResult>;
 /**
  * @deprecated Use `algorand.account.rekeyAccount()` instead
  *
@@ -49,7 +49,4 @@ declare function transferAsset(transfer: TransferAssetParams, algod: Algodv2): P
  * await algokit.rekeyAccount({ from, rekeyTo }, algod)
  * ```
  */
-declare function rekeyAccount(rekey: AlgoRekeyParams, algod: Algodv2): Promise<SendTransactionResult>;
-//#endregion
-export { ensureFunded, rekeyAccount, transferAsset };
-//# sourceMappingURL=transfer.d.ts.map
+export declare function rekeyAccount(rekey: AlgoRekeyParams, algod: Algodv2): Promise<SendTransactionResult>;