@algorandfoundation/algokit-utils 6.3.0-beta.1 → 7.0.0-alpha.1

package/types/algorand-client-transaction-sender.d.ts

@@ -1,26 +1,31 @@
-import algosdk from 'algosdk';
+import algosdk, { Address } from 'algosdk';
+import { SendAppCreateTransactionResult, SendAppTransactionResult, SendAppUpdateTransactionResult } from './app';
+import { AppManager } from './app-manager';
 import { AssetManager } from './asset-manager';
-import AlgoKitComposer, { AssetCreateParams, AssetOptOutParams, ExecuteParams } from './composer';
-import { ConfirmedTransactionResult, SendAtomicTransactionComposerResults } from './transaction';
-/** Result from sending a single transaction. */
-export type SendSingleTransactionResult = SendAtomicTransactionComposerResults & ConfirmedTransactionResult;
+import { AssetCreateParams, AssetOptOutParams, TransactionComposer } from './composer';
+import { SendParams, SendSingleTransactionResult } from './transaction';
 /** Orchestrates sending transactions for `AlgorandClient`. */
 export declare class AlgorandClientTransactionSender {
     private _newGroup;
     private _assetManager;
+    private _appManager;
     /**
      * Creates a new `AlgorandClientSender`
-     * @param newGroup A lambda that starts a new `AlgoKitComposer` transaction group
+     * @param newGroup A lambda that starts a new `TransactionComposer` transaction group
      * @param assetManager An `AssetManager` instance
      */
-    constructor(newGroup: () => AlgoKitComposer, assetManager: AssetManager);
+    constructor(newGroup: () => TransactionComposer, assetManager: AssetManager, appManager: AppManager);
+    newGroup(): TransactionComposer;
     private _send;
+    private _sendAppCall;
+    private _sendAppUpdateCall;
+    private _sendAppCreateCall;
     /**
      * Send a payment transaction to transfer Algo between accounts.
      * @param params The parameters for the payment transaction
      * @example Basic example
      * ```typescript
-     * const result = await algorandClient.send.payment({
+     * const result = await algorand.send.payment({
      *  sender: 'SENDERADDRESS',
      *  receiver: 'RECEIVERADDRESS',
      *  amount: (4).algo(),
@@ -28,7 +33,7 @@ export declare class AlgorandClientTransactionSender {
      * ```
      * @example Advanced example
      * ```typescript
-     * const result = await algorandClient.send.payment({
+     * const result = await algorand.send.payment({
      *   amount: (4).algo(),
      *   receiver: 'RECEIVERADDRESS',
      *   sender: 'SENDERADDRESS',
@@ -57,10 +62,10 @@ export declare class AlgorandClientTransactionSender {
      * @returns The result of the transaction and the transaction that was sent
      */
     payment: (params: import("./composer").CommonTransactionParams & {
-        receiver: string;
+        receiver: string | algosdk.Address;
         amount: import("./amount").AlgoAmount;
-        closeRemainderTo?: string | undefined;
-    } & ExecuteParams) => Promise<SendSingleTransactionResult>;
+        closeRemainderTo?: string | algosdk.Address | undefined;
+    } & SendParams) => Promise<SendSingleTransactionResult>;
     /**
      * Create a new Algorand Standard Asset.
      *
@@ -108,7 +113,7 @@ export declare class AlgorandClientTransactionSender {
      * ```
      * @returns The result of the transaction and the transaction that was sent
      */
