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

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

@@ -0,0 +1,289 @@
+import algosdk from 'algosdk';
+import AlgoKitComposer, { MethodCallParams } from './composer';
+import Transaction = algosdk.Transaction;
+/** Orchestrates creating transactions for `AlgorandClient`. */
+export declare class AlgorandClientTransactionCreator {
+    private _newGroup;
+    /**
+     * Creates a new `AlgorandClientTransactionCreator`
+     * @param newGroup A lambda that starts a new `AlgoKitComposer` transaction group
+     */
+    constructor(newGroup: () => AlgoKitComposer);
+    private _transaction;
+    /**
+     * 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({
+     *  sender: 'SENDERADDRESS',
+     *  receiver: 'RECEIVERADDRESS',
+     *  amount: (4).algo(),
+     * })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * const result = await algorandClient.send.payment({
+     *   amount: (4).algo(),
+     *   receiver: 'RECEIVERADDRESS',
+     *   sender: 'SENDERADDRESS',
+     *   closeRemainderTo: 'CLOSEREMAINDERTOADDRESS',
+     *   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 payment transaction
+     */
+    payment: (params: import("./composer").PaymentParams) => Promise<Transaction>;
+    /** Create a create Algorand Standard Asset transaction.
+     *
+     * The account that sends this transaction will automatically be
+     * opted in to the asset and will hold all units after creation.
+     *
+     * @param params The parameters for the asset creation transaction
+     *
+     * @example Basic example
+     * ```typescript
+     * await algorand.transaction.assetCreate({sender: "CREATORADDRESS", total: 100n})
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * await algorand.transaction.assetCreate({
+     *   sender: 'CREATORADDRESS',
+     *   total: 100n,
+     *   decimals: 2,
+     *   assetName: 'asset',
+     *   unitName: 'unit',
+     *   url: 'url',
+     *   metadataHash: 'metadataHash',
+     *   defaultFrozen: false,
+     *   manager: 'MANAGERADDRESS',
+     *   reserve: 'RESERVEADDRESS',
+     *   freeze: 'FREEZEADDRESS',
+     *   clawback: 'CLAWBACKADDRESS',
+     *   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(),
+     * })
+     * ```
+     * @returns The asset create transaction
+     */
+    assetCreate: (params: import("./composer").AssetCreateParams) => Promise<Transaction>;
+    /** Create an asset config transaction to reconfigure an existing Algorand Standard Asset.
+     *
+     * **Note:** The manager, reserve, freeze, and clawback addresses
+     * are immutably empty if they are not set. If manager is not set then
+     * all fields are immutable from that point forward.
+     *
+     * @param params The parameters for the asset config transaction
+     *
+     * @example Basic example
+     * ```typescript
+     * await algorand.transaction.assetConfig({sender: "MANAGERADDRESS", assetId: 123456n, manager: "MANAGERADDRESS" })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * await algorand.transaction.assetConfig({
+     *   sender: 'MANAGERADDRESS',
+     *   assetId: 123456n,
+     *   manager: 'MANAGERADDRESS',
+     *   reserve: 'RESERVEADDRESS',
+     *   freeze: 'FREEZEADDRESS',
+     *   clawback: 'CLAWBACKADDRESS',
+     *   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(),
+     * })
+     * ```
+     * @returns The asset config transaction
+     */
+    assetConfig: (params: import("./composer").AssetConfigParams) => Promise<Transaction>;
+    /** Create an Algorand Standard Asset freeze transaction.
+     *
+     * @param params The parameters for the asset freeze transaction
+     *
+     * @example Basic example
+     * ```typescript
+     * await algorand.transaction.assetFreeze({sender: "MANAGERADDRESS", assetId: 123456n, account: "ACCOUNTADDRESS", frozen: true })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * await algorand.transaction.assetFreeze({
+     *   sender: 'MANAGERADDRESS',
+     *   assetId: 123456n,
+     *   account: 'ACCOUNTADDRESS',
+     *   frozen: true,
+     *   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(),
+     * })
+     * ```
+     * @returns The asset freeze transaction
+     */
+    assetFreeze: (params: import("./composer").AssetFreezeParams) => Promise<Transaction>;
+    /** Create an Algorand Standard Asset destroy transaction.
+     *
+     * Created assets can be destroyed only by the asset manager account.
+     * All of the assets must be owned by the creator of the asset before
+     * the asset can be deleted.
+     *
+     * @param params The parameters for the asset destroy transaction
+     *
+     * @example Basic example
+     * ```typescript
+     * await algorand.transaction.assetDestroy({sender: "MANAGERADDRESS", assetId: 123456n })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * await algorand.transaction.assetDestroy({
+     *   sender: 'MANAGERADDRESS',
+     *   assetId: 123456n,
+     *   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(),
+     * })
+     * ```
+     * @returns The asset destroy transaction
+     */
+    assetDestroy: (params: import("./composer").AssetDestroyParams) => Promise<Transaction>;
+    /** Create an Algorand Standard Asset transfer transaction.
+     *
+     * @param params The parameters for the asset transfer transaction
+     *
+     * @example Basic example
+     * ```typescript
+     * await algorand.transaction.assetTransfer({sender: "HOLDERADDRESS", assetId: 123456n, amount: 1n, receiver: "RECEIVERADDRESS" })
+     * ```
+     * @example Advanced example (with clawback)
+     * ```typescript
+     * await algorand.transaction.assetTransfer({
+     *   sender: 'CLAWBACKADDRESS',
+     *   assetId: 123456n,
+     *   amount: 1n,
+     *   receiver: 'RECEIVERADDRESS',
+     *   clawbackTarget: 'HOLDERADDRESS',
+     *   // This field needs to be used with caution
+     *   closeAssetTo: 'ADDRESSTOCLOSETO'
+     *   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(),
+     * })
+     * ```
+     * @returns The result of the asset transfer transaction
+     */
+    assetTransfer: (params: import("./composer").AssetTransferParams) => Promise<Transaction>;
+    /** Create an Algorand Standard Asset opt-in transaction.
+     *
+     * @param params The parameters for the asset opt-in transaction
+     *
+     * @example Basic example
+     * ```typescript
+     * await algorand.transaction.assetOptIn({sender: "SENDERADDRESS", assetId: 123456n })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * await algorand.transaction.assetOptIn({
+     *   sender: 'SENDERADDRESS',
+     *   assetId: 123456n,
+     *   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(),
+     * })
+     * ```
+     * @returns The asset opt-in transaction
+     */
+    assetOptIn: (params: import("./composer").AssetOptInParams) => Promise<Transaction>;
+    /** Create an asset opt-out transaction.
+     *
+     * *Note:* If the account has a balance of the asset,
+     * it will lose those assets
+     *
+     * @param params The parameters for the asset opt-out transaction
+     *
+     * @example Basic example
+     * ```typescript
+     * await algorand.transaction.assetOptOut({sender: "SENDERADDRESS", creator: "CREATORADDRESS", assetId: 123456n })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * await algorand.transaction.assetOptIn({
+     *   sender: 'SENDERADDRESS',
+     *   assetId: 123456n,
+     *   creator: 'CREATORADDRESS',
+     *   ensureZeroBalance: true,
+     *   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(),
+     * })
+     * ```
+     * @returns The asset opt-out transaction
+     */
+    assetOptOut: (params: import("./composer").AssetOptOutParams) => Promise<Transaction>;
+    /** Create an application call transaction. */
+    appCall: (params: import("./composer").AppCallParams) => Promise<Transaction>;
+    /** Create an application call with ABI method call transaction. */
+    methodCall: (params: MethodCallParams) => Promise<algosdk.Transaction[]>;
+    /** Create an online key registration transaction. */
+    onlineKeyRegistration: (params: import("./composer").OnlineKeyRegistrationParams) => Promise<Transaction>;
+}
+//# sourceMappingURL=algorand-client-transaction-creator.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,299 @@
+'use strict';
+
+/** Orchestrates creating transactions for `AlgorandClient`. */
+class AlgorandClientTransactionCreator {
+    /**
+     * Creates a new `AlgorandClientTransactionCreator`
+     * @param newGroup A lambda that starts a new `AlgoKitComposer` transaction group
+     */
+    constructor(newGroup) {
+        /**
+         * 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({
+         *  sender: 'SENDERADDRESS',
+         *  receiver: 'RECEIVERADDRESS',
+         *  amount: (4).algo(),
+         * })
+         * ```
+         * @example Advanced example
+         * ```typescript
+         * const result = await algorandClient.send.payment({
+         *   amount: (4).algo(),
+         *   receiver: 'RECEIVERADDRESS',
+         *   sender: 'SENDERADDRESS',
+         *   closeRemainderTo: 'CLOSEREMAINDERTOADDRESS',
+         *   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 payment transaction
+         */
+        this.payment = this._transaction((c) => c.addPayment);
+        /** Create a create Algorand Standard Asset transaction.
+         *
+         * The account that sends this transaction will automatically be
+         * opted in to the asset and will hold all units after creation.
+         *
+         * @param params The parameters for the asset creation transaction
+         *
+         * @example Basic example
+         * ```typescript
+         * await algorand.transaction.assetCreate({sender: "CREATORADDRESS", total: 100n})
+         * ```
+         * @example Advanced example
+         * ```typescript
+         * await algorand.transaction.assetCreate({
+         *   sender: 'CREATORADDRESS',
+         *   total: 100n,
+         *   decimals: 2,
+         *   assetName: 'asset',
+         *   unitName: 'unit',
+         *   url: 'url',
+         *   metadataHash: 'metadataHash',
+         *   defaultFrozen: false,
+         *   manager: 'MANAGERADDRESS',
+         *   reserve: 'RESERVEADDRESS',
+         *   freeze: 'FREEZEADDRESS',
+         *   clawback: 'CLAWBACKADDRESS',
+         *   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(),
+         * })
+         * ```
+         * @returns The asset create transaction
+         */
+        this.assetCreate = this._transaction((c) => c.addAssetCreate);
+        /** Create an asset config transaction to reconfigure an existing Algorand Standard Asset.
+         *
+         * **Note:** The manager, reserve, freeze, and clawback addresses
+         * are immutably empty if they are not set. If manager is not set then
+         * all fields are immutable from that point forward.
+         *
+         * @param params The parameters for the asset config transaction
+         *
+         * @example Basic example
+         * ```typescript
+         * await algorand.transaction.assetConfig({sender: "MANAGERADDRESS", assetId: 123456n, manager: "MANAGERADDRESS" })
+         * ```
+         * @example Advanced example
+         * ```typescript
+         * await algorand.transaction.assetConfig({
+         *   sender: 'MANAGERADDRESS',
+         *   assetId: 123456n,
+         *   manager: 'MANAGERADDRESS',
+         *   reserve: 'RESERVEADDRESS',
+         *   freeze: 'FREEZEADDRESS',
+         *   clawback: 'CLAWBACKADDRESS',
+         *   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(),
+         * })
+         * ```
+         * @returns The asset config transaction
+         */
+        this.assetConfig = this._transaction((c) => c.addAssetConfig);
+        /** Create an Algorand Standard Asset freeze transaction.
+         *
+         * @param params The parameters for the asset freeze transaction
+         *
+         * @example Basic example
+         * ```typescript
+         * await algorand.transaction.assetFreeze({sender: "MANAGERADDRESS", assetId: 123456n, account: "ACCOUNTADDRESS", frozen: true })
+         * ```
+         * @example Advanced example
+         * ```typescript
+         * await algorand.transaction.assetFreeze({
+         *   sender: 'MANAGERADDRESS',
+         *   assetId: 123456n,
+         *   account: 'ACCOUNTADDRESS',
+         *   frozen: true,
+         *   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(),
+         * })
+         * ```
+         * @returns The asset freeze transaction
+         */
+        this.assetFreeze = this._transaction((c) => c.addAssetFreeze);
+        /** Create an Algorand Standard Asset destroy transaction.
+         *
+         * Created assets can be destroyed only by the asset manager account.
+         * All of the assets must be owned by the creator of the asset before
+         * the asset can be deleted.
+         *
+         * @param params The parameters for the asset destroy transaction
+         *
+         * @example Basic example
+         * ```typescript
+         * await algorand.transaction.assetDestroy({sender: "MANAGERADDRESS", assetId: 123456n })
+         * ```
+         * @example Advanced example
+         * ```typescript
+         * await algorand.transaction.assetDestroy({
+         *   sender: 'MANAGERADDRESS',
+         *   assetId: 123456n,
+         *   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(),
+         * })
+         * ```
+         * @returns The asset destroy transaction
+         */
+        this.assetDestroy = this._transaction((c) => c.addAssetDestroy);
+        /** Create an Algorand Standard Asset transfer transaction.
+         *
+         * @param params The parameters for the asset transfer transaction
+         *
+         * @example Basic example
+         * ```typescript
+         * await algorand.transaction.assetTransfer({sender: "HOLDERADDRESS", assetId: 123456n, amount: 1n, receiver: "RECEIVERADDRESS" })
+         * ```
+         * @example Advanced example (with clawback)
+         * ```typescript
+         * await algorand.transaction.assetTransfer({
+         *   sender: 'CLAWBACKADDRESS',
+         *   assetId: 123456n,
+         *   amount: 1n,
+         *   receiver: 'RECEIVERADDRESS',
+         *   clawbackTarget: 'HOLDERADDRESS',
+         *   // This field needs to be used with caution
+         *   closeAssetTo: 'ADDRESSTOCLOSETO'
+         *   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(),
+         * })
+         * ```
+         * @returns The result of the asset transfer transaction
+         */
+        this.assetTransfer = this._transaction((c) => c.addAssetTransfer);
+        /** Create an Algorand Standard Asset opt-in transaction.
+         *
+         * @param params The parameters for the asset opt-in transaction
+         *
+         * @example Basic example
+         * ```typescript
+         * await algorand.transaction.assetOptIn({sender: "SENDERADDRESS", assetId: 123456n })
+         * ```
+         * @example Advanced example
+         * ```typescript
+         * await algorand.transaction.assetOptIn({
+         *   sender: 'SENDERADDRESS',
+         *   assetId: 123456n,
+         *   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(),
+         * })
+         * ```
+         * @returns The asset opt-in transaction
+         */
+        this.assetOptIn = this._transaction((c) => c.addAssetOptIn);
+        /** Create an asset opt-out transaction.
+         *
+         * *Note:* If the account has a balance of the asset,
+         * it will lose those assets
+         *
+         * @param params The parameters for the asset opt-out transaction
+         *
+         * @example Basic example
+         * ```typescript
+         * await algorand.transaction.assetOptOut({sender: "SENDERADDRESS", creator: "CREATORADDRESS", assetId: 123456n })
+         * ```
+         * @example Advanced example
+         * ```typescript
+         * await algorand.transaction.assetOptIn({
+         *   sender: 'SENDERADDRESS',
+         *   assetId: 123456n,
+         *   creator: 'CREATORADDRESS',
+         *   ensureZeroBalance: true,
+         *   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(),
+         * })
+         * ```
+         * @returns The asset opt-out transaction
+         */
+        this.assetOptOut = this._transaction((c) => c.addAssetOptOut);
+        /** Create an application call transaction. */
+        this.appCall = this._transaction((c) => c.addAppCall);
+        /** Create an application call with ABI method call transaction. */
+        this.methodCall = async (params) => {
+            return await this._newGroup().addMethodCall(params).buildTransactions();
+        };
+        /** Create an online key registration transaction. */
+        this.onlineKeyRegistration = this._transaction((c) => c.addOnlineKeyRegistration);
+        this._newGroup = newGroup;
+    }
+    _transaction(c) {
+        return async (params) => {
+            const composer = this._newGroup();
+            const result = await c(composer).apply(composer, [params]).buildTransactions();
+            return result[result.length - 1];
+        };
+    }
+}
+
+exports.AlgorandClientTransactionCreator = AlgorandClientTransactionCreator;
+//# sourceMappingURL=algorand-client-transaction-creator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"algorand-client-transaction-creator.js","sources":["../../src/types/algorand-client-transaction-creator.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA;MACa,gCAAgC,CAAA;AAG3C;;;AAGG;AACH,IAAA,WAAA,CAAY,QAA+B,EAAA;AAY3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCG;AACH,QAAA,IAAA,CAAA,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,CAAA;AAChD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCG;AACH,QAAA,IAAA,CAAA,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,cAAc,CAAC,CAAA;AACxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCG;AACH,QAAA,IAAA,CAAA,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,cAAc,CAAC,CAAA;AACxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACH,QAAA,IAAA,CAAA,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,cAAc,CAAC,CAAA;AACxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BG;AACH,QAAA,IAAA,CAAA,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,eAAe,CAAC,CAAA;AAC1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BG;AACH,QAAA,IAAA,CAAA,aAAa,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,gBAAgB,CAAC,CAAA;AAC5D;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACH,QAAA,IAAA,CAAA,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,aAAa,CAAC,CAAA;AACtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BG;AACH,QAAA,IAAA,CAAA,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,cAAc,CAAC,CAAA;;AAExD,QAAA,IAAA,CAAA,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,CAAA;;AAEhD,QAAA,IAAA,CAAA,UAAU,GAAG,OAAO,MAAwB,KAAI;AAC9C,YAAA,OAAO,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,iBAAiB,EAAE,CAAA;AACzE,SAAC,CAAA;;AAED,QAAA,IAAA,CAAA,qBAAqB,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,wBAAwB,CAAC,CAAA;AA/R1E,QAAA,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAA;KAC1B;AAEO,IAAA,YAAY,CAAI,CAAyD,EAAA;AAC/E,QAAA,OAAO,OAAO,MAAS,KAAI;AACzB,YAAA,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,EAAE,CAAA;AACjC,YAAA,MAAM,MAAM,GAAG,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,iBAAiB,EAAE,CAAA;YAC9E,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;AAClC,SAAC,CAAA;KACF;AAuRF;;;;"}