@algorandfoundation/algokit-utils 6.2.1 → 7.0.0-alpha.1

package/src/util.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.mjs","sources":["../../src/util.ts"],"sourcesContent":["/**\n * Converts a value which might be a number or a bigint into a number to be used with apis that don't support bigint.\n *\n * Throws an UnsafeConversionError if the conversion would result in an unsafe integer for the Number type\n * @param value\n */\nexport const toNumber = (value: number | bigint) => {\n  if (typeof value === 'number') return value\n\n  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {\n    throw new UnsafeConversionError(\n      `Cannot convert ${value} to a Number as it is larger than the maximum safe integer the Number type can hold.`,\n    )\n  } else if (value < BigInt(Number.MIN_SAFE_INTEGER)) {\n    throw new UnsafeConversionError(\n      `Cannot convert ${value} to a Number as it is smaller than the minimum safe integer the Number type can hold.`,\n    )\n  }\n  return Number(value)\n}\n\nexport class UnsafeConversionError extends Error {}\n\n/**\n * Calculates the amount of funds to add to a wallet to bring it up to the minimum spending balance.\n * @param minSpendingBalance The minimum spending balance for the wallet\n * @param currentSpendingBalance The current spending balance for the wallet\n * @param minFundingIncrement The minimum amount of funds that can be added to the wallet\n * @returns The amount of funds to add to the wallet or null if the wallet is already above the minimum spending balance\n */\nexport const calculateFundAmount = (\n  minSpendingBalance: bigint,\n  currentSpendingBalance: bigint,\n  minFundingIncrement: bigint,\n): bigint | null => {\n  if (minSpendingBalance > currentSpendingBalance) {\n    const minFundAmount = minSpendingBalance - currentSpendingBalance\n    return BigInt(Math.max(Number(minFundAmount), Number(minFundingIncrement)))\n  } else {\n    return null\n  }\n}\n\n/**\n * Checks if the current environment is Node.js\n *\n * @returns A boolean indicating whether the current environment is Node.js\n */\nexport const isNode = () => {\n  return typeof process !== 'undefined' && process.versions != null && process.versions.node != null\n}\n\n/**\n * Returns the given array split into chunks of `batchSize` batches.\n * @param array The array to chunk\n * @param batchSize The size of batches to split the array into\n * @returns A generator that yields the array split into chunks of `batchSize` batches\n */\nexport function* chunkArray<T>(array: T[], batchSize: number): Generator<T[], void> {\n  for (let i = 0; i < array.length; i += batchSize) yield array.slice(i, i + batchSize)\n}\n\n/**\n * Memoize calls to the given function in an in-memory map.\n * @param fn The function to memoize\n * @returns The memoized function\n */\nexport const memoize = <T = unknown, R = unknown>(fn: (val: T) => R) => {\n  const cache = new Map()\n  const cached = function (this: unknown, val: T) {\n    return cache.has(val) ? cache.get(val) : cache.set(val, fn.call(this, val)) && cache.get(val)\n  }\n  cached.cache = cache\n  return cached as (val: T) => R\n}\n\nexport const binaryStartsWith = (base: Uint8Array, startsWith: Uint8Array): boolean => {\n  if (startsWith.length > base.length) return false\n  for (let i = 0; i < startsWith.length; i++) {\n    if (base[i] !== startsWith[i]) return false\n  }\n  return true\n}\n"],"names":[],"mappings":"AAAA;;;;;AAKG;AACU,MAAA,QAAQ,GAAG,CAAC,KAAsB,KAAI;IACjD,IAAI,OAAO,KAAK,KAAK,QAAQ;AAAE,QAAA,OAAO,KAAK,CAAA;IAE3C,IAAI,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,EAAE;AAC3C,QAAA,MAAM,IAAI,qBAAqB,CAC7B,kBAAkB,KAAK,CAAA,oFAAA,CAAsF,CAC9G,CAAA;KACF;SAAM,IAAI,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,EAAE;AAClD,QAAA,MAAM,IAAI,qBAAqB,CAC7B,kBAAkB,KAAK,CAAA,qFAAA,CAAuF,CAC/G,CAAA;KACF;AACD,IAAA,OAAO,MAAM,CAAC,KAAK,CAAC,CAAA;AACtB,EAAC;AAEK,MAAO,qBAAsB,SAAQ,KAAK,CAAA;AAAG,CAAA;AAEnD;;;;;;AAMG;AACU,MAAA,mBAAmB,GAAG,CACjC,kBAA0B,EAC1B,sBAA8B,EAC9B,mBAA2B,KACV;AACjB,IAAA,IAAI,kBAAkB,GAAG,sBAAsB,EAAE;AAC/C,QAAA,MAAM,aAAa,GAAG,kBAAkB,GAAG,sBAAsB,CAAA;AACjE,QAAA,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAA;KAC5E;SAAM;AACL,QAAA,OAAO,IAAI,CAAA;KACZ;AACH,EAAC;AAWD;;;;;AAKG;UACc,UAAU,CAAI,KAAU,EAAE,SAAiB,EAAA;AAC1D,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,SAAS;QAAE,MAAM,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,CAAA;AACvF,CAAC;AAED;;;;AAIG;AACU,MAAA,OAAO,GAAG,CAA2B,EAAiB,KAAI;AACrE,IAAA,MAAM,KAAK,GAAG,IAAI,GAAG,EAAE,CAAA;IACvB,MAAM,MAAM,GAAG,UAAyB,GAAM,EAAA;AAC5C,QAAA,OAAO,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;AAC/F,KAAC,CAAA;AACD,IAAA,MAAM,CAAC,KAAK,GAAG,KAAK,CAAA;AACpB,IAAA,OAAO,MAAuB,CAAA;AAChC,EAAC;MAEY,gBAAgB,GAAG,CAAC,IAAgB,EAAE,UAAsB,KAAa;AACpF,IAAA,IAAI,UAAU,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM;AAAE,QAAA,OAAO,KAAK,CAAA;AACjD,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QAC1C,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC;AAAE,YAAA,OAAO,KAAK,CAAA;KAC5C;AACD,IAAA,OAAO,IAAI,CAAA;AACb;;;;"}

