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

package/src/contract/ContractUpdateTransaction.js

@@ -54,6 +54,8 @@ export default class ContractUpdateTransaction extends Transaction {
      * @param {Long | number} [props.stakedNodeId]
      * @param {boolean} [props.declineStakingReward]
      * @param {AccountId} [props.autoRenewAccountId]
+     * @param {import("../hooks/HookCreationDetails.js").default[]} [props.hooksToBeCreated]
+     * @param {Long[]} [props.hooksToBeDeleted]
      */
     constructor(props = {}) {
         super();
@@ -129,6 +131,18 @@ export default class ContractUpdateTransaction extends Transaction {
          */
         this._autoRenewAccountId = null;
 
+        /**
+         * @private
+         * @type {import("../hooks/HookCreationDetails.js").default[]}
+         */
+        this._hooksToBeCreated = [];
+
+        /**
+         * @private
+         * @type {Long[]}
+         */
+        this._hooksToBeDeleted = [];
+
         if (props.contractId != null) {
             this.setContractId(props.contractId);
         }
@@ -179,6 +193,14 @@ export default class ContractUpdateTransaction extends Transaction {
         if (props.autoRenewAccountId != null) {
             this.setAutoRenewAccountId(props.autoRenewAccountId);
         }
+
+        if (props.hooksToBeCreated != null) {
+            this.setHooksToCreate(props.hooksToBeCreated);
+        }
+
+        if (props.hooksToBeDeleted != null) {
+            this.setHooksToDelete(props.hooksToBeDeleted);
+        }
     }
 
     /**
@@ -572,6 +594,57 @@ export default class ContractUpdateTransaction extends Transaction {
         }
     }
 
+    /**
+     * @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;
+    }
+
     /**
      * @override
      * @internal
@@ -647,6 +720,13 @@ export default class ContractUpdateTransaction extends Transaction {
                         ? Proto.proto.AccountID.create()
                         : this._autoRenewAccountId._toProtobuf()
                     : null,
+
+            hookIdsToDelete:
+                this._hooksToBeDeleted != null ? this._hooksToBeDeleted : null,
+            hookCreationDetails:
+                this._hooksToBeCreated != null
+                    ? this._hooksToBeCreated.map((hook) => hook._toProtobuf())
+                    : null,
         };
     }
 

package/src/exports.js

@@ -73,6 +73,23 @@ export { default as FeeDataType } from "./FeeDataType.js";
 export { default as FeeSchedule } from "./FeeSchedule.js";
 export { default as FeeSchedules } from "./FeeSchedules.js";
 export { default as FileAppendTransaction } from "./file/FileAppendTransaction.js";
+export { default as HookCreationDetails } from "./hooks/HookCreationDetails.js";
+export { default as EvmHook } from "./hooks/EvmHook.js";
+export { HookExtensionPoint } from "./hooks/HookExtensionPoint.js";
+export { default as FungibleHookCall } from "./hooks/FungibleHookCall.js";
+export { default as NftHookCall } from "./hooks/NftHookCall.js";
+export { default as EvmHookCall } from "./hooks/EvmHookCall.js";
+export { default as FungibleHookType } from "./hooks/FungibleHookType.js";
+export { default as NftHookType } from "./hooks/NftHookType.js";
+export { default as HookId } from "./hooks/HookId.js";
+export { default as HookEntityId } from "./hooks/HookEntityId.js";
+export { default as HookStoreTransaction } from "./hooks/HookStoreTransaction.js";
+export {
+    EvmHookStorageUpdate,
+    EvmHookStorageSlot,
+    EvmHookMappingEntries,
+} from "./hooks/EvmHookStorageUpdate.js";
+export { default as EvmHookMappingEntry } from "./hooks/EvmHookMappingEntry.js";
 export { default as FileContentsQuery } from "./file/FileContentsQuery.js";
 export { default as FileCreateTransaction } from "./file/FileCreateTransaction.js";
 export { default as FileDeleteTransaction } from "./file/FileDeleteTransaction.js";

package/src/hooks/EvmHook.js

@@ -0,0 +1,83 @@
+/**
+ * Definition of an EVM hook extending shared specifications for an EVM hook.
+ */
+class EvmHook {
+    /**
+     *
+     * @param {object} [props]
+     * @param {import("./../contract/ContractId").default} [props.contractId]
+     * @param {import("./EvmHookStorageUpdate.js").EvmHookStorageUpdate[]} [props.storageUpdates]
+     */
+    constructor(props = {}) {
+        /**
+         * @private
+         * @type {?import("./../contract/ContractId.js").default}
+         */
+        this._contractId = null;
+
+        /**
+         * @private
+         * @type {import("./EvmHookStorageUpdate.js").EvmHookStorageUpdate[]}
+         */
+        this._storageUpdates = [];
+
+        if (props.storageUpdates != null) {
+            this.setStorageUpdates(props.storageUpdates);
+        }
+
+        if (props.contractId != null) {
+            this.setContractId(props.contractId);
+        }
+    }
+
+    /**
+     * @param {import("./../contract/ContractId.js").default} contractId
+     * @returns {this}
+     */
+    setContractId(contractId) {
+        this._contractId = contractId;
+        return this;
+    }
+
+    /**
+     * @param {import("./EvmHookStorageUpdate.js").EvmHookStorageUpdate[]} storageUpdates
+     * @returns {this}
+     */
+    setStorageUpdates(storageUpdates) {
+        this._storageUpdates = storageUpdates;
+        return this;
+    }
+
+    /**
+     *
+     * @returns {import("./EvmHookStorageUpdate.js").EvmHookStorageUpdate[]}
+     */
+    get storageUpdates() {
+        return this._storageUpdates;
+    }
+
+    /**
+     *
+     * @returns {import("./../contract/ContractId.js").default | null}
+     */
+    get contractId() {
+        return this._contractId;
+    }
+
+    /**
+     *
+     * @returns {import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.IEvmHook}
+     */
+    _toProtobuf() {
+        return {
+            spec: {
+                contractId: this._contractId?._toProtobuf(),
+            },
+            storageUpdates: this._storageUpdates.map((update) =>
+                update._toProtobuf(),
+            ),
+        };
+    }
+}
+
+export default EvmHook;

package/src/hooks/EvmHookCall.js

@@ -0,0 +1,100 @@
+import Long from "long";
+
+/**
+ * @namespace proto
+ * @typedef {import("@hiero-ledger/proto").proto.IEvmHookCall} HieroProto.proto.IEvmHookCall
+ */
+
+/**
+ * Specifies details of a call to an EVM hook.
+ */
+class EvmHookCall {
+    /**
+     *
+     * @param {object} props
+     * @param {Uint8Array} [props.data]
+     * @param {Long} [props.gasLimit]
+     */
+    constructor(props = {}) {
+        /**
+         * @private
+         * @type {?Uint8Array}
+         */
+        this._data = null;
+
+        /**
+         * @private
+         * @type {?Long}
+         */
+        this._gasLimit = null;
+
+        if (props.data != null) {
+            this.setData(props.data);
+        }
+
+        if (props.gasLimit != null) {
+            this.setGasLimit(props.gasLimit);
+        }
+    }
+
+    /**
+     *
+     * @param {Uint8Array} data
+     * @returns {this}
+     */
+    setData(data) {
+        this._data = data;
+        return this;
+    }
+
+    /**
+     *
+     * @param {Long} gasLimit
+     * @returns {this}
+     */
+    setGasLimit(gasLimit) {
+        this._gasLimit = gasLimit;
+        return this;
+    }
+
+    /**
+     *
+     * @returns {Uint8Array | null}
+     */
+    get data() {
+        return this._data;
+    }
+
+    /**
+     *
+     * @returns {Long | null}
+     */
+    get gasLimit() {
+        return this._gasLimit;
+    }
+
+    /**
+     *
+     * @param {HieroProto.proto.IEvmHookCall} evmHookCall
+     * @returns {EvmHookCall}
+     */
+    static _fromProtobuf(evmHookCall) {
+        return new EvmHookCall({
+            data: evmHookCall.data ? evmHookCall.data : undefined,
+            gasLimit: evmHookCall.gasLimit ? evmHookCall.gasLimit : undefined,
+        });
+    }
+
+    /**
+     *
+     * @returns {import("@hiero-ledger/proto").proto.IEvmHookCall}
+     */
+    _toProtobuf() {
+        return {
+            data: this._data,
+            gasLimit: this._gasLimit ? this._gasLimit : null,
+        };
+    }
+}
+
+export default EvmHookCall;

package/src/hooks/EvmHookMappingEntry.js

@@ -0,0 +1,140 @@
+/**
+ * An entry in a Solidity mapping. Very helpful for protocols that apply
+ * `HookStore` to manage the entries of a hook contract's mapping instead
+ * its raw storage slots.
+ * <p>
+ * This is especially attractive when the mapping value itself fits in a single
+ * word; for more complicated value storage layouts it becomes necessary to
+ * combine the mapping update with additional `EvmHookStorageSlot` updates that
+ * specify the complete storage slots of the value type.
+ */
+class EvmHookMappingEntry {
+    /**
+     *
+     * @param {object} props
+     * @param {Uint8Array} [props.key]
+     * @param {Uint8Array} [props.value]
+     * @param {Uint8Array} [props.preimage]
+     */
+    constructor(props = {}) {
+        /**
+         * @private
+         * @type {?Uint8Array}
+         */
+        this._key = null;
+
+        /**
+         * @private
+         * @type {?Uint8Array}
+         */
+        this._value = null;
+
+        /**
+         * @private
+         * @type {?Uint8Array}
+         */
+        this._preimage = null;
+
+        if (props.preimage != null) {
+            this.setPreimage(props.preimage);
+        }
+
+        if (props.key != null) {
+            this.setKey(props.key);
+        }
+
+        if (props.value != null) {
+            this.setValue(props.value);
+        }
+    }
+
+    /**
+     *
+     * @param {Uint8Array} key
+     * @returns {this}
+     */
+    setKey(key) {
+        this._key = key;
+        this._preimage = null;
+        return this;
+    }
+
+    /**
+     *
+     * @param {Uint8Array} value
+     * @returns {this}
+     */
+    setValue(value) {
+        this._value = value;
+        return this;
+    }
+
+    /**
+     *
+     * @param {Uint8Array} preimage
+     * @returns {this}
+     */
+    setPreimage(preimage) {
+        this._preimage = preimage;
+        this._key = null;
+        return this;
+    }
+
+    /**
+     *
+     * @returns {Uint8Array | null}
+     */
+    get key() {
+        return this._key;
+    }
+
+    /**
+     *
+     * @returns {Uint8Array | null}
+     */
+    get value() {
+        return this._value;
+    }
+
+    /**
+     *
+     * @returns {Uint8Array | null}
+     */
+    get preimage() {
+        return this._preimage;
+    }
+
+    /**
+     *
+     * @param {import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.IEvmHookMappingEntry} hookMappingEntry
+     * @returns {EvmHookMappingEntry}
+     */
+    static _fromProtobuf(hookMappingEntry) {
+        return new EvmHookMappingEntry({
+            key:
+                hookMappingEntry.key != null ? hookMappingEntry.key : undefined,
+            value:
+                hookMappingEntry.value != null
+                    ? hookMappingEntry.value
+                    : undefined,
+            preimage:
+                hookMappingEntry.preimage != null
+                    ? hookMappingEntry.preimage
+                    : undefined,
+        });
+    }
+
+    /**
+     *
+     * @returns {import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.IEvmHookMappingEntry}
+     */
+    _toProtobuf() {
+        return {
+            key: this._key,
+            value: this._value,
+            preimage: this._preimage,
+        };
+    }
+}
+
+export default EvmHookMappingEntry;

package/src/hooks/EvmHookStorageUpdate.js

@@ -0,0 +1,257 @@
+import EvmHookMappingEntry from "./EvmHookMappingEntry.js";
+
+/**
+ *
+ * @abstract
+ * Specifies a key/value pair in the storage of a EVM hook, either by the explicit storage
+ * slot contents; or by a combination of a Solidity mapping's slot key and the key into
+ * that mapping.
+ */
+class EvmHookStorageUpdate {
+    /**
+     *
+     * @param {import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.IEvmHookStorageUpdate} hookStorageUpdate
+     * @returns {EvmHookStorageUpdate}
+     */
+    static _fromProtobuf(hookStorageUpdate) {
+        if (hookStorageUpdate.storageSlot != null) {
+            return EvmHookStorageSlot._fromProtobuf(hookStorageUpdate);
+        }
+
+        if (hookStorageUpdate.mappingEntries != null) {
+            return EvmHookMappingEntries._fromProtobuf(hookStorageUpdate);
+        }
+
+        throw new Error(
+            "EvmHookStorageUpdate must have either storage_slot or mapping_entries set",
+        );
+    }
+
+    /**
+     * @abstract
+     * @returns {import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.IEvmHookStorageUpdate}
+     */
+    _toProtobuf() {
+        throw new Error(
+            "EvmHookStorageUpdate._toProtobuf must be implemented by a subclass",
+        );
+    }
+}
+
+/**
+ * A slot in the storage of a EVM hook.
+ */
+class EvmHookStorageSlot extends EvmHookStorageUpdate {
+    /**
+     * @param {object} props
+     * @param {Uint8Array} [props.key]
+     * @param {Uint8Array} [props.value]
+     */
+    constructor(props = {}) {
+        super();
+        /**
+         * @private
+         * @type {?Uint8Array}
+         */
+        this._key = null;
+
+        /**
+         * @private
+         * @type {?Uint8Array}
+         */
+        this._value = null;
+
+        if (props.key != null) {
+            this.setKey(props.key);
+        }
+
+        if (props.value != null) {
+            this.setValue(props.value);
+        }
+    }
+
+    /**
+     *
+     * @param {Uint8Array} key
+     * @returns {this}
+     */
+    setKey(key) {
+        this._key = key;
+        return this;
+    }
+
+    /**
+     *
+     * @param {Uint8Array} value
+     * @returns {this}
+     */
+    setValue(value) {
+        this._value = value;
+        return this;
+    }
+
+    /**
+     *
+     * @returns {Uint8Array | null}
+     */
+    get key() {
+        return this._key;
+    }
+
+    /**
+     *
+     * @returns {Uint8Array | null}
+     */
+    get value() {
+        return this._value;
+    }
+
+    /**
+     *
+     * @param {import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.IEvmHookStorageUpdate} hookStorageSlot
+     * @returns {EvmHookStorageSlot}
+     */
+    static _fromProtobuf(hookStorageSlot) {
+        if (hookStorageSlot.storageSlot != null) {
+            return new EvmHookStorageSlot({
+                key:
+                    hookStorageSlot.storageSlot.key != null
+                        ? hookStorageSlot.storageSlot.key
+                        : undefined,
+                value:
+                    hookStorageSlot.storageSlot.value != null
+                        ? hookStorageSlot.storageSlot.value
+                        : undefined,
+            });
+        }
+        throw new Error(
+            "EvmHookStorageSlot._fromProtobuf must be implemented by a subclass",
+        );
+    }
+
+    /**
+     * @returns {import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.EvmHookStorageUpdate}
+     */
+    _toProtobuf() {
+        return {
+            storageSlot: {
+                key: this._key,
+                value: this._value,
+            },
+        };
+    }
+}
+
+/**
+ * Specifies storage slot updates via indirection into a Solidity mapping.
+ * <p>
+ * Concretely, if the Solidity mapping is itself at slot `mapping_slot`, then
+ * the * storage slot for key `key` in the mapping is defined by the relationship
+ * `key_storage_slot = keccak256(abi.encodePacked(mapping_slot, key))`.
+ * <p>
+ * This message lets a metaprotocol be specified in terms of changes to a
+ * Solidity mapping's entries. If only raw slots could be updated, then a block
+ * stream consumer following the metaprotocol would have to invert the Keccak256
+ * hash to determine which mapping entry was being updated, which is not possible.
+ */
+class EvmHookMappingEntries extends EvmHookStorageUpdate {
+    /**
+     *
+     * @param {object} props
+     * @param {Uint8Array} [props.mappingSlot]
+     * @param {import("./EvmHookMappingEntry.js").default[]} [props.entries]
+     */
+    constructor(props = {}) {
+        super();
+        /**
+         * @private
+         * @type {?Uint8Array}
+         */
+        this._mappingSlot = null;
+
+        /**
+         * @private
+         * @type {?import("./EvmHookMappingEntry.js").default[]}
+         */
+        this._entries = null;
+
+        if (props.mappingSlot != null) {
+            this.setMappingSlot(props.mappingSlot);
+        }
+
+        if (props.entries != null) {
+            this.setEntries(props.entries);
+        }
+    }
+
+    /**
+     *
+     * @param {Uint8Array} mappingSlot
+     * @returns {this}
+     */
+    setMappingSlot(mappingSlot) {
+        this._mappingSlot = mappingSlot;
+        return this;
+    }
+
+    /**
+     *
+     * @param {import("./EvmHookMappingEntry.js").default[]} entries
+     * @returns {this}
+     */
+    setEntries(entries) {
+        this._entries = entries;
+        return this;
+    }
+
+    /**
+     *
+     * @returns {Uint8Array | null}
+     */
+    get mappingSlot() {
+        return this._mappingSlot;
+    }
+
+    /**
+     *
+     * @returns {import("./EvmHookMappingEntry.js").default[] | null}
+     */
+    get entries() {
+        return this._entries;
+    }
+
+    /**
+     *
+     * @param {import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.IEvmHookStorageUpdate} hookStorageUpdate
+     * @returns {EvmHookMappingEntries}
+     */
+    static _fromProtobuf(hookStorageUpdate) {
+        return new EvmHookMappingEntries({
+            mappingSlot:
+                hookStorageUpdate.mappingEntries?.mappingSlot != null
+                    ? hookStorageUpdate.mappingEntries.mappingSlot
+                    : undefined,
+            entries: hookStorageUpdate.mappingEntries?.entries?.map((entry) =>
+                EvmHookMappingEntry._fromProtobuf(entry),
+            ),
+        });
+    }
+
+    /**
+     *
+     * @returns {import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.EvmHookStorageUpdate}
+     */
+    _toProtobuf() {
+        return {
+            mappingEntries: {
+                mappingSlot: this._mappingSlot,
+                entries:
+                    this._entries != null
+                        ? this._entries.map((entry) => entry._toProtobuf())
+                        : null,
+            },
+        };
+    }
+}
+
+export { EvmHookStorageUpdate, EvmHookStorageSlot, EvmHookMappingEntries };