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

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

@@ -0,0 +1,433 @@
+import algosdk from 'algosdk';
+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;
+/** Orchestrates sending transactions for `AlgorandClient`. */
+export declare class AlgorandClientTransactionSender {
+    private _newGroup;
+    private _assetManager;
+    /**
+     * Creates a new `AlgorandClientSender`
+     * @param newGroup A lambda that starts a new `AlgoKitComposer` transaction group
+     * @param assetManager An `AssetManager` instance
+     */
+    constructor(newGroup: () => AlgoKitComposer, assetManager: AssetManager);
+    private _send;
+    /**
+     * 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({
+     *  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(),
+     *   // 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 result of the transaction and the transaction that was sent
+     */
+    payment: (params: import("./composer").CommonTransactionParams & {
+        receiver: string;
+        amount: import("./amount").AlgoAmount;
+        closeRemainderTo?: string | undefined;
+    } & ExecuteParams) => Promise<SendSingleTransactionResult>;
+    /**
+     * Create a new Algorand Standard Asset.
+     *
+     * 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.send.assetCreate({sender: "CREATORADDRESS", total: 100n})
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * await algorand.send.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(),
+     *   // 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 result of the transaction and the transaction that was sent
+     */
+    assetCreate: (params: AssetCreateParams & ExecuteParams) => Promise<{
+        assetId: bigint;
+        groupId: string;
+        txIds: string[];
+        returns?: import("./app").ABIReturn[] | undefined;
+        confirmations: algosdk.modelsv2.PendingTransactionResponse[];
+        transactions: algosdk.Transaction[];
+        confirmation: algosdk.modelsv2.PendingTransactionResponse;
+        transaction: algosdk.Transaction;
+    }>;
+    /**
+     * Configure 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.send.assetConfig({sender: "MANAGERADDRESS", assetId: 123456n, manager: "MANAGERADDRESS" })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * await algorand.send.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(),
+     *   // 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 result of the transaction and the transaction that was sent
+     */
+    assetConfig: (params: import("./composer").CommonTransactionParams & {
+        assetId: bigint;
+        manager: string | undefined;
+        reserve?: string | undefined;
+        freeze?: string | undefined;
+        clawback?: string | undefined;
+    } & ExecuteParams) => Promise<SendSingleTransactionResult>;
+    /**
+     * Freeze or unfreeze an Algorand Standard Asset for an account.
+     *
+     * @param params The parameters for the asset freeze transaction
+     *
+     * @example Basic example
+     * ```typescript
+     * await algorand.send.assetFreeze({sender: "MANAGERADDRESS", assetId: 123456n, account: "ACCOUNTADDRESS", frozen: true })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * await algorand.send.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(),
+     *   // 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 result of the transaction and the transaction that was sent
+     */
+    assetFreeze: (params: import("./composer").CommonTransactionParams & {
+        assetId: bigint;
+        account: string;
+        frozen: boolean;
+    } & ExecuteParams) => Promise<SendSingleTransactionResult>;
+    /**
+     * Destroys an Algorand Standard Asset.
+     *
+     * 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.send.assetDestroy({sender: "MANAGERADDRESS", assetId: 123456n })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * await algorand.send.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(),
+     *   // 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 result of the transaction and the transaction that was sent
+     */
+    assetDestroy: (params: import("./composer").CommonTransactionParams & {
+        assetId: bigint;
+    } & ExecuteParams) => Promise<SendSingleTransactionResult>;
+    /**
+     * Transfer an Algorand Standard Asset.
+     *
+     * @param params The parameters for the asset transfer transaction
+     *
+     * @example Basic example
+     * ```typescript
+     * await algorand.send.assetTransfer({sender: "HOLDERADDRESS", assetId: 123456n, amount: 1n, receiver: "RECEIVERADDRESS" })
+     * ```
+     * @example Advanced example (with clawback)
+     * ```typescript
+     * await algorand.send.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(),
+     *   // 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 result of the transaction and the transaction that was sent
+     */
+    assetTransfer: (params: import("./composer").CommonTransactionParams & {
+        assetId: bigint;
+        amount: bigint;
+        receiver: string;
+        clawbackTarget?: string | undefined;
+        closeAssetTo?: string | undefined;
+    } & ExecuteParams) => Promise<SendSingleTransactionResult>;
+    /**
+     * Opt an account into an Algorand Standard Asset.
+     *
+     * @param params The parameters for the asset opt-in transaction
+     *
+     * @example Basic example
+     * ```typescript
+     * await algorand.send.assetOptIn({sender: "SENDERADDRESS", assetId: 123456n })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * await algorand.send.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(),
+     *   // 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 result of the transaction and the transaction that was sent
+     */
+    assetOptIn: (params: import("./composer").CommonTransactionParams & {
+        assetId: bigint;
+    } & ExecuteParams) => Promise<SendSingleTransactionResult>;
+    /**
+     * Opt an account out of an Algorand Standard Asset.
+     *
+     * *Note:* If the account has a balance of the asset,
+     * it will not be able to opt-out unless `ensureZeroBalance`
+     * is set to `false` (but then the account will lose the assets).
+     *
+     * @param params The parameters for the asset opt-out transaction
+     *
+     * @example Basic example (without creator)
+     * ```typescript
+     * await algorand.send.assetOptOut({sender: "SENDERADDRESS", assetId: 123456n, ensureZeroBalance: true })
+     * ```
+     * @example Basic example (with creator)
+     * ```typescript
+     * await algorand.send.assetOptOut({sender: "SENDERADDRESS", creator: "CREATORADDRESS", assetId: 123456n, ensureZeroBalance: true })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * await algorand.send.assetOptOut({
+     *   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(),
+     *   // 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 result of the transaction and the transaction that was sent
+     */
+    assetOptOut: (params: Omit<AssetOptOutParams, 'creator'> & {
+        /** Optional asset creator account address; if not specified it will be retrieved from algod */
+        creator?: string;
+        /** 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.
+         *
+         * 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>;
+    /**
+     * Call a smart contract.
+     *
+     * Note: you may prefer to use `algorandClient.client` to get an app client for more advanced functionality.
+     */
+    appCall: (params: import("./composer").CommonTransactionParams & {
+        onComplete?: algosdk.OnApplicationComplete | undefined;
+        appId?: bigint | undefined;
+        approvalProgram?: Uint8Array | undefined;
+        clearProgram?: Uint8Array | undefined;
+        schema?: {
+            globalUints: number;
+            globalByteSlices: number;
+            localUints: number;
+            localByteSlices: number;
+        } | undefined;
+        args?: Uint8Array[] | undefined;
+        accountReferences?: string[] | undefined;
+        appReferences?: bigint[] | undefined;
+        assetReferences?: bigint[] | undefined;
+        extraPages?: number | undefined;
+        boxReferences?: algosdk.BoxReference[] | undefined;
+    } & ExecuteParams) => Promise<SendSingleTransactionResult>;
+    /**
+     * Call a smart contract ABI method.
+     *
+     * Note: you may prefer to use `algorandClient.client` to get an app client for more advanced functionality.
+     */
+    methodCall: (params: import("./composer").CommonTransactionParams & Omit<import("./composer").AppCallParams, "args"> & {
+        appId: bigint;
+        method: algosdk.ABIMethod;
+        args?: (algosdk.TransactionWithSigner | algosdk.Transaction | algosdk.ABIValue | Promise<algosdk.Transaction> | import("./composer").MethodCallParams)[] | undefined;
+    } & ExecuteParams) => Promise<SendSingleTransactionResult>;
+    /** Register an online key. */
+    onlineKeyRegistration: (params: import("./composer").CommonTransactionParams & {
+        voteKey: Uint8Array;
+        selectionKey: Uint8Array;
+        voteFirst: bigint;
+        voteLast: bigint;
+        voteKeyDilution: bigint;
+        stateProofKey?: Uint8Array | undefined;
+    } & ExecuteParams) => Promise<SendSingleTransactionResult>;
+}
+//# sourceMappingURL=algorand-client-transaction-sender.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"algorand-client-transaction-sender.d.ts","sourceRoot":"","sources":["../../src/types/algorand-client-transaction-sender.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,SAAS,CAAA;AAE7B,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAC9C,OAAO,eAAe,EAAE,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AACjG,OAAO,EAAE,0BAA0B,EAAE,oCAAoC,EAAE,MAAM,eAAe,CAAA;AAIhG,gDAAgD;AAChD,MAAM,MAAM,2BAA2B,GAAG,oCAAoC,GAAG,0BAA0B,CAAA;AAE3G,8DAA8D;AAC9D,qBAAa,+BAA+B;IAC1C,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,aAAa,CAAc;IAEnC;;;;OAIG;gBACS,QAAQ,EAAE,MAAM,eAAe,EAAE,YAAY,EAAE,YAAY;IAKvE,OAAO,CAAC,KAAK;IAmCb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACH,OAAO;;;;0BAtE2B,QAAQ,2BAA2B,CAAC,CAyEpE;IACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8CG;IACH,WAAW,WAAkB,iBAAiB,GAAG,aAAa;;;;;;;;;OAM7D;IACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,WAAW;;;;;;0BA1KuB,QAAQ,2BAA2B,CAAC,CA4KpE;IACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,WAAW;;;;0BAjNuB,QAAQ,2BAA2B,CAAC,CAmNpE;IACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,YAAY;;0BA1PsB,QAAQ,2BAA2B,CAAC,CA4PpE;IACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,aAAa;;;;;;0BApSqB,QAAQ,2BAA2B,CAAC,CAuSpE;IACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,UAAU;;0BA1UwB,QAAQ,2BAA2B,CAAC,CA4UpE;IACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,WAAW,WACD,KAAK,iBAAiB,EAAE,SAAS,CAAC,GAAG;QAC3C,+FAA+F;QAC/F,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB;;;;;WAKG;QACH,iBAAiB,EAAE,OAAO,CAAA;KAC3B,GAAG,aAAa,0CAqBlB;IACD;;;;OAIG;IACH,OAAO;;;;;;;;;;;;;;;;;0BA/Z2B,QAAQ,2BAA2B,CAAC,CA+Z7B;IACzC;;;;OAIG;IACH,UAAU;;;;0BArawB,QAAQ,2BAA2B,CAAC,CAqavB;IAC/C,8BAA8B;IAC9B,qBAAqB;;;;;;;0BAvaa,QAAQ,2BAA2B,CAAC,CAyapE;CACH"}