@algorandfoundation/algokit-utils 8.2.0-beta.2 → 8.2.0-beta.3

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

@@ -8,6 +8,10 @@ export declare class AlgorandClientTransactionCreator {
     /**
      * Creates a new `AlgorandClientTransactionCreator`
      * @param newGroup A lambda that starts a new `TransactionComposer` transaction group
+     * @example
+     * ```typescript
+     * const transactionCreator = new AlgorandClientTransactionCreator(() => new TransactionComposer())
+     * ```
      */
     constructor(newGroup: () => TransactionComposer);
     private _transaction;
@@ -17,15 +21,15 @@ export declare class AlgorandClientTransactionCreator {
      * @param params The parameters for the payment transaction
      * @example Basic example
      * ```typescript
-     * const result = await algorand.send.payment({
-     *  sender: 'SENDERADDRESS',
-     *  receiver: 'RECEIVERADDRESS',
-     *  amount: (4).algo(),
+     * await algorand.createTransaction.payment({
+     *   sender: 'SENDERADDRESS',
+     *   receiver: 'RECEIVERADDRESS',
+     *   amount: (4).algo(),
      * })
      * ```
      * @example Advanced example
      * ```typescript
-     * const result = await algorand.send.payment({
+     * await algorand.createTransaction.payment({
      *   amount: (4).algo(),
      *   receiver: 'RECEIVERADDRESS',
      *   sender: 'SENDERADDRESS',
@@ -44,7 +48,6 @@ export declare class AlgorandClientTransactionCreator {
      *   maxFee: (3000).microAlgo(),
      * })
      * ```
-     *
      * @returns The payment transaction
      */
     payment: (params: import("./composer").PaymentParams) => Promise<Transaction>;
@@ -57,7 +60,7 @@ export declare class AlgorandClientTransactionCreator {
      *
      * @example Basic example
      * ```typescript
-     * await algorand.createTransaction.assetCreate({sender: "CREATORADDRESS", total: 100n})
+     * await algorand.createTransaction.assetCreate({ sender: "CREATORADDRESS", total: 100n})
      * ```
      * @example Advanced example
      * ```typescript
@@ -99,7 +102,7 @@ export declare class AlgorandClientTransactionCreator {
      *
      * @example Basic example
      * ```typescript
-     * await algorand.createTransaction.assetConfig({sender: "MANAGERADDRESS", assetId: 123456n, manager: "MANAGERADDRESS" })
+     * await algorand.createTransaction.assetConfig({ sender: "MANAGERADDRESS", assetId: 123456n, manager: "MANAGERADDRESS" })
      * ```
      * @example Advanced example
      * ```typescript
@@ -131,7 +134,7 @@ export declare class AlgorandClientTransactionCreator {
      *
      * @example Basic example
      * ```typescript
-     * await algorand.createTransaction.assetFreeze({sender: "MANAGERADDRESS", assetId: 123456n, account: "ACCOUNTADDRESS", frozen: true })
+     * await algorand.createTransaction.assetFreeze({ sender: "MANAGERADDRESS", assetId: 123456n, account: "ACCOUNTADDRESS", frozen: true })
      * ```
      * @example Advanced example
      * ```typescript
@@ -165,7 +168,7 @@ export declare class AlgorandClientTransactionCreator {
      *
      * @example Basic example
      * ```typescript
-     * await algorand.createTransaction.assetDestroy({sender: "MANAGERADDRESS", assetId: 123456n })
+     * await algorand.createTransaction.assetDestroy({ sender: "MANAGERADDRESS", assetId: 123456n })
      * ```
      * @example Advanced example
      * ```typescript
@@ -193,7 +196,7 @@ export declare class AlgorandClientTransactionCreator {
      *
      * @example Basic example
      * ```typescript
-     * await algorand.createTransaction.assetTransfer({sender: "HOLDERADDRESS", assetId: 123456n, amount: 1n, receiver: "RECEIVERADDRESS" })
+     * await algorand.createTransaction.assetTransfer({ sender: "HOLDERADDRESS", assetId: 123456n, amount: 1n, receiver: "RECEIVERADDRESS" })
      * ```
      * @example Advanced example (with clawback)
      * ```typescript
@@ -226,7 +229,7 @@ export declare class AlgorandClientTransactionCreator {
      *
      * @example Basic example
      * ```typescript
-     * await algorand.createTransaction.assetOptIn({sender: "SENDERADDRESS", assetId: 123456n })
+     * await algorand.createTransaction.assetOptIn({ sender: "SENDERADDRESS", assetId: 123456n })
      * ```
      * @example Advanced example
      * ```typescript
@@ -255,13 +258,17 @@ export declare class AlgorandClientTransactionCreator {
      *
      * @param params The parameters for the asset opt-out transaction
      *
-     * @example Basic example
+     * @example Basic example (without creator, will be retrieved from algod)
      * ```typescript
-     * await algorand.createTransaction.assetOptOut({sender: "SENDERADDRESS", creator: "CREATORADDRESS", assetId: 123456n })
+     * await algorand.createTransaction.assetOptOut({ sender: "SENDERADDRESS", assetId: 123456n, ensureZeroBalance: true })
+     * ```
+     * @example Basic example (with creator)
+     * ```typescript
+     * await algorand.createTransaction.assetOptOut({ sender: "SENDERADDRESS", creator: "CREATORADDRESS", assetId: 123456n, ensureZeroBalance: true })
      * ```
      * @example Advanced example
      * ```typescript
-     * await algorand.createTransaction.assetOptIn({
+     * await algorand.createTransaction.assetOptOut({
      *   sender: 'SENDERADDRESS',
      *   assetId: 123456n,
      *   creator: 'CREATORADDRESS',
@@ -288,8 +295,7 @@ export declare class AlgorandClientTransactionCreator {
      * @param params The parameters for the app creation transaction
      * @example Basic example
      * ```typescript
-     * const result = await algorand.createTransaction.appCreate({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE' })
-     * const createdAppId = result.appId
+     * await algorand.createTransaction.appCreate({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE' })
      * ```
      * @example Advanced example
      * ```typescript
@@ -320,14 +326,9 @@ export declare class AlgorandClientTransactionCreator {
      *  // 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,
      *})
      * ```
+     * @returns The application create transaction
      */
     appCreate: (params: {
         sender: string | algosdk.Address;
@@ -388,14 +389,9 @@ export declare class AlgorandClientTransactionCreator {
      *  // 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,
      *})
      * ```
+     * @returns The application update transaction
      */
     appUpdate: (params: {
         sender: string | algosdk.Address;
@@ -448,14 +444,9 @@ export declare class AlgorandClientTransactionCreator {
      *  // 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,
      *})
      * ```
+     * @returns The application delete transaction
      */
     appDelete: (params: import("./composer").AppDeleteParams) => Promise<Transaction>;
     /** Create an application call transaction.
@@ -487,14 +478,9 @@ export declare class AlgorandClientTransactionCreator {
      *  // 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,
      *})
      * ```
+     * @returns The application call transaction
      */
     appCall: (params: import("./composer").AppCallParams) => Promise<Transaction>;
     /** Create an application create call with ABI method call transaction.
@@ -509,8 +495,7 @@ export declare class AlgorandClientTransactionCreator {
      *   args: [{ name: 'arg1', type: 'string' }],
      *   returns: { type: 'string' },
      * })
-     * const result = await algorand.createTransaction.appCreateMethodCall({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE', method: method, args: ["arg1_value"] })
-     * const createdAppId = result.appId
+     * await algorand.createTransaction.appCreateMethodCall({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE', method: method, args: ["arg1_value"] })
      * ```
      * @example Advanced example
      * ```typescript
@@ -519,7 +504,7 @@ export declare class AlgorandClientTransactionCreator {
      *   args: [{ name: 'arg1', type: 'string' }],
      *   returns: { type: 'string' },
      * })
-     * await algorand.createTransaction.appCreate({
+     * await algorand.createTransaction.appCreateMethodCall({
      *  sender: 'CREATORADDRESS',
      *  method: method,
      *  args: ["arg1_value"],
@@ -548,14 +533,9 @@ export declare class AlgorandClientTransactionCreator {
      *  // 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,
      *})
      * ```
+     * @returns The application ABI method create transaction
      */
     appCreateMethodCall: (params: import("./composer").AppCreateMethodCall) => Promise<Expand<BuiltTransactions>>;
     /** Create an application update call with ABI method call transaction.
@@ -601,14 +581,9 @@ export declare class AlgorandClientTransactionCreator {
      *  // 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,
      *})
      * ```
+     * @returns The application ABI method update transaction
      */
     appUpdateMethodCall: (params: import("./composer").AppUpdateMethodCall) => Promise<Expand<BuiltTransactions>>;
     /** Create an application delete call with ABI method call transaction.
@@ -652,14 +627,9 @@ export declare class AlgorandClientTransactionCreator {
      *  // 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,
      *})
      * ```
+     * @returns The application ABI method delete transaction
      */
     appDeleteMethodCall: (params: import("./composer").AppDeleteMethodCall) => Promise<Expand<BuiltTransactions>>;
     /** Create an application call with ABI method call transaction.
@@ -703,18 +673,81 @@ export declare class AlgorandClientTransactionCreator {
      *  // 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,
      *})
      * ```
+     * @returns The application ABI method call transaction
      */
     appCallMethodCall: (params: import("./composer").AppCallMethodCall) => Promise<Expand<BuiltTransactions>>;
-    /** Create an online key registration transaction. */
+    /**
+     * Create an online key registration transaction.
+     * @param params The parameters for the key registration transaction
+     * @example Basic example
+     * ```typescript
+     * await algorand.createTransaction.onlineKeyRegistration({
+     *   sender: 'SENDERADDRESS',
+     *   voteKey: Uint8Array.from(Buffer.from("voteKeyBase64", 'base64')),
+     *   selectionKey: Uint8Array.from(Buffer.from("selectionKeyBase64", 'base64')),
+     *   stateProofKey: Uint8Array.from(Buffer.from("stateProofKeyBase64", 'base64')),
+     *   voteFirst: 1n,
+     *   voteLast: 1000n,
+     *   voteKeyDilution: 1n,
+     * })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * await algorand.createTransaction.onlineKeyRegistration({
+     *   sender: 'SENDERADDRESS',
+     *   voteKey: Uint8Array.from(Buffer.from("voteKeyBase64", 'base64')),
+     *   selectionKey: Uint8Array.from(Buffer.from("selectionKeyBase64", 'base64')),
+     *   stateProofKey: Uint8Array.from(Buffer.from("stateProofKeyBase64", 'base64')),
+     *   voteFirst: 1n,
+     *   voteLast: 1000n,
+     *   voteKeyDilution: 1n,
+     *   lease: 'lease',
+     *   note: 'note',
+     *   // Use this with caution, it's generally better to use algorand.account.rekeyAccount
+     *   rekeyTo: 'REKEYTOADDRESS',
+     *   // 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(),
+     * })
+     * ```
+     * @returns The online key registration transaction
+     */
     onlineKeyRegistration: (params: import("./composer").OnlineKeyRegistrationParams) => Promise<Transaction>;
-    /** Create an offline key registration transaction. */
+    /**
+     * Create an offline key registration transaction.
+     * @param params The parameters for the key registration transaction
+     * @example Basic example
+     * ```typescript
+     * await algorand.createTransaction.offlineKeyRegistration({
+     *   sender: 'SENDERADDRESS',
+     * })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * await algorand.createTransaction.offlineKeyRegistration({
+     *   sender: 'SENDERADDRESS',
+     *   lease: 'lease',
+     *   note: 'note',
+     *   // Use this with caution, it's generally better to use algorand.account.rekeyAccount
+     *   rekeyTo: 'REKEYTOADDRESS',
+     *   // 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(),
+     * })
+     * ```
+     * @returns The offline key registration transaction
+     */
     offlineKeyRegistration: (params: import("./composer").OfflineKeyRegistrationParams) => Promise<Transaction>;
 }

package/types/algorand-client-transaction-creator.js

@@ -5,6 +5,10 @@ class AlgorandClientTransactionCreator {
     /**
      * Creates a new `AlgorandClientTransactionCreator`
      * @param newGroup A lambda that starts a new `TransactionComposer` transaction group
+     * @example
+     * ```typescript
+     * const transactionCreator = new AlgorandClientTransactionCreator(() => new TransactionComposer())
+     * ```
      */
     constructor(newGroup) {
         /**
@@ -12,15 +16,15 @@ class AlgorandClientTransactionCreator {
          * @param params The parameters for the payment transaction
          * @example Basic example
          * ```typescript
-         * const result = await algorand.send.payment({
-         *  sender: 'SENDERADDRESS',
-         *  receiver: 'RECEIVERADDRESS',
-         *  amount: (4).algo(),
+         * await algorand.createTransaction.payment({
+         *   sender: 'SENDERADDRESS',
+         *   receiver: 'RECEIVERADDRESS',
+         *   amount: (4).algo(),
          * })
          * ```
          * @example Advanced example
          * ```typescript
-         * const result = await algorand.send.payment({
+         * await algorand.createTransaction.payment({
          *   amount: (4).algo(),
          *   receiver: 'RECEIVERADDRESS',
          *   sender: 'SENDERADDRESS',
@@ -39,7 +43,6 @@ class AlgorandClientTransactionCreator {
          *   maxFee: (3000).microAlgo(),
          * })
          * ```
-         *
          * @returns The payment transaction
          */
         this.payment = this._transaction((c) => c.addPayment);
@@ -52,7 +55,7 @@ class AlgorandClientTransactionCreator {
          *
          * @example Basic example
          * ```typescript
-         * await algorand.createTransaction.assetCreate({sender: "CREATORADDRESS", total: 100n})
+         * await algorand.createTransaction.assetCreate({ sender: "CREATORADDRESS", total: 100n})
          * ```
          * @example Advanced example
          * ```typescript
@@ -94,7 +97,7 @@ class AlgorandClientTransactionCreator {
          *
          * @example Basic example
          * ```typescript
-         * await algorand.createTransaction.assetConfig({sender: "MANAGERADDRESS", assetId: 123456n, manager: "MANAGERADDRESS" })
+         * await algorand.createTransaction.assetConfig({ sender: "MANAGERADDRESS", assetId: 123456n, manager: "MANAGERADDRESS" })
          * ```
          * @example Advanced example
          * ```typescript
@@ -126,7 +129,7 @@ class AlgorandClientTransactionCreator {
          *
          * @example Basic example
          * ```typescript
-         * await algorand.createTransaction.assetFreeze({sender: "MANAGERADDRESS", assetId: 123456n, account: "ACCOUNTADDRESS", frozen: true })
+         * await algorand.createTransaction.assetFreeze({ sender: "MANAGERADDRESS", assetId: 123456n, account: "ACCOUNTADDRESS", frozen: true })
          * ```
          * @example Advanced example
          * ```typescript
@@ -160,7 +163,7 @@ class AlgorandClientTransactionCreator {
          *
          * @example Basic example
          * ```typescript
-         * await algorand.createTransaction.assetDestroy({sender: "MANAGERADDRESS", assetId: 123456n })
+         * await algorand.createTransaction.assetDestroy({ sender: "MANAGERADDRESS", assetId: 123456n })
          * ```
          * @example Advanced example
          * ```typescript
@@ -188,7 +191,7 @@ class AlgorandClientTransactionCreator {
          *
          * @example Basic example
          * ```typescript
-         * await algorand.createTransaction.assetTransfer({sender: "HOLDERADDRESS", assetId: 123456n, amount: 1n, receiver: "RECEIVERADDRESS" })
+         * await algorand.createTransaction.assetTransfer({ sender: "HOLDERADDRESS", assetId: 123456n, amount: 1n, receiver: "RECEIVERADDRESS" })
          * ```
          * @example Advanced example (with clawback)
          * ```typescript
@@ -221,7 +224,7 @@ class AlgorandClientTransactionCreator {
          *
          * @example Basic example
          * ```typescript
-         * await algorand.createTransaction.assetOptIn({sender: "SENDERADDRESS", assetId: 123456n })
+         * await algorand.createTransaction.assetOptIn({ sender: "SENDERADDRESS", assetId: 123456n })
          * ```
          * @example Advanced example
          * ```typescript
@@ -250,13 +253,17 @@ class AlgorandClientTransactionCreator {
          *
          * @param params The parameters for the asset opt-out transaction
          *
-         * @example Basic example
+         * @example Basic example (without creator, will be retrieved from algod)
+         * ```typescript
+         * await algorand.createTransaction.assetOptOut({ sender: "SENDERADDRESS", assetId: 123456n, ensureZeroBalance: true })
+         * ```
+         * @example Basic example (with creator)
          * ```typescript
-         * await algorand.createTransaction.assetOptOut({sender: "SENDERADDRESS", creator: "CREATORADDRESS", assetId: 123456n })
+         * await algorand.createTransaction.assetOptOut({ sender: "SENDERADDRESS", creator: "CREATORADDRESS", assetId: 123456n, ensureZeroBalance: true })
          * ```
          * @example Advanced example
          * ```typescript
-         * await algorand.createTransaction.assetOptIn({
+         * await algorand.createTransaction.assetOptOut({
          *   sender: 'SENDERADDRESS',
          *   assetId: 123456n,
          *   creator: 'CREATORADDRESS',
@@ -283,8 +290,7 @@ class AlgorandClientTransactionCreator {
          * @param params The parameters for the app creation transaction
          * @example Basic example
          * ```typescript
-         * const result = await algorand.createTransaction.appCreate({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE' })
-         * const createdAppId = result.appId
+         * await algorand.createTransaction.appCreate({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE' })
          * ```
          * @example Advanced example
          * ```typescript
@@ -315,14 +321,9 @@ class AlgorandClientTransactionCreator {
          *  // 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,
          *})
          * ```
+         * @returns The application create transaction
          */
         this.appCreate = this._transaction((c) => c.addAppCreate);
         /** Create an application update transaction.
@@ -356,14 +357,9 @@ class AlgorandClientTransactionCreator {
          *  // 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,
          *})
          * ```
+         * @returns The application update transaction
          */
         this.appUpdate = this._transaction((c) => c.addAppUpdate);
         /** Create an application delete transaction.
@@ -395,14 +391,9 @@ class AlgorandClientTransactionCreator {
          *  // 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,
          *})
          * ```
+         * @returns The application delete transaction
          */
         this.appDelete = this._transaction((c) => c.addAppDelete);
         /** Create an application call transaction.
@@ -434,14 +425,9 @@ class AlgorandClientTransactionCreator {
          *  // 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,
          *})
          * ```
+         * @returns The application call transaction
          */
         this.appCall = this._transaction((c) => c.addAppCall);
         /** Create an application create call with ABI method call transaction.
@@ -456,8 +442,7 @@ class AlgorandClientTransactionCreator {
          *   args: [{ name: 'arg1', type: 'string' }],
          *   returns: { type: 'string' },
          * })
-         * const result = await algorand.createTransaction.appCreateMethodCall({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE', method: method, args: ["arg1_value"] })
-         * const createdAppId = result.appId
+         * await algorand.createTransaction.appCreateMethodCall({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE', method: method, args: ["arg1_value"] })
          * ```
          * @example Advanced example
          * ```typescript
@@ -466,7 +451,7 @@ class AlgorandClientTransactionCreator {
          *   args: [{ name: 'arg1', type: 'string' }],
          *   returns: { type: 'string' },
          * })
-         * await algorand.createTransaction.appCreate({
+         * await algorand.createTransaction.appCreateMethodCall({
          *  sender: 'CREATORADDRESS',
          *  method: method,
          *  args: ["arg1_value"],
@@ -495,14 +480,9 @@ class AlgorandClientTransactionCreator {
          *  // 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,
          *})
          * ```
+         * @returns The application ABI method create transaction
          */
         this.appCreateMethodCall = this._transactions((c) => c.addAppCreateMethodCall);
         /** Create an application update call with ABI method call transaction.
@@ -548,14 +528,9 @@ class AlgorandClientTransactionCreator {
          *  // 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,
          *})
          * ```
+         * @returns The application ABI method update transaction
          */
         this.appUpdateMethodCall = this._transactions((c) => c.addAppUpdateMethodCall);
         /** Create an application delete call with ABI method call transaction.
@@ -599,14 +574,9 @@ class AlgorandClientTransactionCreator {
          *  // 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,
          *})
          * ```
+         * @returns The application ABI method delete transaction
          */
         this.appDeleteMethodCall = this._transactions((c) => c.addAppDeleteMethodCall);
         /** Create an application call with ABI method call transaction.
@@ -650,19 +620,82 @@ class AlgorandClientTransactionCreator {
          *  // 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,
          *})
          * ```
+         * @returns The application ABI method call transaction
          */
         this.appCallMethodCall = this._transactions((c) => c.addAppCallMethodCall);
-        /** Create an online key registration transaction. */
+        /**
+         * Create an online key registration transaction.
+         * @param params The parameters for the key registration transaction
+         * @example Basic example
+         * ```typescript
+         * await algorand.createTransaction.onlineKeyRegistration({
+         *   sender: 'SENDERADDRESS',
+         *   voteKey: Uint8Array.from(Buffer.from("voteKeyBase64", 'base64')),
+         *   selectionKey: Uint8Array.from(Buffer.from("selectionKeyBase64", 'base64')),
+         *   stateProofKey: Uint8Array.from(Buffer.from("stateProofKeyBase64", 'base64')),
+         *   voteFirst: 1n,
+         *   voteLast: 1000n,
+         *   voteKeyDilution: 1n,
+         * })
+         * ```
+         * @example Advanced example
+         * ```typescript
+         * await algorand.createTransaction.onlineKeyRegistration({
+         *   sender: 'SENDERADDRESS',
+         *   voteKey: Uint8Array.from(Buffer.from("voteKeyBase64", 'base64')),
+         *   selectionKey: Uint8Array.from(Buffer.from("selectionKeyBase64", 'base64')),
+         *   stateProofKey: Uint8Array.from(Buffer.from("stateProofKeyBase64", 'base64')),
+         *   voteFirst: 1n,
+         *   voteLast: 1000n,
+         *   voteKeyDilution: 1n,
+         *   lease: 'lease',
+         *   note: 'note',
+         *   // Use this with caution, it's generally better to use algorand.account.rekeyAccount
+         *   rekeyTo: 'REKEYTOADDRESS',
+         *   // 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(),
+         * })
+         * ```
+         * @returns The online key registration transaction
+         */
         this.onlineKeyRegistration = this._transaction((c) => c.addOnlineKeyRegistration);
-        /** Create an offline key registration transaction. */
+        /**
+         * Create an offline key registration transaction.
+         * @param params The parameters for the key registration transaction
+         * @example Basic example
+         * ```typescript
+         * await algorand.createTransaction.offlineKeyRegistration({
+         *   sender: 'SENDERADDRESS',
+         * })
+         * ```
+         * @example Advanced example
+         * ```typescript
+         * await algorand.createTransaction.offlineKeyRegistration({
+         *   sender: 'SENDERADDRESS',
+         *   lease: 'lease',
+         *   note: 'note',
+         *   // Use this with caution, it's generally better to use algorand.account.rekeyAccount
+         *   rekeyTo: 'REKEYTOADDRESS',
+         *   // 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(),
+         * })
+         * ```
+         * @returns The offline key registration transaction
+         */
         this.offlineKeyRegistration = this._transaction((c) => c.addOfflineKeyRegistration);
         this._newGroup = newGroup;
     }