package/testing/_asset.d.ts

@@ -1,5 +1,3 @@
-import algosdk from 'algosdk';
-import Account = algosdk.Account;
-import Algodv2 = algosdk.Algodv2;
-export declare function generateTestAsset(client: Algodv2, sender: Account, total?: number): Promise<any>;
-//# sourceMappingURL=_asset.d.ts.map
+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,5 +1,6 @@
-import algosdk from 'algosdk';
+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;
@@ -16,7 +17,7 @@ import Kmd = algosdk.Kmd;
  * @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
  */
-export declare function getTestAccount(params: GetTestAccountParams, algod: Algodv2, kmd?: Kmd): Promise<Account>;
+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,5 +27,4 @@ export declare function getTestAccount(params: GetTestAccountParams, algod: Algo
  * @param algorand An AlgorandClient client
  * @returns The account, with private key loaded
  */
-export declare function getTestAccount(params: GetTestAccountParams, algorand: AlgorandClient): Promise<Account>;
-//# 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

@@ -17,4 +17,3 @@ import { AlgoKitLogCaptureFixture } from '../../types/testing';
  * @returns The fixture
  */
 export declare const algoKitLogCaptureFixture: () => AlgoKitLogCaptureFixture;
-//# sourceMappingURL=algokit-log-capture-fixture.d.ts.map

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

@@ -61,8 +61,7 @@ export declare function algorandFixture(fixtureConfig?: AlgorandFixtureConfig):
  * ```
  *
  * @param fixtureConfig The fixture configuration
- * @param config The algo configuration
+ * @param config The fixture configuration
  * @returns The fixture
  */
 export declare function algorandFixture(fixtureConfig: AlgorandFixtureConfig | undefined, config: AlgoConfig): AlgorandFixture;
-//# sourceMappingURL=algorand-fixture.d.ts.map

package/testing/fixtures/index.d.ts

@@ -1,3 +1,2 @@
 export * from './algokit-log-capture-fixture';
 export * from './algorand-fixture';
-//# sourceMappingURL=index.d.ts.map

package/testing/index.d.ts

@@ -3,4 +3,3 @@ export * from './fixtures';
 export * from './indexer';
 export * from './test-logger';
 export * from './transaction-logger';
-//# sourceMappingURL=index.d.ts.map

package/testing/index.js

@@ -1,11 +1,11 @@
 'use strict';
 
-var account = require('./account.js');
-var indexer = require('./indexer.js');
-var testLogger = require('./test-logger.js');
-var transactionLogger = require('./transaction-logger.js');
-var algokitLogCaptureFixture = require('./fixtures/algokit-log-capture-fixture.js');
-var algorandFixture = require('./fixtures/algorand-fixture.js');
+var account = require('../src/testing/account.js');
+var indexer = require('../src/testing/indexer.js');
+var testLogger = require('../src/testing/test-logger.js');
+var transactionLogger = require('../src/testing/transaction-logger.js');
+var algokitLogCaptureFixture = require('../src/testing/fixtures/algokit-log-capture-fixture.js');
+var algorandFixture = require('../src/testing/fixtures/algorand-fixture.js');
 
 
 

package/testing/index.mjs

@@ -1,7 +1,7 @@
-export { getTestAccount } from './account.mjs';
-export { runWhenIndexerCaughtUp } from './indexer.mjs';
-export { TestLogger } from './test-logger.mjs';
-export { TransactionLogger } from './transaction-logger.mjs';
-export { algoKitLogCaptureFixture } from './fixtures/algokit-log-capture-fixture.mjs';
-export { algorandFixture } from './fixtures/algorand-fixture.mjs';
+export { getTestAccount } from '../src/testing/account.mjs';
+export { runWhenIndexerCaughtUp } from '../src/testing/indexer.mjs';
+export { TestLogger } from '../src/testing/test-logger.mjs';
+export { TransactionLogger } from '../src/testing/transaction-logger.mjs';
+export { algoKitLogCaptureFixture } from '../src/testing/fixtures/algokit-log-capture-fixture.mjs';
+export { algorandFixture } from '../src/testing/fixtures/algorand-fixture.mjs';
 //# sourceMappingURL=index.mjs.map

package/testing/indexer.d.ts

@@ -10,4 +10,3 @@
  * @returns The result (as a promise), or throws if the indexer didn't catch up in time
  */
 export declare function runWhenIndexerCaughtUp<T>(run: () => Promise<T>): Promise<T>;
-//# sourceMappingURL=indexer.d.ts.map

package/testing/test-logger.d.ts

@@ -38,4 +38,3 @@ export declare class TestLogger implements Logger {
     verbose(message: string, ...optionalParams: unknown[]): void;
     debug(message: string, ...optionalParams: unknown[]): void;
 }
-//# sourceMappingURL=test-logger.d.ts.map

package/testing/transaction-logger.d.ts

@@ -28,4 +28,3 @@ export declare class TransactionLogger {
     /** Wait until all logged transactions IDs appear in the given `Indexer`. */
     waitForIndexer(indexer: Indexer): Promise<void>;
 }
-//# sourceMappingURL=transaction-logger.d.ts.map

package/transaction/index.d.ts

@@ -1,3 +1,2 @@
 export * from './perform-atomic-transaction-composer-simulate';
 export * from './transaction';
-//# sourceMappingURL=index.d.ts.map

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 | undefined;
+    appForeignApps: number[] | undefined;
+    appForeignAssets: number[] | undefined;
+    appAccounts: string[] | undefined;
+    methodArgs: (string | number | bigint | boolean | Uint8Array | 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,11 +1,13 @@
 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.
+ *
  * @param atc The AtomicTransactionComposer with transaction(s) loaded.
  * @param algod An Algod client to perform the simulation.
  * @returns The simulation result, which includes various details about how the transactions would be processed.
  */
-export declare function performAtomicTransactionComposerSimulate(atc: AtomicTransactionComposer, algod: Algodv2): Promise<algosdk.modelsv2.SimulateResponse>;
-//# 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/transaction.d.ts

@@ -1,5 +1,6 @@
 import algosdk from 'algosdk';
 import { AlgoAmount } from '../types/amount';
+import { ABIReturn } from '../types/app';
 import { AtomicTransactionComposerToSend, SendAtomicTransactionComposerResults, SendTransactionFrom, SendTransactionParams, SendTransactionResult, TransactionGroupToSend, TransactionNote, TransactionToSign } from '../types/transaction';
 import Algodv2 = algosdk.Algodv2;
 import AtomicTransactionComposer = algosdk.AtomicTransactionComposer;
@@ -10,7 +11,10 @@ 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 = 4;
-/** Encodes a transaction note into a byte array ready to be included in an Algorand transaction.
+/**
+ * @deprecated Convert your data to a `string` or `Uint8Array`, if using ARC-2 use `TransactionComposer.arc2Note`.
+ *
+ * Encodes a transaction note into a byte array ready to be included in an Algorand transaction.
  *
  * @param note The transaction note
  * @returns the transaction note ready for inclusion in a transaction
@@ -33,12 +37,18 @@ export declare function encodeTransactionNote(note?: TransactionNote): Uint8Arra
  */
 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.
+ *
  * Returns the public address of the given transaction sender.
  * @param sender A transaction sender
  * @returns The public address
  */
 export declare const getSenderAddress: (sender: string | SendTransactionFrom) => string;
 /**
+ * @deprecated Use `AlgorandClient` / `TransactionComposer` to construct transactions instead or
+ * construct an `algosdk.TransactionWithSigner` manually instead.
+ *
  * Given a transaction in a variety of supported formats, returns a TransactionWithSigner object ready to be passed to an
  * AtomicTransactionComposer's addTransaction method.
  * @param transaction One of: A TransactionWithSigner object (returned as is), a TransactionToSign object (signer is obtained from the
@@ -50,6 +60,9 @@ export declare const getSenderAddress: (sender: string | SendTransactionFrom) =>
  */
 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`.
+ *
  * Returns a `TransactionSigner` for the given transaction sender.
  * This function has memoization, so will return the same transaction signer for a given sender.
  * @param sender A transaction sender
@@ -57,13 +70,20 @@ export declare const getTransactionWithSigner: (transaction: TransactionWithSign
  */
 export declare const getSenderTransactionSigner: (val: SendTransactionFrom) => algosdk.TransactionSigner;
 /**
+ * @deprecated Use `AlgorandClient` / `TransactionComposer` to sign transactions
+ * or use the relevant underlying `account.signTxn` / `algosdk.signLogicSigTransactionObject`
+ * / `multiSigAccount.sign` / `TransactionSigner` methods directly.
+ *
  * Signs a single transaction by the given signer.
  * @param transaction The transaction to sign
  * @param signer The signer to sign
  * @returns The signed transaction as a `Uint8Array`
  */
 export declare const signTransaction: (transaction: Transaction, signer: SendTransactionFrom) => Promise<Uint8Array>;
-/** Prepares a transaction for sending and then (if instructed) signs and sends the given transaction to the chain.
+/**
+ * @deprecated Use `AlgorandClient` / `TransactionComposer` to send transactions.
+ *
+ * Prepares a transaction for sending and then (if instructed) signs and sends the given transaction to the chain.
  *
  * @param send The details for the transaction to prepare/send, including:
  *   * `transaction`: The unsigned transaction
@@ -98,21 +118,20 @@ export declare const sendTransaction: (send: {
 export declare function populateAppCallResources(atc: algosdk.AtomicTransactionComposer, algod: algosdk.Algodv2): 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`
- *  * `sendParams` The parameters to control the send behaviour
+ * @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`)
  */
 export declare const sendAtomicTransactionComposer: (atcSend: AtomicTransactionComposerToSend, algod: Algodv2) => Promise<SendAtomicTransactionComposerResults>;
 /**
- * Performs a dry run of the transactions loaded into the given AtomicTransactionComposer`
- * @param atc The AtomicTransactionComposer` with transaction(s) loaded
- * @param algod An Algod client
- * @returns The dryrun result
+ * 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`
  */
-export declare function performAtomicTransactionComposerDryrun(atc: AtomicTransactionComposer, algod: Algodv2): Promise<algosdk.DryrunResult>;
+export declare function getABIReturnValue(result: algosdk.ABIResult): ABIReturn;
 /**
+ * @deprecated Use `TransactionComposer` (`algorand.newGroup()`) or `AtomicTransactionComposer` to construct and send group transactions instead.
+ *
  * Signs and sends a group of [up to 16](https://developer.algorand.org/docs/get-details/atomic_transfers/#create-transactions) transactions to the chain
  *
  * @param groupSend The group details to send, with:
@@ -135,7 +154,9 @@ export declare const sendGroupOfTransactions: (groupSend: TransactionGroupToSend
  */
 export declare const waitForConfirmation: (transactionId: string, maxRoundsToWait: number | bigint, algod: Algodv2) => Promise<modelsv2.PendingTransactionResponse>;
 /**
- * Limit the acceptable fee to a defined amount of µALGOs.
+ * @deprecated Use `TransactionComposer` and the `maxFee` field in the transaction params instead.
+ *
+ * Limit the acceptable fee to a defined amount of µAlgo.
  * This also sets the transaction to be flatFee to ensure the transaction only succeeds at
  * the estimated rate.
  * @param transaction The transaction to cap or suggested params object about to be used to create a transaction
@@ -143,6 +164,8 @@ export declare const waitForConfirmation: (transactionId: string, maxRoundsToWai
  */
 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.
+ *
  * Allows for control of fees on a `Transaction` or `SuggestedParams` object
  * @param transaction The transaction or suggested params
  * @param feeControl The fee control parameters
@@ -152,23 +175,19 @@ export declare function controlFees<T extends SuggestedParams | Transaction>(tra
     maxFee?: AlgoAmount;
 }): T;
 /**
+ * @deprecated Use `suggestedParams ? { ...suggestedParams } : await algod.getTransactionParams().do()` instead
+ *
  * Returns suggested transaction parameters from algod unless some are already provided.
  * @param params Optionally provide parameters to use
  * @param algod Algod algod
  * @returns The suggested transaction parameters
  */
-export declare function getTransactionParams(params: SuggestedParams | undefined, algod: Algodv2): Promise<import("algosdk/dist/types/types/transactions/base").SuggestedParamsWithMinFee | {
-    flatFee?: boolean | undefined;
-    fee: number;
-    firstRound: number;
-    lastRound: number;
-    genesisID: string;
-    genesisHash: string;
-}>;
+export declare function getTransactionParams(params: SuggestedParams | undefined, algod: Algodv2): Promise<SuggestedParams>;
 /**
+ * @deprecated Use `atc.clone().buildGroup()` instead.
+ *
  * Returns the array of transactions currently present in the given `AtomicTransactionComposer`
  * @param atc The atomic transaction composer
  * @returns The array of transactions with signers
  */
 export declare function getAtomicTransactionComposerTransactions(atc: AtomicTransactionComposer): algosdk.TransactionWithSigner[];
-//# sourceMappingURL=transaction.d.ts.map

package/transfer/index.d.ts

@@ -1,3 +1,2 @@
 export * from './transfer';
 export * from './transfer-algos';
-//# sourceMappingURL=index.d.ts.map

package/transfer/transfer-algos.d.ts

@@ -3,15 +3,16 @@ import { SendTransactionResult } from '../types/transaction';
 import { AlgoTransferParams } from '../types/transfer';
 import Algodv2 = algosdk.Algodv2;
 /**
- * Transfer ALGOs between two accounts.
+ * @deprecated Use `algorand.send.payment()` / `algorand.createTransaction.payment()` instead
+ *
+ * Transfer Algo between two accounts.
  * @param transfer The transfer definition
  * @param algod An algod client
  * @returns The transaction object and optionally the confirmation if it was sent to the chain (`skipSending` is `false` or unset)
  *
  * @example Usage example
  * ```typescript
- * await algokit.transferAlgos({ from, to, amount: algokit.algos(1) }, algod)
+ * await algokit.transferAlgos({ from, to, amount: algokit.algo(1) }, algod)
  * ```
  */
 export declare function transferAlgos(transfer: AlgoTransferParams, algod: Algodv2): Promise<SendTransactionResult>;
-//# sourceMappingURL=transfer-algos.d.ts.map

package/transfer/transfer.d.ts

@@ -4,7 +4,10 @@ import { AlgoRekeyParams, EnsureFundedParams, EnsureFundedReturnType, TransferAs
 import Algodv2 = algosdk.Algodv2;
 import Kmd = algosdk.Kmd;
 /**
- * Funds a given account using a funding source such that it has a certain amount of algos free to spend (accounting for ALGOs locked in minimum balance requirement).
+ * @deprecated Use `algorand.account.ensureFunded()` / `algorand.account.ensureFundedFromEnvironment()`
+ * / `algorand.account.ensureFundedFromTestNetDispenserApi()` instead
+ *
+ * Funds a given account using a funding source such that it has a certain amount of Algo free to spend (accounting for Algo locked in minimum balance requirement).
  *
  * https://developer.algorand.org/docs/get-details/accounts/#minimum-balance
  *
@@ -17,6 +20,8 @@ import Kmd = algosdk.Kmd;
  */
 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
+ *
  * Transfer asset between two accounts.
  * @param transfer The transfer definition
  * @param algod An algod client
@@ -29,6 +34,8 @@ export declare function ensureFunded<T extends EnsureFundedParams>(funding: T, a
  */
 export declare function transferAsset(transfer: TransferAssetParams, algod: Algodv2): Promise<SendTransactionResult>;
 /**
+ * @deprecated Use `algorand.account.rekeyAccount()` instead
+ *
  * Rekey an account to a new address.
  *
  * **Note:** Please be careful with this function and be sure to read the [official rekey guidance](https://developer.algorand.org/docs/get-details/accounts/rekey/).
@@ -43,4 +50,3 @@ export declare function transferAsset(transfer: TransferAssetParams, algod: Algo
  * ```
  */
 export declare function rekeyAccount(rekey: AlgoRekeyParams, algod: Algodv2): Promise<SendTransactionResult>;
-//# sourceMappingURL=transfer.d.ts.map