@algorandfoundation/algokit-utils 7.0.0-beta.1 → 7.0.0-beta.2

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

@@ -1,5 +1,6 @@
 import algosdk from 'algosdk';
-import AlgoKitComposer, { MethodCallParams } from './composer';
+import AlgoKitComposer, { BuiltTransactions } from './composer';
+import { Expand } from './expand';
 import Transaction = algosdk.Transaction;
 /** Orchestrates creating transactions for `AlgorandClient`. */
 export declare class AlgorandClientTransactionCreator {
@@ -10,12 +11,13 @@ export declare class AlgorandClientTransactionCreator {
      */
     constructor(newGroup: () => AlgoKitComposer);
     private _transaction;
+    private _transactions;
     /**
      * Create 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(),
@@ -23,7 +25,7 @@ export declare class AlgorandClientTransactionCreator {
      * ```
      * @example Advanced example
      * ```typescript
-     * const result = await algorandClient.send.payment({
+     * const result = await algorand.send.payment({
      *   amount: (4).algo(),
      *   receiver: 'RECEIVERADDRESS',
      *   sender: 'SENDERADDRESS',
@@ -55,11 +57,11 @@ export declare class AlgorandClientTransactionCreator {
      *
      * @example Basic example
      * ```typescript
-     * await algorand.transaction.assetCreate({sender: "CREATORADDRESS", total: 100n})
+     * await algorand.transactions.assetCreate({sender: "CREATORADDRESS", total: 100n})
      * ```
      * @example Advanced example
      * ```typescript
-     * await algorand.transaction.assetCreate({
+     * await algorand.transactions.assetCreate({
      *   sender: 'CREATORADDRESS',
      *   total: 100n,
      *   decimals: 2,
@@ -97,11 +99,11 @@ export declare class AlgorandClientTransactionCreator {
      *
      * @example Basic example
      * ```typescript
-     * await algorand.transaction.assetConfig({sender: "MANAGERADDRESS", assetId: 123456n, manager: "MANAGERADDRESS" })
+     * await algorand.transactions.assetConfig({sender: "MANAGERADDRESS", assetId: 123456n, manager: "MANAGERADDRESS" })
      * ```
      * @example Advanced example
      * ```typescript
-     * await algorand.transaction.assetConfig({
+     * await algorand.transactions.assetConfig({
      *   sender: 'MANAGERADDRESS',
      *   assetId: 123456n,
      *   manager: 'MANAGERADDRESS',
@@ -129,11 +131,11 @@ export declare class AlgorandClientTransactionCreator {
      *
      * @example Basic example
      * ```typescript
-     * await algorand.transaction.assetFreeze({sender: "MANAGERADDRESS", assetId: 123456n, account: "ACCOUNTADDRESS", frozen: true })
+     * await algorand.transactions.assetFreeze({sender: "MANAGERADDRESS", assetId: 123456n, account: "ACCOUNTADDRESS", frozen: true })
      * ```
      * @example Advanced example
      * ```typescript
-     * await algorand.transaction.assetFreeze({
+     * await algorand.transactions.assetFreeze({
      *   sender: 'MANAGERADDRESS',
      *   assetId: 123456n,
      *   account: 'ACCOUNTADDRESS',
@@ -163,11 +165,11 @@ export declare class AlgorandClientTransactionCreator {
      *
      * @example Basic example
      * ```typescript
-     * await algorand.transaction.assetDestroy({sender: "MANAGERADDRESS", assetId: 123456n })
+     * await algorand.transactions.assetDestroy({sender: "MANAGERADDRESS", assetId: 123456n })
      * ```
      * @example Advanced example
      * ```typescript
-     * await algorand.transaction.assetDestroy({
+     * await algorand.transactions.assetDestroy({
      *   sender: 'MANAGERADDRESS',
      *   assetId: 123456n,
      *   lease: 'lease',
@@ -191,11 +193,11 @@ export declare class AlgorandClientTransactionCreator {
      *
      * @example Basic example
      * ```typescript
-     * await algorand.transaction.assetTransfer({sender: "HOLDERADDRESS", assetId: 123456n, amount: 1n, receiver: "RECEIVERADDRESS" })
+     * await algorand.transactions.assetTransfer({sender: "HOLDERADDRESS", assetId: 123456n, amount: 1n, receiver: "RECEIVERADDRESS" })
      * ```
      * @example Advanced example (with clawback)
      * ```typescript
-     * await algorand.transaction.assetTransfer({
+     * await algorand.transactions.assetTransfer({
      *   sender: 'CLAWBACKADDRESS',
      *   assetId: 123456n,
      *   amount: 1n,
@@ -224,11 +226,11 @@ export declare class AlgorandClientTransactionCreator {
      *
      * @example Basic example
      * ```typescript
-     * await algorand.transaction.assetOptIn({sender: "SENDERADDRESS", assetId: 123456n })
+     * await algorand.transactions.assetOptIn({sender: "SENDERADDRESS", assetId: 123456n })
      * ```
      * @example Advanced example
      * ```typescript
-     * await algorand.transaction.assetOptIn({
+     * await algorand.transactions.assetOptIn({
      *   sender: 'SENDERADDRESS',
      *   assetId: 123456n,
      *   lease: 'lease',
@@ -255,11 +257,11 @@ export declare class AlgorandClientTransactionCreator {
      *
      * @example Basic example
      * ```typescript
-     * await algorand.transaction.assetOptOut({sender: "SENDERADDRESS", creator: "CREATORADDRESS", assetId: 123456n })
+     * await algorand.transactions.assetOptOut({sender: "SENDERADDRESS", creator: "CREATORADDRESS", assetId: 123456n })
      * ```
      * @example Advanced example
      * ```typescript
-     * await algorand.transaction.assetOptIn({
+     * await algorand.transactions.assetOptIn({
      *   sender: 'SENDERADDRESS',
      *   assetId: 123456n,
      *   creator: 'CREATORADDRESS',
@@ -279,10 +281,438 @@ export declare class AlgorandClientTransactionCreator {
      * @returns The asset opt-out transaction
      */
     assetOptOut: (params: import("./composer").AssetOptOutParams) => Promise<Transaction>;
-    /** Create an application call transaction. */
+    /** Create an application create transaction.
+     *
+     * 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.transactions.appCreate({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE' })
+     * const createdAppId = result.appId
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * await algorand.transactions.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: {
+        lease?: string | Uint8Array | undefined;
+        note?: string | Uint8Array | undefined;
+        maxFee?: import("./amount").AlgoAmount | undefined;
+        args?: Uint8Array[] | undefined;
+        signer?: algosdk.TransactionSigner | import("./account").TransactionSignerAccount | undefined;
+        sender: string;
+        rekeyTo?: string | undefined;
+        staticFee?: import("./amount").AlgoAmount | undefined;
+        extraFee?: import("./amount").AlgoAmount | undefined;
+        validityWindow?: number | undefined;
+        firstValidRound?: bigint | undefined;
+        lastValidRound?: bigint | undefined;
+        onComplete?: algosdk.OnApplicationComplete.NoOpOC | algosdk.OnApplicationComplete.OptInOC | algosdk.OnApplicationComplete.CloseOutOC | algosdk.OnApplicationComplete.UpdateApplicationOC | algosdk.OnApplicationComplete.DeleteApplicationOC | undefined;
+        accountReferences?: string[] | 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;
+    }) => Promise<Transaction>;
+    /** Create an application update transaction.
+     *
+     * 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.transactions.appUpdate({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE' })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * await algorand.transactions.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;
+        signer?: algosdk.TransactionSigner | import("./account").TransactionSignerAccount | undefined;
+        rekeyTo?: string | 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 | undefined;
+        firstValidRound?: bigint | undefined;
+        lastValidRound?: bigint | undefined;
+        appId: bigint;
+        onComplete?: algosdk.OnApplicationComplete.UpdateApplicationOC | undefined;
+        args?: Uint8Array[] | undefined;
+        accountReferences?: string[] | undefined;
+        appReferences?: bigint[] | undefined;
+        assetReferences?: bigint[] | undefined;
+        boxReferences?: (import("./app-manager").BoxIdentifier | import("./app-manager").BoxReference)[] | undefined;
+        approvalProgram: string | Uint8Array;
+        clearStateProgram: string | Uint8Array;
+    }) => Promise<Transaction>;
+    /** Create an application delete transaction.
+     *
+     * 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.transactions.appDelete({ sender: 'CREATORADDRESS' })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * await algorand.transactions.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").AppDeleteParams) => Promise<Transaction>;
+    /** Create an application call transaction.
+     *
+     * 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.transactions.appCall({ sender: 'CREATORADDRESS' })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * await algorand.transactions.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").AppCallParams) => Promise<Transaction>;
-    /** Create an application call with ABI method call transaction. */
-    methodCall: (params: MethodCallParams) => Promise<algosdk.Transaction[]>;
+    /** Create an application create call with ABI method call transaction.
+     *
+     * 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.transactions.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.transactions.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: import("./composer").AppCreateMethodCall) => Promise<Expand<BuiltTransactions>>;
+    /** Create an application update call with ABI method call transaction.
+     *
+     * 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.transactions.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.transactions.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,
+     *})
+     * ```
+     */
+    appUpdateMethodCall: (params: import("./composer").AppUpdateMethodCall) => Promise<Expand<BuiltTransactions>>;
+    /** Create an application delete call with ABI method call transaction.
+     *
+     * 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.transactions.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.transactions.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: import("./composer").AppDeleteMethodCall) => Promise<Expand<BuiltTransactions>>;
+    /** Create an application call with ABI method call transaction.
+     *
+     * 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.transactions.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.transactions.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: import("./composer").AppCallMethodCall) => Promise<Expand<BuiltTransactions>>;
     /** Create an online key registration transaction. */
     onlineKeyRegistration: (params: import("./composer").OnlineKeyRegistrationParams) => Promise<Transaction>;
 }

package/types/algorand-client-transaction-creator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"algorand-client-transaction-creator.d.ts","sourceRoot":"","sources":["../../src/types/algorand-client-transaction-creator.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,SAAS,CAAA;AAC7B,OAAO,eAAe,EAAE,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAE9D,OAAO,WAAW,GAAG,OAAO,CAAC,WAAW,CAAA;AAExC,+DAA+D;AAC/D,qBAAa,gCAAgC;IAC3C,OAAO,CAAC,SAAS,CAAuB;IAExC;;;OAGG;gBACS,QAAQ,EAAE,MAAM,eAAe;IAI3C,OAAO,CAAC,YAAY;IAQpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,OAAO,kDA3C4F,QAAQ,WAAW,CAAC,CA2CvE;IAChD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;IACH,WAAW,sDApFwF,QAAQ,WAAW,CAAC,CAoF/D;IACxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,WAAW,sDAxHwF,QAAQ,WAAW,CAAC,CAwH/D;IACxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,WAAW,sDAtJwF,QAAQ,WAAW,CAAC,CAsJ/D;IACxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,YAAY,uDAtLuF,QAAQ,WAAW,CAAC,CAsL7D;IAC1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,aAAa,wDAvNsF,QAAQ,WAAW,CAAC,CAuN3D;IAC5D;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,UAAU,qDAnPyF,QAAQ,WAAW,CAAC,CAmPjE;IACtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,WAAW,sDApRwF,QAAQ,WAAW,CAAC,CAoR/D;IACxD,8CAA8C;IAC9C,OAAO,kDAtR4F,QAAQ,WAAW,CAAC,CAsRvE;IAChD,mEAAmE;IACnE,UAAU,WAAkB,gBAAgB,oCAE3C;IACD,qDAAqD;IACrD,qBAAqB,gEA5R8E,QAAQ,WAAW,CAAC,CA4R3C;CAC7E"}
+{"version":3,"file":"algorand-client-transaction-creator.d.ts","sourceRoot":"","sources":["../../src/types/algorand-client-transaction-creator.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,SAAS,CAAA;AAC7B,OAAO,eAAe,EAAE,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAC/D,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAEjC,OAAO,WAAW,GAAG,OAAO,CAAC,WAAW,CAAA;AAExC,+DAA+D;AAC/D,qBAAa,gCAAgC;IAC3C,OAAO,CAAC,SAAS,CAAuB;IAExC;;;OAGG;gBACS,QAAQ,EAAE,MAAM,eAAe;IAI3C,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,aAAa;IAOrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,OAAO,kDAlD4F,QAAQ,WAAW,CAAC,CAkDvE;IAChD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;IACH,WAAW,sDA3FwF,QAAQ,WAAW,CAAC,CA2F/D;IACxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,WAAW,sDA/HwF,QAAQ,WAAW,CAAC,CA+H/D;IACxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,WAAW,sDA7JwF,QAAQ,WAAW,CAAC,CA6J/D;IACxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,YAAY,uDA7LuF,QAAQ,WAAW,CAAC,CA6L7D;IAC1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,aAAa,wDA9NsF,QAAQ,WAAW,CAAC,CA8N3D;IAC5D;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,UAAU,qDA1PyF,QAAQ,WAAW,CAAC,CA0PjE;IACtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,WAAW,sDA3RwF,QAAQ,WAAW,CAAC,CA2R/D;IACxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+CG;IACH,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;UA5U0F,QAAQ,WAAW,CAAC,CA4UnE;IACpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;IACH,SAAS;;;;;;;;;;;;;;;;;;;;;UArX0F,QAAQ,WAAW,CAAC,CAqXnE;IACpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,SAAS,oDA5Z0F,QAAQ,WAAW,CAAC,CA4ZnE;IACpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,OAAO,kDAnc4F,QAAQ,WAAW,CAAC,CAmcvE;IAChD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2DG;IACH,mBAAmB,wDAxfiF,QAAQ,OAAO,iBAAiB,CAAC,CAAC,CAwf7D;IACzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmDG;IACH,mBAAmB,wDA7iBiF,QAAQ,OAAO,iBAAiB,CAAC,CAAC,CA6iB7D;IACzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiDG;IACH,mBAAmB,wDAhmBiF,QAAQ,OAAO,iBAAiB,CAAC,CAAC,CAgmB7D;IACzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiDG;IACH,iBAAiB,sDAnpBmF,QAAQ,OAAO,iBAAiB,CAAC,CAAC,CAmpBjE;IACrE,qDAAqD;IACrD,qBAAqB,gEA7pB8E,QAAQ,WAAW,CAAC,CA6pB3C;CAC7E"}