-    assetCreate: (params: AssetCreateParams & ExecuteParams) => Promise<{
+    assetCreate: (params: AssetCreateParams & SendParams) => Promise<{
         assetId: bigint;
         groupId: string;
         txIds: string[];
@@ -162,11 +167,11 @@ export declare class AlgorandClientTransactionSender {
      */
     assetConfig: (params: import("./composer").CommonTransactionParams & {
         assetId: bigint;
-        manager: string | undefined;
-        reserve?: string | undefined;
-        freeze?: string | undefined;
-        clawback?: string | undefined;
-    } & ExecuteParams) => Promise<SendSingleTransactionResult>;
+        manager: string | algosdk.Address | undefined;
+        reserve?: string | algosdk.Address | undefined;
+        freeze?: string | algosdk.Address | undefined;
+        clawback?: string | algosdk.Address | undefined;
+    } & SendParams) => Promise<SendSingleTransactionResult>;
     /**
      * Freeze or unfreeze an Algorand Standard Asset for an account.
      *
@@ -205,9 +210,9 @@ export declare class AlgorandClientTransactionSender {
      */
     assetFreeze: (params: import("./composer").CommonTransactionParams & {
         assetId: bigint;
-        account: string;
+        account: string | algosdk.Address;
         frozen: boolean;
-    } & ExecuteParams) => Promise<SendSingleTransactionResult>;
+    } & SendParams) => Promise<SendSingleTransactionResult>;
     /**
      * Destroys an Algorand Standard Asset.
      *
@@ -248,7 +253,7 @@ export declare class AlgorandClientTransactionSender {
      */
     assetDestroy: (params: import("./composer").CommonTransactionParams & {
         assetId: bigint;
-    } & ExecuteParams) => Promise<SendSingleTransactionResult>;
+    } & SendParams) => Promise<SendSingleTransactionResult>;
     /**
      * Transfer an Algorand Standard Asset.
      *
@@ -291,10 +296,10 @@ export declare class AlgorandClientTransactionSender {
     assetTransfer: (params: import("./composer").CommonTransactionParams & {
         assetId: bigint;
         amount: bigint;
-        receiver: string;
-        clawbackTarget?: string | undefined;
-        closeAssetTo?: string | undefined;
-    } & ExecuteParams) => Promise<SendSingleTransactionResult>;
+        receiver: string | algosdk.Address;
+        clawbackTarget?: string | algosdk.Address | undefined;
+        closeAssetTo?: string | algosdk.Address | undefined;
+    } & SendParams) => Promise<SendSingleTransactionResult>;
     /**
      * Opt an account into an Algorand Standard Asset.
      *
@@ -331,7 +336,7 @@ export declare class AlgorandClientTransactionSender {
      */
     assetOptIn: (params: import("./composer").CommonTransactionParams & {
         assetId: bigint;
-    } & ExecuteParams) => Promise<SendSingleTransactionResult>;
+    } & SendParams) => Promise<SendSingleTransactionResult>;
     /**
      * Opt an account out of an Algorand Standard Asset.
      *
@@ -341,7 +346,7 @@ export declare class AlgorandClientTransactionSender {
      *
      * @param params The parameters for the asset opt-out transaction
      *
-     * @example Basic example (without creator)
+     * @example Basic example (without creator, will be retrieved from algod)
      * ```typescript
      * await algorand.send.assetOptOut({sender: "SENDERADDRESS", assetId: 123456n, ensureZeroBalance: true })
      * ```
@@ -378,7 +383,7 @@ export declare class AlgorandClientTransactionSender {
      */
     assetOptOut: (params: Omit<AssetOptOutParams, 'creator'> & {
         /** Optional asset creator account address; if not specified it will be retrieved from algod */
-        creator?: string;
+        creator?: string | Address;
         /** Whether or not to check if the account has a zero balance first or not.
          *
          * If this is set to `true` and the account has an asset balance it will throw an error.
@@ -386,40 +391,761 @@ export declare class AlgorandClientTransactionSender {
          * If this is set to `false` and the account has an asset balance it will lose those assets to the asset creator.
          */
         ensureZeroBalance: boolean;
-    } & ExecuteParams) => Promise<SendSingleTransactionResult>;
+    } & SendParams) => Promise<{
+        groupId: string;
+        txIds: string[];
+        returns?: import("./app").ABIReturn[] | undefined;
+        confirmations: algosdk.modelsv2.PendingTransactionResponse[];
+        transactions: algosdk.Transaction[];
+        confirmation: algosdk.modelsv2.PendingTransactionResponse;
+        transaction: algosdk.Transaction;
+    }>;
+    /**
+     * Create a smart contract.
+     *
+     * Note: you may prefer to use `algorand.client` to get an app client for more advanced functionality.
+     *
+     * @param params The parameters for the app creation transaction
+     * @example Basic example
+     * ```typescript
+     * const result = await algorand.send.appCreate({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE' })
+     * const createdAppId = result.appId
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * await algorand.send.appCreate({
+     *  sender: 'CREATORADDRESS',
+     *  approvalProgram: "TEALCODE",
+     *  clearStateProgram: "TEALCODE",
+     *  schema: {
+     *    globalInts: 1,
+     *    globalByteSlices: 2,
+     *    localInts: 3,
+     *    localByteSlices: 4
+     *  },
+     *  extraProgramPages: 1,
+     *  onComplete: algosdk.OnApplicationComplete.OptInOC,
+     *  args: [new Uint8Array(1, 2, 3, 4)]
+     *  accountReferences: ["ACCOUNT_1"]
+     *  appReferences: [123n, 1234n]
+     *  assetReferences: [12345n]
+     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+     *  lease: 'lease',
+     *  note: 'note',
+     *  // You wouldn't normally set this field
+     *  firstValidRound: 1000n,
+     *  validityWindow: 10,
+     *  extraFee: (1000).microAlgo(),
+     *  staticFee: (1000).microAlgo(),
+     *  // Max fee doesn't make sense with extraFee AND staticFee
+     *  //  already specified, but here for completeness
+     *  maxFee: (3000).microAlgo(),
+     *  // Signer only needed if you want to provide one,
+     *  //  generally you'd register it with AlgorandClient
+     *  //  against the sender and not need to pass it in
+     *  signer: transactionSigner,
+     *  maxRoundsToWaitForConfirmation: 5,
+     *  suppressLog: true,
+     *})
+     * ```
+     */
+    appCreate: (params: {
+        sender: string | algosdk.Address;
+        maxFee?: import("./amount").AlgoAmount | undefined;
+        note?: string | Uint8Array | undefined;
+        args?: Uint8Array[] | undefined;
+        signer?: algosdk.TransactionSigner | import("./account").TransactionSignerAccount | undefined;
+        onComplete?: algosdk.OnApplicationComplete.NoOpOC | algosdk.OnApplicationComplete.OptInOC | algosdk.OnApplicationComplete.CloseOutOC | algosdk.OnApplicationComplete.UpdateApplicationOC | algosdk.OnApplicationComplete.DeleteApplicationOC | undefined;
+        lease?: string | Uint8Array | undefined;
+        rekeyTo?: string | algosdk.Address | undefined;
+        staticFee?: import("./amount").AlgoAmount | undefined;
+        extraFee?: import("./amount").AlgoAmount | undefined;
+        validityWindow?: number | bigint | undefined;
+        firstValidRound?: bigint | undefined;
+        lastValidRound?: bigint | undefined;
+        accountReferences?: (string | algosdk.Address)[] | undefined;
+        appReferences?: bigint[] | undefined;
+        assetReferences?: bigint[] | undefined;
+        boxReferences?: (import("./app-manager").BoxIdentifier | import("./app-manager").BoxReference)[] | undefined;
+        approvalProgram: string | Uint8Array;
+        clearStateProgram: string | Uint8Array;
+        schema?: {
+            globalInts: number;
+            globalByteSlices: number;
+            localInts: number;
+            localByteSlices: number;
+        } | undefined;
+        extraProgramPages?: number | undefined;
+    } & SendParams) => Promise<SendAppCreateTransactionResult>;
+    /**
+     * Update a smart contract.
+     *
+     * Note: you may prefer to use `algorand.client` to get an app client for more advanced functionality.
+     *
+     * @param params The parameters for the app update transaction
+     * @example Basic example
+     * ```typescript
+     * await algorand.send.appUpdate({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE' })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * await algorand.send.appUpdate({
+     *  sender: 'CREATORADDRESS',
+     *  approvalProgram: "TEALCODE",
+     *  clearStateProgram: "TEALCODE",
+     *  onComplete: algosdk.OnApplicationComplete.UpdateApplicationOC,
+     *  args: [new Uint8Array(1, 2, 3, 4)]
+     *  accountReferences: ["ACCOUNT_1"]
+     *  appReferences: [123n, 1234n]
+     *  assetReferences: [12345n]
+     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+     *  lease: 'lease',
+     *  note: 'note',
+     *  // You wouldn't normally set this field
+     *  firstValidRound: 1000n,
+     *  validityWindow: 10,
+     *  extraFee: (1000).microAlgo(),
+     *  staticFee: (1000).microAlgo(),
+     *  // Max fee doesn't make sense with extraFee AND staticFee
+     *  //  already specified, but here for completeness
+     *  maxFee: (3000).microAlgo(),
+     *  // Signer only needed if you want to provide one,
+     *  //  generally you'd register it with AlgorandClient
+     *  //  against the sender and not need to pass it in
+     *  signer: transactionSigner,
+     *  maxRoundsToWaitForConfirmation: 5,
+     *  suppressLog: true,
+     *})
+     * ```
+     */
+    appUpdate: (params: {
+        sender: string | algosdk.Address;
+        signer?: algosdk.TransactionSigner | import("./account").TransactionSignerAccount | undefined;
+        rekeyTo?: string | algosdk.Address | undefined;
+        note?: string | Uint8Array | undefined;
+        lease?: string | Uint8Array | undefined;
+        staticFee?: import("./amount").AlgoAmount | undefined;
+        extraFee?: import("./amount").AlgoAmount | undefined;
+        maxFee?: import("./amount").AlgoAmount | undefined;
+        validityWindow?: number | bigint | undefined;
+        firstValidRound?: bigint | undefined;
+        lastValidRound?: bigint | undefined;
+        appId: bigint;
+        onComplete?: algosdk.OnApplicationComplete.UpdateApplicationOC | undefined;
+        args?: Uint8Array[] | undefined;
+        accountReferences?: (string | algosdk.Address)[] | undefined;
+        appReferences?: bigint[] | undefined;
+        assetReferences?: bigint[] | undefined;
+        boxReferences?: (import("./app-manager").BoxIdentifier | import("./app-manager").BoxReference)[] | undefined;
+        approvalProgram: string | Uint8Array;
+        clearStateProgram: string | Uint8Array;
+    } & SendParams) => Promise<SendAppUpdateTransactionResult>;
+    /**
+     * Delete a smart contract.
+     *
+     * Note: you may prefer to use `algorand.client` to get an app client for more advanced functionality.
+     *
+     * @param params The parameters for the app deletion transaction
+     * @example Basic example
+     * ```typescript
+     * await algorand.send.appDelete({ sender: 'CREATORADDRESS' })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * await algorand.send.appDelete({
+     *  sender: 'CREATORADDRESS',
+     *  onComplete: algosdk.OnApplicationComplete.DeleteApplicationOC,
+     *  args: [new Uint8Array(1, 2, 3, 4)]
+     *  accountReferences: ["ACCOUNT_1"]
+     *  appReferences: [123n, 1234n]
+     *  assetReferences: [12345n]
+     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+     *  lease: 'lease',
+     *  note: 'note',
+     *  // You wouldn't normally set this field
+     *  firstValidRound: 1000n,
+     *  validityWindow: 10,
+     *  extraFee: (1000).microAlgo(),
+     *  staticFee: (1000).microAlgo(),
+     *  // Max fee doesn't make sense with extraFee AND staticFee
+     *  //  already specified, but here for completeness
+     *  maxFee: (3000).microAlgo(),
+     *  // Signer only needed if you want to provide one,
+     *  //  generally you'd register it with AlgorandClient
+     *  //  against the sender and not need to pass it in
+     *  signer: transactionSigner,
+     *  maxRoundsToWaitForConfirmation: 5,
+     *  suppressLog: true,
+     *})
+     * ```
+     */
+    appDelete: (params: import("./composer").CommonTransactionParams & {
+        appId: bigint;
+        onComplete?: algosdk.OnApplicationComplete | undefined;
+        args?: Uint8Array[] | undefined;
+        accountReferences?: (string | algosdk.Address)[] | undefined;
+        appReferences?: bigint[] | undefined;
+        assetReferences?: bigint[] | undefined;
+        boxReferences?: (import("./app-manager").BoxIdentifier | import("./app-manager").BoxReference)[] | undefined;
+    } & {
+        onComplete?: algosdk.OnApplicationComplete.DeleteApplicationOC | undefined;
+    } & SendParams) => Promise<SendAppTransactionResult>;
     /**
      * Call a smart contract.
      *
-     * Note: you may prefer to use `algorandClient.client` to get an app client for more advanced functionality.
+     * Note: you may prefer to use `algorand.client` to get an app client for more advanced functionality.
+     *
+     * @param params The parameters for the app call transaction
+     * @example Basic example
+     * ```typescript
+     * await algorand.send.appCall({ sender: 'CREATORADDRESS' })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * await algorand.send.appCall({
+     *  sender: 'CREATORADDRESS',
+     *  onComplete: algosdk.OnApplicationComplete.OptInOC,
+     *  args: [new Uint8Array(1, 2, 3, 4)]
+     *  accountReferences: ["ACCOUNT_1"]
+     *  appReferences: [123n, 1234n]
+     *  assetReferences: [12345n]
+     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+     *  lease: 'lease',
+     *  note: 'note',
+     *  // You wouldn't normally set this field
+     *  firstValidRound: 1000n,
+     *  validityWindow: 10,
+     *  extraFee: (1000).microAlgo(),
+     *  staticFee: (1000).microAlgo(),
+     *  // Max fee doesn't make sense with extraFee AND staticFee
+     *  //  already specified, but here for completeness
+     *  maxFee: (3000).microAlgo(),
+     *  // Signer only needed if you want to provide one,
+     *  //  generally you'd register it with AlgorandClient
+     *  //  against the sender and not need to pass it in
+     *  signer: transactionSigner,
+     *  maxRoundsToWaitForConfirmation: 5,
+     *  suppressLog: true,
+     *})
+     * ```
      */
     appCall: (params: import("./composer").CommonTransactionParams & {
+        appId: bigint;
         onComplete?: algosdk.OnApplicationComplete | undefined;
-        appId?: bigint | undefined;
-        approvalProgram?: Uint8Array | undefined;
-        clearProgram?: Uint8Array | undefined;
+        args?: Uint8Array[] | undefined;
+        accountReferences?: (string | algosdk.Address)[] | undefined;
+        appReferences?: bigint[] | undefined;
+        assetReferences?: bigint[] | undefined;
+        boxReferences?: (import("./app-manager").BoxIdentifier | import("./app-manager").BoxReference)[] | undefined;
+    } & {
+        onComplete?: algosdk.OnApplicationComplete.NoOpOC | algosdk.OnApplicationComplete.OptInOC | algosdk.OnApplicationComplete.CloseOutOC | algosdk.OnApplicationComplete.ClearStateOC | algosdk.OnApplicationComplete.DeleteApplicationOC | undefined;
+    } & SendParams) => Promise<SendAppTransactionResult>;
+    /**
+     * Create a smart contract via an ABI method.
+     *
+     * Note: you may prefer to use `algorand.client` to get an app client for more advanced functionality.
+     *
+     * @param params The parameters for the app creation transaction
+     * @example Basic example
+     * ```typescript
+     * const method = new ABIMethod({
+     *   name: 'method',
+     *   args: [{ name: 'arg1', type: 'string' }],
+     *   returns: { type: 'string' },
+     * })
+     * const result = await algorand.send.appCreateMethodCall({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE', method: method, args: ["arg1_value"] })
+     * const createdAppId = result.appId
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * const method = new ABIMethod({
+     *   name: 'method',
+     *   args: [{ name: 'arg1', type: 'string' }],
+     *   returns: { type: 'string' },
+     * })
+     * await algorand.send.appCreate({
+     *  sender: 'CREATORADDRESS',
+     *  method: method,
+     *  args: ["arg1_value"],
+     *  approvalProgram: "TEALCODE",
+     *  clearStateProgram: "TEALCODE",
+     *  schema: {
+     *    globalInts: 1,
+     *    globalByteSlices: 2,
+     *    localInts: 3,
+     *    localByteSlices: 4
+     *  },
+     *  extraProgramPages: 1,
+     *  onComplete: algosdk.OnApplicationComplete.OptInOC,
+     *  args: [new Uint8Array(1, 2, 3, 4)]
+     *  accountReferences: ["ACCOUNT_1"]
+     *  appReferences: [123n, 1234n]
+     *  assetReferences: [12345n]
+     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+     *  lease: 'lease',
+     *  note: 'note',
+     *  // You wouldn't normally set this field
+     *  firstValidRound: 1000n,
+     *  validityWindow: 10,
+     *  extraFee: (1000).microAlgo(),
+     *  staticFee: (1000).microAlgo(),
+     *  // Max fee doesn't make sense with extraFee AND staticFee
+     *  //  already specified, but here for completeness
+     *  maxFee: (3000).microAlgo(),
+     *  // Signer only needed if you want to provide one,
+     *  //  generally you'd register it with AlgorandClient
+     *  //  against the sender and not need to pass it in
+     *  signer: transactionSigner,
+     *  maxRoundsToWaitForConfirmation: 5,
+     *  suppressLog: true,
+     *})
+     * ```
+     */
+    appCreateMethodCall: (params: {
+        sender: string | algosdk.Address;
+        maxFee?: import("./amount").AlgoAmount | undefined;
+        approvalProgram: string | Uint8Array;
+        clearStateProgram: string | Uint8Array;
+        note?: string | Uint8Array | undefined;
         schema?: {
-            globalUints: number;
+            globalInts: number;
             globalByteSlices: number;
-            localUints: number;
+            localInts: number;
             localByteSlices: number;
         } | undefined;
-        args?: Uint8Array[] | undefined;
-        accountReferences?: string[] | undefined;
+        signer?: algosdk.TransactionSigner | import("./account").TransactionSignerAccount | undefined;
+        onComplete?: algosdk.OnApplicationComplete.NoOpOC | algosdk.OnApplicationComplete.OptInOC | algosdk.OnApplicationComplete.CloseOutOC | algosdk.OnApplicationComplete.UpdateApplicationOC | algosdk.OnApplicationComplete.DeleteApplicationOC | undefined;
+        lease?: string | Uint8Array | undefined;
+        rekeyTo?: string | algosdk.Address | undefined;
+        extraProgramPages?: number | undefined;
+        staticFee?: import("./amount").AlgoAmount | undefined;
+        extraFee?: import("./amount").AlgoAmount | undefined;
+        validityWindow?: number | bigint | undefined;
+        firstValidRound?: bigint | undefined;
+        lastValidRound?: bigint | undefined;
+        accountReferences?: (string | algosdk.Address)[] | undefined;
         appReferences?: bigint[] | undefined;
         assetReferences?: bigint[] | undefined;
-        extraPages?: number | undefined;
-        boxReferences?: algosdk.BoxReference[] | undefined;
-    } & ExecuteParams) => Promise<SendSingleTransactionResult>;
+        boxReferences?: (import("./app-manager").BoxIdentifier | import("./app-manager").BoxReference)[] | undefined;
+    } & {
+        method: algosdk.ABIMethod;
+        args?: (algosdk.Address | algosdk.Transaction | algosdk.ABIValue | algosdk.TransactionWithSigner | Promise<algosdk.Transaction> | import("./composer").AppMethodCall<{
+            sender: string | algosdk.Address;
+            maxFee?: import("./amount").AlgoAmount | undefined;
+            note?: string | Uint8Array | undefined;
+            args?: Uint8Array[] | undefined;
+            signer?: algosdk.TransactionSigner | import("./account").TransactionSignerAccount | undefined;
+            onComplete?: algosdk.OnApplicationComplete.NoOpOC | algosdk.OnApplicationComplete.OptInOC | algosdk.OnApplicationComplete.CloseOutOC | algosdk.OnApplicationComplete.UpdateApplicationOC | algosdk.OnApplicationComplete.DeleteApplicationOC | undefined;
+            lease?: string | Uint8Array | undefined;
+            rekeyTo?: string | algosdk.Address | undefined;
+            staticFee?: import("./amount").AlgoAmount | undefined;
+            extraFee?: import("./amount").AlgoAmount | undefined;
+            validityWindow?: number | bigint | undefined;
+            firstValidRound?: bigint | undefined;
+            lastValidRound?: bigint | undefined;
+            accountReferences?: (string | algosdk.Address)[] | undefined;
+            appReferences?: bigint[] | undefined;
+            assetReferences?: bigint[] | undefined;
+            boxReferences?: (import("./app-manager").BoxIdentifier | import("./app-manager").BoxReference)[] | undefined;
+            approvalProgram: string | Uint8Array;
+            clearStateProgram: string | Uint8Array;
+            schema?: {
+                globalInts: number;
+                globalByteSlices: number;
+                localInts: number;
+                localByteSlices: number;
+            } | undefined;
+            extraProgramPages?: number | undefined;
+        }> | import("./composer").AppMethodCall<{
+            sender: string | algosdk.Address;
+            signer?: algosdk.TransactionSigner | import("./account").TransactionSignerAccount | undefined;
+            rekeyTo?: string | algosdk.Address | undefined;
+            note?: string | Uint8Array | undefined;
+            lease?: string | Uint8Array | undefined;
+            staticFee?: import("./amount").AlgoAmount | undefined;
+            extraFee?: import("./amount").AlgoAmount | undefined;
+            maxFee?: import("./amount").AlgoAmount | undefined;
+            validityWindow?: number | bigint | undefined;
+            firstValidRound?: bigint | undefined;
+            lastValidRound?: bigint | undefined;
+            appId: bigint;
+            onComplete?: algosdk.OnApplicationComplete.UpdateApplicationOC | undefined;
+            args?: Uint8Array[] | undefined;
+            accountReferences?: (string | algosdk.Address)[] | undefined;
+            appReferences?: bigint[] | undefined;
+            assetReferences?: bigint[] | undefined;
+            boxReferences?: (import("./app-manager").BoxIdentifier | import("./app-manager").BoxReference)[] | undefined;
+            approvalProgram: string | Uint8Array;
+            clearStateProgram: string | Uint8Array;
+        }> | import("./composer").AppMethodCall<import("./composer").AppMethodCallParams> | undefined)[] | undefined;
+    } & SendParams) => Promise<SendAppCreateTransactionResult>;
     /**
-     * Call a smart contract ABI method.
+     * Update a smart contract via an ABI method.
      *
-     * Note: you may prefer to use `algorandClient.client` to get an app client for more advanced functionality.
+     * Note: you may prefer to use `algorand.client` to get an app client for more advanced functionality.
+     *
+     * @param params The parameters for the app update transaction
+     * @example Basic example
+     * ```typescript
+     * const method = new ABIMethod({
+     *   name: 'method',
+     *   args: [{ name: 'arg1', type: 'string' }],
+     *   returns: { type: 'string' },
+     * })
+     * await algorand.send.appUpdateMethodCall({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE', method: method, args: ["arg1_value"] })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * const method = new ABIMethod({
+     *   name: 'method',
+     *   args: [{ name: 'arg1', type: 'string' }],
+     *   returns: { type: 'string' },
+     * })
+     * await algorand.send.appUpdateMethodCall({
+     *  sender: 'CREATORADDRESS',
+     *  method: method,
+     *  args: ["arg1_value"],
+     *  approvalProgram: "TEALCODE",
+     *  clearStateProgram: "TEALCODE",
+     *  onComplete: algosdk.OnApplicationComplete.UpdateApplicationOC,
+     *  args: [new Uint8Array(1, 2, 3, 4)]
+     *  accountReferences: ["ACCOUNT_1"]
+     *  appReferences: [123n, 1234n]
+     *  assetReferences: [12345n]
+     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+     *  lease: 'lease',
+     *  note: 'note',
+     *  // You wouldn't normally set this field
+     *  firstValidRound: 1000n,
+     *  validityWindow: 10,
+     *  extraFee: (1000).microAlgo(),
+     *  staticFee: (1000).microAlgo(),
+     *  // Max fee doesn't make sense with extraFee AND staticFee
+     *  //  already specified, but here for completeness
+     *  maxFee: (3000).microAlgo(),
+     *  // Signer only needed if you want to provide one,
+     *  //  generally you'd register it with AlgorandClient
+     *  //  against the sender and not need to pass it in
+     *  signer: transactionSigner,
+     *  maxRoundsToWaitForConfirmation: 5,
+     *  suppressLog: true,
+     *})
+     * ```
      */
