@hiero-ledger/sdk 2.80.0 → 2.81.0-beta.1

package/src/Transfer.js

@@ -2,6 +2,8 @@
 
 import AccountId from "./account/AccountId.js";
 import Hbar from "./Hbar.js";
+import FungibleHookCall from "./hooks/FungibleHookCall.js";
+import FungibleHookType from "./hooks/FungibleHookType.js";
 
 /**
  * @typedef {object} TransferJSON
@@ -31,6 +33,7 @@ export default class Transfer {
      * @param {AccountId | string} props.accountId
      * @param {number | string | Long | BigNumber | Hbar} props.amount
      * @param {boolean} props.isApproved
+     * @param {FungibleHookCall} [props.hookCall]
      */
     constructor(props) {
         /**
@@ -52,6 +55,7 @@ export default class Transfer {
                 : new Hbar(props.amount);
 
         this.isApproved = props.isApproved;
+        this.hookCall = props.hookCall;
     }
 
     /**
@@ -63,6 +67,19 @@ export default class Transfer {
         const transfers = [];
 
         for (const transfer of accountAmounts) {
+            let hookCall = undefined;
+            if (transfer.preTxAllowanceHook != null) {
+                hookCall = FungibleHookCall._fromProtobufWithType(
+                    transfer.preTxAllowanceHook,
+                    FungibleHookType.PRE_TX_ALLOWANCE_HOOK,
+                );
+            } else if (transfer.prePostTxAllowanceHook != null) {
+                hookCall = FungibleHookCall._fromProtobufWithType(
+                    transfer.prePostTxAllowanceHook,
+                    FungibleHookType.PRE_POST_TX_ALLOWANCE_HOOK,
+                );
+            }
+
             transfers.push(
                 new Transfer({
                     accountId: AccountId._fromProtobuf(
@@ -74,6 +91,7 @@ export default class Transfer {
                         transfer.amount != null ? transfer.amount : 0,
                     ),
                     isApproved: /** @type {boolean} */ (transfer.isApproval),
+                    hookCall,
                 }),
             );
         }