-    methodCall: (params: import("./composer").CommonTransactionParams & Omit<import("./composer").AppCallParams, "args"> & {
+    appUpdateMethodCall: (params: {
+        sender: string | algosdk.Address;
+        maxFee?: import("./amount").AlgoAmount | undefined;
+        approvalProgram: string | Uint8Array;
+        clearStateProgram: string | Uint8Array;
+        note?: string | Uint8Array | undefined;
         appId: bigint;
+        signer?: algosdk.TransactionSigner | import("./account").TransactionSignerAccount | undefined;
+        onComplete?: algosdk.OnApplicationComplete.UpdateApplicationOC | undefined;
+        lease?: string | Uint8Array | undefined;
+        rekeyTo?: string | algosdk.Address | undefined;
+        staticFee?: import("./amount").AlgoAmount | undefined;
+        extraFee?: import("./amount").AlgoAmount | undefined;
+        validityWindow?: number | bigint | undefined;
+        firstValidRound?: bigint | undefined;
+        lastValidRound?: bigint | undefined;
+        accountReferences?: (string | algosdk.Address)[] | undefined;
+        appReferences?: bigint[] | undefined;
+        assetReferences?: bigint[] | undefined;
+        boxReferences?: (import("./app-manager").BoxIdentifier | import("./app-manager").BoxReference)[] | undefined;
+    } & {
+        method: algosdk.ABIMethod;
+        args?: (algosdk.Address | algosdk.Transaction | algosdk.ABIValue | algosdk.TransactionWithSigner | Promise<algosdk.Transaction> | import("./composer").AppMethodCall<{
+            sender: string | algosdk.Address;
+            maxFee?: import("./amount").AlgoAmount | undefined;
+            note?: string | Uint8Array | undefined;
+            args?: Uint8Array[] | undefined;
+            signer?: algosdk.TransactionSigner | import("./account").TransactionSignerAccount | undefined;
+            onComplete?: algosdk.OnApplicationComplete.NoOpOC | algosdk.OnApplicationComplete.OptInOC | algosdk.OnApplicationComplete.CloseOutOC | algosdk.OnApplicationComplete.UpdateApplicationOC | algosdk.OnApplicationComplete.DeleteApplicationOC | undefined;
+            lease?: string | Uint8Array | undefined;
+            rekeyTo?: string | algosdk.Address | undefined;
+            staticFee?: import("./amount").AlgoAmount | undefined;
+            extraFee?: import("./amount").AlgoAmount | undefined;
+            validityWindow?: number | bigint | undefined;
+            firstValidRound?: bigint | undefined;
+            lastValidRound?: bigint | undefined;
+            accountReferences?: (string | algosdk.Address)[] | undefined;
+            appReferences?: bigint[] | undefined;
+            assetReferences?: bigint[] | undefined;
+            boxReferences?: (import("./app-manager").BoxIdentifier | import("./app-manager").BoxReference)[] | undefined;
+            approvalProgram: string | Uint8Array;
+            clearStateProgram: string | Uint8Array;
+            schema?: {
+                globalInts: number;
+                globalByteSlices: number;
+                localInts: number;
+                localByteSlices: number;
+            } | undefined;
+            extraProgramPages?: number | undefined;
+        }> | import("./composer").AppMethodCall<{
+            sender: string | algosdk.Address;
+            signer?: algosdk.TransactionSigner | import("./account").TransactionSignerAccount | undefined;
+            rekeyTo?: string | algosdk.Address | undefined;
+            note?: string | Uint8Array | undefined;
+            lease?: string | Uint8Array | undefined;
+            staticFee?: import("./amount").AlgoAmount | undefined;
+            extraFee?: import("./amount").AlgoAmount | undefined;
+            maxFee?: import("./amount").AlgoAmount | undefined;
+            validityWindow?: number | bigint | undefined;
+            firstValidRound?: bigint | undefined;
+            lastValidRound?: bigint | undefined;
+            appId: bigint;
+            onComplete?: algosdk.OnApplicationComplete.UpdateApplicationOC | undefined;
+            args?: Uint8Array[] | undefined;
+            accountReferences?: (string | algosdk.Address)[] | undefined;
+            appReferences?: bigint[] | undefined;
+            assetReferences?: bigint[] | undefined;
+            boxReferences?: (import("./app-manager").BoxIdentifier | import("./app-manager").BoxReference)[] | undefined;
+            approvalProgram: string | Uint8Array;
+            clearStateProgram: string | Uint8Array;
+        }> | import("./composer").AppMethodCall<import("./composer").AppMethodCallParams> | undefined)[] | undefined;
+    } & SendParams) => Promise<SendAppUpdateTransactionResult>;
+    /**
+     * Delete a smart contract via an ABI method.
+     *
+     * Note: you may prefer to use `algorand.client` to get an app client for more advanced functionality.
+     *
+     * @param params The parameters for the app deletion transaction
+     * @example Basic example
+     * ```typescript
+     * const method = new ABIMethod({
+     *   name: 'method',
+     *   args: [{ name: 'arg1', type: 'string' }],
+     *   returns: { type: 'string' },
+     * })
+     * await algorand.send.appDeleteMethodCall({ sender: 'CREATORADDRESS', method: method, args: ["arg1_value"] })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * const method = new ABIMethod({
+     *   name: 'method',
+     *   args: [{ name: 'arg1', type: 'string' }],
+     *   returns: { type: 'string' },
+     * })
+     * await algorand.send.appDeleteMethodCall({
+     *  sender: 'CREATORADDRESS',
+     *  method: method,
+     *  args: ["arg1_value"],
+     *  onComplete: algosdk.OnApplicationComplete.DeleteApplicationOC,
+     *  args: [new Uint8Array(1, 2, 3, 4)]
+     *  accountReferences: ["ACCOUNT_1"]
+     *  appReferences: [123n, 1234n]
+     *  assetReferences: [12345n]
+     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+     *  lease: 'lease',
+     *  note: 'note',
+     *  // You wouldn't normally set this field
+     *  firstValidRound: 1000n,
+     *  validityWindow: 10,
+     *  extraFee: (1000).microAlgo(),
+     *  staticFee: (1000).microAlgo(),
+     *  // Max fee doesn't make sense with extraFee AND staticFee
+     *  //  already specified, but here for completeness
+     *  maxFee: (3000).microAlgo(),
+     *  // Signer only needed if you want to provide one,
+     *  //  generally you'd register it with AlgorandClient
+     *  //  against the sender and not need to pass it in
+     *  signer: transactionSigner,
+     *  maxRoundsToWaitForConfirmation: 5,
+     *  suppressLog: true,
+     *})
+     * ```
+     */
+    appDeleteMethodCall: (params: {
+        sender: string | algosdk.Address;
+        maxFee?: import("./amount").AlgoAmount | undefined;
+        note?: string | Uint8Array | undefined;
+        appId: bigint;
+        signer?: algosdk.TransactionSigner | import("./account").TransactionSignerAccount | undefined;
+        onComplete?: algosdk.OnApplicationComplete.DeleteApplicationOC | undefined;
+        lease?: string | Uint8Array | undefined;
+        rekeyTo?: string | algosdk.Address | undefined;
+        staticFee?: import("./amount").AlgoAmount | undefined;
+        extraFee?: import("./amount").AlgoAmount | undefined;
+        validityWindow?: number | bigint | undefined;
+        firstValidRound?: bigint | undefined;
+        lastValidRound?: bigint | undefined;
+        accountReferences?: (string | algosdk.Address)[] | undefined;
+        appReferences?: bigint[] | undefined;
+        assetReferences?: bigint[] | undefined;
+        boxReferences?: (import("./app-manager").BoxIdentifier | import("./app-manager").BoxReference)[] | undefined;
+    } & {
+        method: algosdk.ABIMethod;
+        args?: (algosdk.Address | algosdk.Transaction | algosdk.ABIValue | algosdk.TransactionWithSigner | Promise<algosdk.Transaction> | import("./composer").AppMethodCall<{
+            sender: string | algosdk.Address;
+            maxFee?: import("./amount").AlgoAmount | undefined;
+            note?: string | Uint8Array | undefined;
+            args?: Uint8Array[] | undefined;
+            signer?: algosdk.TransactionSigner | import("./account").TransactionSignerAccount | undefined;
+            onComplete?: algosdk.OnApplicationComplete.NoOpOC | algosdk.OnApplicationComplete.OptInOC | algosdk.OnApplicationComplete.CloseOutOC | algosdk.OnApplicationComplete.UpdateApplicationOC | algosdk.OnApplicationComplete.DeleteApplicationOC | undefined;
+            lease?: string | Uint8Array | undefined;
+            rekeyTo?: string | algosdk.Address | undefined;
+            staticFee?: import("./amount").AlgoAmount | undefined;
+            extraFee?: import("./amount").AlgoAmount | undefined;
+            validityWindow?: number | bigint | undefined;
+            firstValidRound?: bigint | undefined;
+            lastValidRound?: bigint | undefined;
+            accountReferences?: (string | algosdk.Address)[] | undefined;
+            appReferences?: bigint[] | undefined;
+            assetReferences?: bigint[] | undefined;
+            boxReferences?: (import("./app-manager").BoxIdentifier | import("./app-manager").BoxReference)[] | undefined;
+            approvalProgram: string | Uint8Array;
+            clearStateProgram: string | Uint8Array;
+            schema?: {
+                globalInts: number;
+                globalByteSlices: number;
+                localInts: number;
+                localByteSlices: number;
+            } | undefined;
+            extraProgramPages?: number | undefined;
+        }> | import("./composer").AppMethodCall<{
+            sender: string | algosdk.Address;
+            signer?: algosdk.TransactionSigner | import("./account").TransactionSignerAccount | undefined;
+            rekeyTo?: string | algosdk.Address | undefined;
+            note?: string | Uint8Array | undefined;
+            lease?: string | Uint8Array | undefined;
+            staticFee?: import("./amount").AlgoAmount | undefined;
+            extraFee?: import("./amount").AlgoAmount | undefined;
+            maxFee?: import("./amount").AlgoAmount | undefined;
+            validityWindow?: number | bigint | undefined;
+            firstValidRound?: bigint | undefined;
+            lastValidRound?: bigint | undefined;
+            appId: bigint;
+            onComplete?: algosdk.OnApplicationComplete.UpdateApplicationOC | undefined;
+            args?: Uint8Array[] | undefined;
+            accountReferences?: (string | algosdk.Address)[] | undefined;
+            appReferences?: bigint[] | undefined;
+            assetReferences?: bigint[] | undefined;
+            boxReferences?: (import("./app-manager").BoxIdentifier | import("./app-manager").BoxReference)[] | undefined;
+            approvalProgram: string | Uint8Array;
+            clearStateProgram: string | Uint8Array;
+        }> | import("./composer").AppMethodCall<import("./composer").AppMethodCallParams> | undefined)[] | undefined;
+    } & SendParams) => Promise<SendAppTransactionResult>;
+    /**
+     * Call a smart contract via an ABI method.
+     *
+     * Note: you may prefer to use `algorand.client` to get an app client for more advanced functionality.
+     *
+     * @param params The parameters for the app call transaction
+     * @example Basic example
+     * ```typescript
+     * const method = new ABIMethod({
+     *   name: 'method',
+     *   args: [{ name: 'arg1', type: 'string' }],
+     *   returns: { type: 'string' },
+     * })
+     * await algorand.send.appCallMethodCall({ sender: 'CREATORADDRESS', method: method, args: ["arg1_value"] })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * const method = new ABIMethod({
+     *   name: 'method',
+     *   args: [{ name: 'arg1', type: 'string' }],
+     *   returns: { type: 'string' },
+     * })
+     * await algorand.send.appCallMethodCall({
+     *  sender: 'CREATORADDRESS',
+     *  method: method,
+     *  args: ["arg1_value"],
+     *  onComplete: algosdk.OnApplicationComplete.OptInOC,
+     *  args: [new Uint8Array(1, 2, 3, 4)]
+     *  accountReferences: ["ACCOUNT_1"]
+     *  appReferences: [123n, 1234n]
+     *  assetReferences: [12345n]
+     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+     *  lease: 'lease',
+     *  note: 'note',
+     *  // You wouldn't normally set this field
+     *  firstValidRound: 1000n,
+     *  validityWindow: 10,
+     *  extraFee: (1000).microAlgo(),
+     *  staticFee: (1000).microAlgo(),
+     *  // Max fee doesn't make sense with extraFee AND staticFee
+     *  //  already specified, but here for completeness
+     *  maxFee: (3000).microAlgo(),
+     *  // Signer only needed if you want to provide one,
+     *  //  generally you'd register it with AlgorandClient
+     *  //  against the sender and not need to pass it in
+     *  signer: transactionSigner,
+     *  maxRoundsToWaitForConfirmation: 5,
+     *  suppressLog: true,
+     *})
+     * ```
+     */
+    appCallMethodCall: (params: {
+        sender: string | algosdk.Address;
+        maxFee?: import("./amount").AlgoAmount | undefined;
+        note?: string | Uint8Array | undefined;
+        appId: bigint;
+        signer?: algosdk.TransactionSigner | import("./account").TransactionSignerAccount | undefined;
+        onComplete?: algosdk.OnApplicationComplete.NoOpOC | algosdk.OnApplicationComplete.OptInOC | algosdk.OnApplicationComplete.CloseOutOC | algosdk.OnApplicationComplete.DeleteApplicationOC | undefined;
+        lease?: string | Uint8Array | undefined;
+        rekeyTo?: string | algosdk.Address | undefined;
+        staticFee?: import("./amount").AlgoAmount | undefined;
+        extraFee?: import("./amount").AlgoAmount | undefined;
+        validityWindow?: number | bigint | undefined;
+        firstValidRound?: bigint | undefined;
+        lastValidRound?: bigint | undefined;
+        accountReferences?: (string | algosdk.Address)[] | undefined;
+        appReferences?: bigint[] | undefined;
+        assetReferences?: bigint[] | undefined;
+        boxReferences?: (import("./app-manager").BoxIdentifier | import("./app-manager").BoxReference)[] | undefined;
+    } & {
         method: algosdk.ABIMethod;
-        args?: (algosdk.TransactionWithSigner | algosdk.Transaction | algosdk.ABIValue | Promise<algosdk.Transaction> | import("./composer").MethodCallParams)[] | undefined;
-    } & ExecuteParams) => Promise<SendSingleTransactionResult>;
+        args?: (algosdk.Address | algosdk.Transaction | algosdk.ABIValue | algosdk.TransactionWithSigner | Promise<algosdk.Transaction> | import("./composer").AppMethodCall<{
+            sender: string | algosdk.Address;
+            maxFee?: import("./amount").AlgoAmount | undefined;
+            note?: string | Uint8Array | undefined;
+            args?: Uint8Array[] | undefined;
+            signer?: algosdk.TransactionSigner | import("./account").TransactionSignerAccount | undefined;
+            onComplete?: algosdk.OnApplicationComplete.NoOpOC | algosdk.OnApplicationComplete.OptInOC | algosdk.OnApplicationComplete.CloseOutOC | algosdk.OnApplicationComplete.UpdateApplicationOC | algosdk.OnApplicationComplete.DeleteApplicationOC | undefined;
+            lease?: string | Uint8Array | undefined;
+            rekeyTo?: string | algosdk.Address | undefined;
+            staticFee?: import("./amount").AlgoAmount | undefined;
+            extraFee?: import("./amount").AlgoAmount | undefined;
+            validityWindow?: number | bigint | undefined;
+            firstValidRound?: bigint | undefined;
+            lastValidRound?: bigint | undefined;
+            accountReferences?: (string | algosdk.Address)[] | undefined;
+            appReferences?: bigint[] | undefined;
+            assetReferences?: bigint[] | undefined;
+            boxReferences?: (import("./app-manager").BoxIdentifier | import("./app-manager").BoxReference)[] | undefined;
+            approvalProgram: string | Uint8Array;
+            clearStateProgram: string | Uint8Array;
+            schema?: {
+                globalInts: number;
+                globalByteSlices: number;
+                localInts: number;
+                localByteSlices: number;
+            } | undefined;
+            extraProgramPages?: number | undefined;
+        }> | import("./composer").AppMethodCall<{
+            sender: string | algosdk.Address;
+            signer?: algosdk.TransactionSigner | import("./account").TransactionSignerAccount | undefined;
+            rekeyTo?: string | algosdk.Address | undefined;
+            note?: string | Uint8Array | undefined;
+            lease?: string | Uint8Array | undefined;
+            staticFee?: import("./amount").AlgoAmount | undefined;
+            extraFee?: import("./amount").AlgoAmount | undefined;
+            maxFee?: import("./amount").AlgoAmount | undefined;
+            validityWindow?: number | bigint | undefined;
+            firstValidRound?: bigint | undefined;
+            lastValidRound?: bigint | undefined;
+            appId: bigint;
+            onComplete?: algosdk.OnApplicationComplete.UpdateApplicationOC | undefined;
+            args?: Uint8Array[] | undefined;
+            accountReferences?: (string | algosdk.Address)[] | undefined;
+            appReferences?: bigint[] | undefined;
+            assetReferences?: bigint[] | undefined;
+            boxReferences?: (import("./app-manager").BoxIdentifier | import("./app-manager").BoxReference)[] | undefined;
+            approvalProgram: string | Uint8Array;
+            clearStateProgram: string | Uint8Array;
+        }> | import("./composer").AppMethodCall<import("./composer").AppMethodCallParams> | undefined)[] | undefined;
+    } & SendParams) => Promise<SendAppTransactionResult>;
     /** Register an online key. */
     onlineKeyRegistration: (params: import("./composer").CommonTransactionParams & {
         voteKey: Uint8Array;
@@ -428,6 +1154,5 @@ export declare class AlgorandClientTransactionSender {
         voteLast: bigint;
         voteKeyDilution: bigint;
         stateProofKey?: Uint8Array | undefined;
-    } & ExecuteParams) => Promise<SendSingleTransactionResult>;
+    } & SendParams) => Promise<SendSingleTransactionResult>;
 }
-//# sourceMappingURL=algorand-client-transaction-sender.d.ts.map