@@ -86,11 +104,25 @@ export default class Transfer {
      * @returns {HieroProto.proto.IAccountAmount}
      */
     _toProtobuf() {
-        return {
+        /** @type {HieroProto.proto.IAccountAmount} */
+        const result = {
             accountID: this.accountId._toProtobuf(),
             amount: this.amount.toTinybars(),
             isApproval: this.isApproved,
         };
+
+        if (this.hookCall != null) {
+            switch (this.hookCall.type) {
+                case FungibleHookType.PRE_TX_ALLOWANCE_HOOK:
+                    result.preTxAllowanceHook = this.hookCall._toProtobuf();
+                    break;
+                case FungibleHookType.PRE_POST_TX_ALLOWANCE_HOOK:
+                    result.prePostTxAllowanceHook = this.hookCall._toProtobuf();
+                    break;
+            }
+        }
+
+        return result;
     }
 
     /**

package/src/account/AccountCreateTransaction.js

@@ -39,6 +39,7 @@ export default class AccountCreateTransaction extends Transaction {
      * @param {Long | number} [props.stakedNodeId]
      * @param {boolean} [props.declineStakingReward]
      * @param {EvmAddress} [props.alias]
+     * @param {import("../hooks/HookCreationDetails.js").default[]} [props.hooks]
      */
     constructor(props = {}) {
         super();
@@ -121,6 +122,18 @@ export default class AccountCreateTransaction extends Transaction {
          */
         this._alias = null;
 
+        /**
+         * @private
+         * @type {import("../hooks/HookCreationDetails.js").default[]}
+         */
+        this._hooks = [];
+
+        if (props.hooks != null) {
+            props.hooks.forEach((hook) => {
+                this.addHook(hook);
+            });
+        }
+
         if (props.key != null) {
             this.setKeyWithoutAlias(props.key);
         }
@@ -652,10 +665,36 @@ export default class AccountCreateTransaction extends Transaction {
                     : null,
             stakedNodeId: this.stakedNodeId,
             declineReward: this.declineStakingRewards,
+            hookCreationDetails: this._hooks.map((hook) => hook._toProtobuf()),
             alias,
         };
     }
 
+    /**
+     * @param {import("../hooks/HookCreationDetails.js").default} hook
+     * @returns {this}
+     */
+    addHook(hook) {
+        this._hooks.push(hook);
+        return this;
+    }
+
+    /**
+     * @param {import("../hooks/HookCreationDetails.js").default[]} hooks
+     * @returns {this}
+     */
+    setHooks(hooks) {
+        this._hooks = hooks;
+        return this;
+    }
+
+    /**
+     * @returns {import("../hooks/HookCreationDetails.js").default[]}
+     */
+    get hooks() {
+        return this._hooks;
+    }
+
     /**
      * @returns {string}
      */

package/src/account/AccountUpdateTransaction.js

@@ -44,6 +44,8 @@ export default class AccountUpdateTransaction extends Transaction {
      * @param {AccountId | string} [props.stakedAccountId]
      * @param {Long | number} [props.stakedNodeId]
      * @param {?boolean} [props.declineStakingReward]
+     * @param {import("../hooks/HookCreationDetails.js").default[]} [props.hooksToBeCreated]
+     * @param {Long[]} [props.hooksToBeDeleted]
      */
     constructor(props = {}) {
         super();
@@ -120,6 +122,18 @@ export default class AccountUpdateTransaction extends Transaction {
          */
         this._declineStakingReward = null;
 
+        /**
+         * @private
+         * @type {import("../hooks/HookCreationDetails.js").default[]}
+         */
+        this._hooksToBeCreated = [];
+
+        /**
+         * @private
+         * @type {Long[]}
+         */
+        this._hooksToBeDeleted = [];
+
         if (props.accountId != null) {
             this.setAccountId(props.accountId);
         }
@@ -166,6 +180,14 @@ export default class AccountUpdateTransaction extends Transaction {
         if (props.declineStakingReward != null) {
             this.setDeclineStakingReward(props.declineStakingReward);
         }
+
+        if (props.hooksToBeCreated != null) {
+            this.setHooksToCreate(props.hooksToBeCreated);
+        }
+
+        if (props.hooksToBeDeleted != null) {
+            this.setHooksToDelete(props.hooksToBeDeleted);
+        }
     }
 
     /**
@@ -533,6 +555,57 @@ export default class AccountUpdateTransaction extends Transaction {
         return this;
     }
 
+    /**
+     * @param {import("../hooks/HookCreationDetails.js").default} hook
+     * @returns {this}
+     */
+    addHookToCreate(hook) {
+        this._hooksToBeCreated.push(hook);
+        return this;
+    }
+
+    /**
+     * @param {import("../hooks/HookCreationDetails.js").default[]} hooks
+     * @returns {this}
+     */
+    setHooksToCreate(hooks) {
+        this._hooksToBeCreated = hooks;
+        return this;
+    }
+
+    /**
+     * @returns {import("../hooks/HookCreationDetails.js").default[]}
+     */
+    get hooksToCreate() {
+        return this._hooksToBeCreated;
+    }
+
+    /**
+     *
+     * @param {Long} hook
+     * @returns {this}
+     */
+    addHookToDelete(hook) {
+        this._hooksToBeDeleted.push(hook);
+        return this;
+    }
+
+    /**
+     * @param {Long[]} hookIds
+     * @returns {this}
+     */
+    setHooksToDelete(hookIds) {
+        this._hooksToBeDeleted = hookIds;
+        return this;
+    }
+
+    /**
+     * @returns {Long[]}
+     */
+    get hooksToDelete() {
+        return this._hooksToBeDeleted;
+    }
+
     /**
      * @param {Client} client
      */
@@ -613,6 +686,11 @@ export default class AccountUpdateTransaction extends Transaction {
                 this.declineStakingRewards != null
                     ? { value: this.declineStakingRewards }
                     : null,
+
+            hookIdsToDelete: this._hooksToBeDeleted,
+            hookCreationDetails: this._hooksToBeCreated.map((hook) =>
+                hook._toProtobuf(),
+            ),
         };
     }
 

package/src/account/TransferTransaction.js

@@ -12,6 +12,8 @@ import HbarTransferMap from "./HbarTransferMap.js";
 import TokenNftTransfer from "../token/TokenNftTransfer.js";
 import NftId from "../token/NftId.js";
 import AbstractTokenTransferTransaction from "../token/AbstractTokenTransferTransaction.js";
+import FungibleHookCall from "../hooks/FungibleHookCall.js";
+import NftHookCall from "../hooks/NftHookCall.js";
 
 /**
  * @typedef {import("../long.js").LongObject} LongObject
@@ -169,9 +171,10 @@ export default class TransferTransaction extends AbstractTokenTransferTransactio
      * @param {AccountId | string} accountId
      * @param {number | string | Long | LongObject | BigNumber | Hbar} amount
      * @param {boolean} isApproved
+     * @param {FungibleHookCall} [hookCall]
      * @returns {TransferTransaction}
      */
-    _addHbarTransfer(accountId, amount, isApproved) {
+    _addHbarTransfer(accountId, amount, isApproved, hookCall) {
         this._requireNotFrozen();
 
         const account =
@@ -194,6 +197,7 @@ export default class TransferTransaction extends AbstractTokenTransferTransactio
                 accountId: account,
                 amount: hbars,
                 isApproved,
+                hookCall,
             }),
         );
 
@@ -310,6 +314,82 @@ export default class TransferTransaction extends AbstractTokenTransferTransactio
         return this;
     }
 
+    /**
+     *
+     * @param {AccountId} accountId
+     * @param {Long} amount
+     * @param {FungibleHookCall} hook
+     * @returns {TransferTransaction}
+     */
+    addHbarTransferWithHook(accountId, amount, hook) {
+        const isApproved = false; // this is not approved transfer, adding comment for clarity
+        return this._addHbarTransfer(
+            accountId,
+            amount,
+            isApproved,
+            new FungibleHookCall({
+                hookId: hook.hookId,
+                evmHookCall: hook.evmHookCall,
+                type: hook.type,
+            }),
+        );
+    }
+
+    /**
+     *
+     * @param {NftId} nftId
+     * @param {AccountId} sender
+     * @param {AccountId} receiver
+     * @param {NftHookCall} senderHookCall
+     * @param {NftHookCall} receiverHookCall
+     * @returns {TransferTransaction}
+     */
+    addNftTransferWithHook(
+        nftId,
+        sender,
+        receiver,
+        senderHookCall,
+        receiverHookCall,
+    ) {
+        return this._addNftTransfer(
+            false,
+            nftId,
+            sender,
+            receiver,
+            undefined, // receiver
+            senderHookCall,
+            receiverHookCall,
+        );
+    }
+
+    /**
+     *
+     * @param {TokenId} tokenId
+     * @param {AccountId} accountId
+     * @param {Long} amount
+     * @param {FungibleHookCall} hook
+     * @returns {TransferTransaction}
+     */
+    addTokenTransferWithHook(tokenId, accountId, amount, hook) {
+        const fungibleHook = new FungibleHookCall({
+            hookId: hook.hookId != null ? hook.hookId : undefined,
+            evmHookCall:
+                hook.evmHookCall != null ? hook.evmHookCall : undefined,
+            type: hook.type,
+        });
+
+        const isApproved = false; // this is not approved transfer, adding comment for clarity
+        const expectedDecimals = null; // we don't expect  decimals here, adding comment for clarity
+
+        return this._addTokenTransfer(
+            tokenId,
+            accountId,
+            amount,
+            isApproved,
+            expectedDecimals,
+            fungibleHook,
+        );
+    }
     /**
      * @override
      * @internal
@@ -342,13 +422,9 @@ export default class TransferTransaction extends AbstractTokenTransferTransactio
 
         return {
             transfers: {
-                accountAmounts: this._hbarTransfers.map((transfer) => {
-                    return {
-                        accountID: transfer.accountId._toProtobuf(),
-                        amount: transfer.amount.toTinybars(),
-                        isApproval: transfer.isApproved,
-                    };
-                }),
+                accountAmounts: this._hbarTransfers.map((transfer) =>
+                    transfer._toProtobuf(),
+                ),
             },
             tokenTransfers,
         };

package/src/client/Client.js

@@ -132,6 +132,18 @@ export default class Client {
         /** @private */
         this._defaultRegenerateTransactionId = true;
 
+        /**
+         * When enabled, allows receipt queries to fail over to other nodes
+         * if the submitting node is unresponsive. Default is false to preserve
+         * existing semantics where receipt queries are pinned to the submitting node.
+         *
+         * Tradeoff: Improved availability vs the rare case where only the submitting
+         * node may have final failure information.
+         *
+         * @private
+         */
+        this._allowReceiptNodeFailover = false;
+
         /** @private */
         this._requestTimeout = DEFAULT_REQUEST_TIMEOUT;
 
@@ -480,6 +492,32 @@ export default class Client {
         return this;
     }
 
+    /**
+     * @returns {boolean}
+     */
+    get allowReceiptNodeFailover() {
+        return this._allowReceiptNodeFailover;
+    }
+
+    /**
+     * Enable or disable receipt query failover to other nodes when the submitting node
+     * is unresponsive. When enabled, receipt queries will start with the submitting node
+     * but can fail over to other nodes in the network if needed.
+     *
+     * Default is `false` to preserve existing behavior where receipt queries are pinned
+     * to the submitting node only.
+     *
+     * **Tradeoff**: Enabling this improves availability for high-throughput/relay use cases,
+     * but in rare cases only the submitting node may have the final failure information.
+     *
+     * @param {boolean} allowReceiptNodeFailover
+     * @returns {this}
+     */
+    setAllowReceiptNodeFailover(allowReceiptNodeFailover) {
+        this._allowReceiptNodeFailover = allowReceiptNodeFailover;
+        return this;
+    }
+
     /**
      * @returns {Hbar}
      */