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

package/lib/hooks/EvmHookMappingEntry.d.ts

@@ -0,0 +1,84 @@
+export default EvmHookMappingEntry;
+/**
+ * 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.
+ */
+declare class EvmHookMappingEntry {
+    /**
+     *
+     * @param {import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.IEvmHookMappingEntry} hookMappingEntry
+     * @returns {EvmHookMappingEntry}
+     */
+    static _fromProtobuf(hookMappingEntry: import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.IEvmHookMappingEntry): EvmHookMappingEntry;
+    /**
+     *
+     * @param {object} props
+     * @param {Uint8Array} [props.key]
+     * @param {Uint8Array} [props.value]
+     * @param {Uint8Array} [props.preimage]
+     */
+    constructor(props?: {
+        key?: Uint8Array<ArrayBufferLike> | undefined;
+        value?: Uint8Array<ArrayBufferLike> | undefined;
+        preimage?: Uint8Array<ArrayBufferLike> | undefined;
+    });
+    /**
+     * @private
+     * @type {?Uint8Array}
+     */
+    private _key;
+    /**
+     * @private
+     * @type {?Uint8Array}
+     */
+    private _value;
+    /**
+     * @private
+     * @type {?Uint8Array}
+     */
+    private _preimage;
+    /**
+     *
+     * @param {Uint8Array} key
+     * @returns {this}
+     */
+    setKey(key: Uint8Array): this;
+    /**
+     *
+     * @param {Uint8Array} value
+     * @returns {this}
+     */
+    setValue(value: Uint8Array): this;
+    /**
+     *
+     * @param {Uint8Array} preimage
+     * @returns {this}
+     */
+    setPreimage(preimage: Uint8Array): this;
+    /**
+     *
+     * @returns {Uint8Array | null}
+     */
+    get key(): Uint8Array | null;
+    /**
+     *
+     * @returns {Uint8Array | null}
+     */
+    get value(): Uint8Array | null;
+    /**
+     *
+     * @returns {Uint8Array | null}
+     */
+    get preimage(): Uint8Array | null;
+    /**
+     *
+     * @returns {import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.IEvmHookMappingEntry}
+     */
+    _toProtobuf(): import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.IEvmHookMappingEntry;
+}

package/lib/hooks/EvmHookMappingEntry.js

@@ -0,0 +1,2 @@
+class e{constructor(e={}){this._key=null,this._value=null,this._preimage=null,null!=e.preimage&&this.setPreimage(e.preimage),null!=e.key&&this.setKey(e.key),null!=e.value&&this.setValue(e.value)}setKey(e){return this._key=e,this._preimage=null,this}setValue(e){return this._value=e,this}setPreimage(e){return this._preimage=e,this._key=null,this}get key(){return this._key}get value(){return this._value}get preimage(){return this._preimage}static _fromProtobuf(t){return new e({key:null!=t.key?t.key:void 0,value:null!=t.value?t.value:void 0,preimage:null!=t.preimage?t.preimage:void 0})}_toProtobuf(){return{key:this._key,value:this._value,preimage:this._preimage}}}export{e as default};
+//# sourceMappingURL=EvmHookMappingEntry.js.map

package/lib/hooks/EvmHookMappingEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EvmHookMappingEntry.js","sources":["../../src/hooks/EvmHookMappingEntry.js"],"sourcesContent":["/**\n * An entry in a Solidity mapping. Very helpful for protocols that apply\n * `HookStore` to manage the entries of a hook contract's mapping instead\n * its raw storage slots.\n * <p>\n * This is especially attractive when the mapping value itself fits in a single\n * word; for more complicated value storage layouts it becomes necessary to\n * combine the mapping update with additional `EvmHookStorageSlot` updates that\n * specify the complete storage slots of the value type.\n */\nclass EvmHookMappingEntry {\n    /**\n     *\n     * @param {object} props\n     * @param {Uint8Array} [props.key]\n     * @param {Uint8Array} [props.value]\n     * @param {Uint8Array} [props.preimage]\n     */\n    constructor(props = {}) {\n        /**\n         * @private\n         * @type {?Uint8Array}\n         */\n        this._key = null;\n\n        /**\n         * @private\n         * @type {?Uint8Array}\n         */\n        this._value = null;\n\n        /**\n         * @private\n         * @type {?Uint8Array}\n         */\n        this._preimage = null;\n\n        if (props.preimage != null) {\n            this.setPreimage(props.preimage);\n        }\n\n        if (props.key != null) {\n            this.setKey(props.key);\n        }\n\n        if (props.value != null) {\n            this.setValue(props.value);\n        }\n    }\n\n    /**\n     *\n     * @param {Uint8Array} key\n     * @returns {this}\n     */\n    setKey(key) {\n        this._key = key;\n        this._preimage = null;\n        return this;\n    }\n\n    /**\n     *\n     * @param {Uint8Array} value\n     * @returns {this}\n     */\n    setValue(value) {\n        this._value = value;\n        return this;\n    }\n\n    /**\n     *\n     * @param {Uint8Array} preimage\n     * @returns {this}\n     */\n    setPreimage(preimage) {\n        this._preimage = preimage;\n        this._key = null;\n        return this;\n    }\n\n    /**\n     *\n     * @returns {Uint8Array | null}\n     */\n    get key() {\n        return this._key;\n    }\n\n    /**\n     *\n     * @returns {Uint8Array | null}\n     */\n    get value() {\n        return this._value;\n    }\n\n    /**\n     *\n     * @returns {Uint8Array | null}\n     */\n    get preimage() {\n        return this._preimage;\n    }\n\n    /**\n     *\n     * @param {import(\"@hiero-ledger/proto\").com.hedera.hapi.node.hooks.IEvmHookMappingEntry} hookMappingEntry\n     * @returns {EvmHookMappingEntry}\n     */\n    static _fromProtobuf(hookMappingEntry) {\n        return new EvmHookMappingEntry({\n            key:\n                hookMappingEntry.key != null ? hookMappingEntry.key : undefined,\n            value:\n                hookMappingEntry.value != null\n                    ? hookMappingEntry.value\n                    : undefined,\n            preimage:\n                hookMappingEntry.preimage != null\n                    ? hookMappingEntry.preimage\n                    : undefined,\n        });\n    }\n\n    /**\n     *\n     * @returns {import(\"@hiero-ledger/proto\").com.hedera.hapi.node.hooks.IEvmHookMappingEntry}\n     */\n    _toProtobuf() {\n        return {\n            key: this._key,\n            value: this._value,\n            preimage: this._preimage,\n        };\n    }\n}\n\nexport default EvmHookMappingEntry;\n"],"names":["EvmHookMappingEntry","constructor","props","this","_key","_value","_preimage","preimage","setPreimage","key","setKey","value","setValue","_fromProtobuf","hookMappingEntry","undefined","_toProtobuf"],"mappings":"AAUA,MAAMA,EAQF,WAAAC,CAAYC,EAAQ,IAKhBC,KAAKC,KAAO,KAMZD,KAAKE,OAAS,KAMdF,KAAKG,UAAY,KAEK,MAAlBJ,EAAMK,UACNJ,KAAKK,YAAYN,EAAMK,UAGV,MAAbL,EAAMO,KACNN,KAAKO,OAAOR,EAAMO,KAGH,MAAfP,EAAMS,OACNR,KAAKS,SAASV,EAAMS,MAEhC,CAOI,MAAAD,CAAOD,GAGH,OAFAN,KAAKC,KAAOK,EACZN,KAAKG,UAAY,KACVH,IACf,CAOI,QAAAS,CAASD,GAEL,OADAR,KAAKE,OAASM,EACPR,IACf,CAOI,WAAAK,CAAYD,GAGR,OAFAJ,KAAKG,UAAYC,EACjBJ,KAAKC,KAAO,KACLD,IACf,CAMI,OAAIM,GACA,OAAON,KAAKC,IACpB,CAMI,SAAIO,GACA,OAAOR,KAAKE,MACpB,CAMI,YAAIE,GACA,OAAOJ,KAAKG,SACpB,CAOI,oBAAOO,CAAcC,GACjB,OAAO,IAAId,EAAoB,CAC3BS,IAC4B,MAAxBK,EAAiBL,IAAcK,EAAiBL,SAAMM,EAC1DJ,MAC8B,MAA1BG,EAAiBH,MACXG,EAAiBH,WACjBI,EACVR,SACiC,MAA7BO,EAAiBP,SACXO,EAAiBP,cACjBQ,GAEtB,CAMI,WAAAC,GACI,MAAO,CACHP,IAAKN,KAAKC,KACVO,MAAOR,KAAKE,OACZE,SAAUJ,KAAKG,UAE3B"}

package/lib/hooks/EvmHookStorageUpdate.cjs

@@ -0,0 +1,238 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EvmHookStorageUpdate = exports.EvmHookStorageSlot = exports.EvmHookMappingEntries = void 0;
+var _EvmHookMappingEntry = _interopRequireDefault(require("./EvmHookMappingEntry.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ *
+ * @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.
+ */
+exports.EvmHookStorageUpdate = EvmHookStorageUpdate;
+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.
+ */
+exports.EvmHookStorageSlot = EvmHookStorageSlot;
+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.default._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
+      }
+    };
+  }
+}
+exports.EvmHookMappingEntries = EvmHookMappingEntries;

package/lib/hooks/EvmHookStorageUpdate.d.ts

@@ -0,0 +1,144 @@
+/**
+ *
+ * @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.
+ */
+export class EvmHookStorageUpdate {
+    /**
+     *
+     * @param {import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.IEvmHookStorageUpdate} hookStorageUpdate
+     * @returns {EvmHookStorageUpdate}
+     */
+    static _fromProtobuf(hookStorageUpdate: import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.IEvmHookStorageUpdate): EvmHookStorageUpdate;
+    /**
+     * @abstract
+     * @returns {import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.IEvmHookStorageUpdate}
+     */
+    _toProtobuf(): import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.IEvmHookStorageUpdate;
+}
+/**
+ * A slot in the storage of a EVM hook.
+ */
+export class EvmHookStorageSlot extends EvmHookStorageUpdate {
+    /**
+     *
+     * @param {import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.IEvmHookStorageUpdate} hookStorageSlot
+     * @returns {EvmHookStorageSlot}
+     */
+    static _fromProtobuf(hookStorageSlot: import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.IEvmHookStorageUpdate): EvmHookStorageSlot;
+    /**
+     * @param {object} props
+     * @param {Uint8Array} [props.key]
+     * @param {Uint8Array} [props.value]
+     */
+    constructor(props?: {
+        key?: Uint8Array<ArrayBufferLike> | undefined;
+        value?: Uint8Array<ArrayBufferLike> | undefined;
+    });
+    /**
+     * @private
+     * @type {?Uint8Array}
+     */
+    private _key;
+    /**
+     * @private
+     * @type {?Uint8Array}
+     */
+    private _value;
+    /**
+     *
+     * @param {Uint8Array} key
+     * @returns {this}
+     */
+    setKey(key: Uint8Array): this;
+    /**
+     *
+     * @param {Uint8Array} value
+     * @returns {this}
+     */
+    setValue(value: Uint8Array): this;
+    /**
+     *
+     * @returns {Uint8Array | null}
+     */
+    get key(): Uint8Array | null;
+    /**
+     *
+     * @returns {Uint8Array | null}
+     */
+    get value(): Uint8Array | null;
+    /**
+     * @returns {import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.EvmHookStorageUpdate}
+     */
+    _toProtobuf(): import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.EvmHookStorageUpdate;
+}
+/**
+ * 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.
+ */
+export class EvmHookMappingEntries extends EvmHookStorageUpdate {
+    /**
+     *
+     * @param {import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.IEvmHookStorageUpdate} hookStorageUpdate
+     * @returns {EvmHookMappingEntries}
+     */
+    static _fromProtobuf(hookStorageUpdate: import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.IEvmHookStorageUpdate): EvmHookMappingEntries;
+    /**
+     *
+     * @param {object} props
+     * @param {Uint8Array} [props.mappingSlot]
+     * @param {import("./EvmHookMappingEntry.js").default[]} [props.entries]
+     */
+    constructor(props?: {
+        mappingSlot?: Uint8Array<ArrayBufferLike> | undefined;
+        entries?: EvmHookMappingEntry[] | undefined;
+    });
+    /**
+     * @private
+     * @type {?Uint8Array}
+     */
+    private _mappingSlot;
+    /**
+     * @private
+     * @type {?import("./EvmHookMappingEntry.js").default[]}
+     */
+    private _entries;
+    /**
+     *
+     * @param {Uint8Array} mappingSlot
+     * @returns {this}
+     */
+    setMappingSlot(mappingSlot: Uint8Array): this;
+    /**
+     *
+     * @param {import("./EvmHookMappingEntry.js").default[]} entries
+     * @returns {this}
+     */
+    setEntries(entries: import("./EvmHookMappingEntry.js").default[]): this;
+    /**
+     *
+     * @returns {Uint8Array | null}
+     */
+    get mappingSlot(): Uint8Array | null;
+    /**
+     *
+     * @returns {import("./EvmHookMappingEntry.js").default[] | null}
+     */
+    get entries(): import("./EvmHookMappingEntry.js").default[] | null;
+    /**
+     *
+     * @returns {import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.EvmHookStorageUpdate}
+     */
+    _toProtobuf(): import("@hiero-ledger/proto").com.hedera.hapi.node.hooks.EvmHookStorageUpdate;
+}
+import EvmHookMappingEntry from "./EvmHookMappingEntry.js";

package/lib/hooks/EvmHookStorageUpdate.js

@@ -0,0 +1,2 @@
+import t from"./EvmHookMappingEntry.js";class e{static _fromProtobuf(t){if(null!=t.storageSlot)return r._fromProtobuf(t);if(null!=t.mappingEntries)return o._fromProtobuf(t);throw new Error("EvmHookStorageUpdate must have either storage_slot or mapping_entries set")}_toProtobuf(){throw new Error("EvmHookStorageUpdate._toProtobuf must be implemented by a subclass")}}class r extends e{constructor(t={}){super(),this._key=null,this._value=null,null!=t.key&&this.setKey(t.key),null!=t.value&&this.setValue(t.value)}setKey(t){return this._key=t,this}setValue(t){return this._value=t,this}get key(){return this._key}get value(){return this._value}static _fromProtobuf(t){if(null!=t.storageSlot)return new r({key:null!=t.storageSlot.key?t.storageSlot.key:void 0,value:null!=t.storageSlot.value?t.storageSlot.value:void 0});throw new Error("EvmHookStorageSlot._fromProtobuf must be implemented by a subclass")}_toProtobuf(){return{storageSlot:{key:this._key,value:this._value}}}}class o extends e{constructor(t={}){super(),this._mappingSlot=null,this._entries=null,null!=t.mappingSlot&&this.setMappingSlot(t.mappingSlot),null!=t.entries&&this.setEntries(t.entries)}setMappingSlot(t){return this._mappingSlot=t,this}setEntries(t){return this._entries=t,this}get mappingSlot(){return this._mappingSlot}get entries(){return this._entries}static _fromProtobuf(e){return new o({mappingSlot:null!=e.mappingEntries?.mappingSlot?e.mappingEntries.mappingSlot:void 0,entries:e.mappingEntries?.entries?.map(e=>t._fromProtobuf(e))})}_toProtobuf(){return{mappingEntries:{mappingSlot:this._mappingSlot,entries:null!=this._entries?this._entries.map(t=>t._toProtobuf()):null}}}}export{o as EvmHookMappingEntries,r as EvmHookStorageSlot,e as EvmHookStorageUpdate};
+//# sourceMappingURL=EvmHookStorageUpdate.js.map

package/lib/hooks/EvmHookStorageUpdate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EvmHookStorageUpdate.js","sources":["../../src/hooks/EvmHookStorageUpdate.js"],"sourcesContent":["import EvmHookMappingEntry from \"./EvmHookMappingEntry.js\";\n\n/**\n *\n * @abstract\n * Specifies a key/value pair in the storage of a EVM hook, either by the explicit storage\n * slot contents; or by a combination of a Solidity mapping's slot key and the key into\n * that mapping.\n */\nclass EvmHookStorageUpdate {\n    /**\n     *\n     * @param {import(\"@hiero-ledger/proto\").com.hedera.hapi.node.hooks.IEvmHookStorageUpdate} hookStorageUpdate\n     * @returns {EvmHookStorageUpdate}\n     */\n    static _fromProtobuf(hookStorageUpdate) {\n        if (hookStorageUpdate.storageSlot != null) {\n            return EvmHookStorageSlot._fromProtobuf(hookStorageUpdate);\n        }\n\n        if (hookStorageUpdate.mappingEntries != null) {\n            return EvmHookMappingEntries._fromProtobuf(hookStorageUpdate);\n        }\n\n        throw new Error(\n            \"EvmHookStorageUpdate must have either storage_slot or mapping_entries set\",\n        );\n    }\n\n    /**\n     * @abstract\n     * @returns {import(\"@hiero-ledger/proto\").com.hedera.hapi.node.hooks.IEvmHookStorageUpdate}\n     */\n    _toProtobuf() {\n        throw new Error(\n            \"EvmHookStorageUpdate._toProtobuf must be implemented by a subclass\",\n        );\n    }\n}\n\n/**\n * A slot in the storage of a EVM hook.\n */\nclass EvmHookStorageSlot extends EvmHookStorageUpdate {\n    /**\n     * @param {object} props\n     * @param {Uint8Array} [props.key]\n     * @param {Uint8Array} [props.value]\n     */\n    constructor(props = {}) {\n        super();\n        /**\n         * @private\n         * @type {?Uint8Array}\n         */\n        this._key = null;\n\n        /**\n         * @private\n         * @type {?Uint8Array}\n         */\n        this._value = null;\n\n        if (props.key != null) {\n            this.setKey(props.key);\n        }\n\n        if (props.value != null) {\n            this.setValue(props.value);\n        }\n    }\n\n    /**\n     *\n     * @param {Uint8Array} key\n     * @returns {this}\n     */\n    setKey(key) {\n        this._key = key;\n        return this;\n    }\n\n    /**\n     *\n     * @param {Uint8Array} value\n     * @returns {this}\n     */\n    setValue(value) {\n        this._value = value;\n        return this;\n    }\n\n    /**\n     *\n     * @returns {Uint8Array | null}\n     */\n    get key() {\n        return this._key;\n    }\n\n    /**\n     *\n     * @returns {Uint8Array | null}\n     */\n    get value() {\n        return this._value;\n    }\n\n    /**\n     *\n     * @param {import(\"@hiero-ledger/proto\").com.hedera.hapi.node.hooks.IEvmHookStorageUpdate} hookStorageSlot\n     * @returns {EvmHookStorageSlot}\n     */\n    static _fromProtobuf(hookStorageSlot) {\n        if (hookStorageSlot.storageSlot != null) {\n            return new EvmHookStorageSlot({\n                key:\n                    hookStorageSlot.storageSlot.key != null\n                        ? hookStorageSlot.storageSlot.key\n                        : undefined,\n                value:\n                    hookStorageSlot.storageSlot.value != null\n                        ? hookStorageSlot.storageSlot.value\n                        : undefined,\n            });\n        }\n        throw new Error(\n            \"EvmHookStorageSlot._fromProtobuf must be implemented by a subclass\",\n        );\n    }\n\n    /**\n     * @returns {import(\"@hiero-ledger/proto\").com.hedera.hapi.node.hooks.EvmHookStorageUpdate}\n     */\n    _toProtobuf() {\n        return {\n            storageSlot: {\n                key: this._key,\n                value: this._value,\n            },\n        };\n    }\n}\n\n/**\n * Specifies storage slot updates via indirection into a Solidity mapping.\n * <p>\n * Concretely, if the Solidity mapping is itself at slot `mapping_slot`, then\n * the * storage slot for key `key` in the mapping is defined by the relationship\n * `key_storage_slot = keccak256(abi.encodePacked(mapping_slot, key))`.\n * <p>\n * This message lets a metaprotocol be specified in terms of changes to a\n * Solidity mapping's entries. If only raw slots could be updated, then a block\n * stream consumer following the metaprotocol would have to invert the Keccak256\n * hash to determine which mapping entry was being updated, which is not possible.\n */\nclass EvmHookMappingEntries extends EvmHookStorageUpdate {\n    /**\n     *\n     * @param {object} props\n     * @param {Uint8Array} [props.mappingSlot]\n     * @param {import(\"./EvmHookMappingEntry.js\").default[]} [props.entries]\n     */\n    constructor(props = {}) {\n        super();\n        /**\n         * @private\n         * @type {?Uint8Array}\n         */\n        this._mappingSlot = null;\n\n        /**\n         * @private\n         * @type {?import(\"./EvmHookMappingEntry.js\").default[]}\n         */\n        this._entries = null;\n\n        if (props.mappingSlot != null) {\n            this.setMappingSlot(props.mappingSlot);\n        }\n\n        if (props.entries != null) {\n            this.setEntries(props.entries);\n        }\n    }\n\n    /**\n     *\n     * @param {Uint8Array} mappingSlot\n     * @returns {this}\n     */\n    setMappingSlot(mappingSlot) {\n        this._mappingSlot = mappingSlot;\n        return this;\n    }\n\n    /**\n     *\n     * @param {import(\"./EvmHookMappingEntry.js\").default[]} entries\n     * @returns {this}\n     */\n    setEntries(entries) {\n        this._entries = entries;\n        return this;\n    }\n\n    /**\n     *\n     * @returns {Uint8Array | null}\n     */\n    get mappingSlot() {\n        return this._mappingSlot;\n    }\n\n    /**\n     *\n     * @returns {import(\"./EvmHookMappingEntry.js\").default[] | null}\n     */\n    get entries() {\n        return this._entries;\n    }\n\n    /**\n     *\n     * @param {import(\"@hiero-ledger/proto\").com.hedera.hapi.node.hooks.IEvmHookStorageUpdate} hookStorageUpdate\n     * @returns {EvmHookMappingEntries}\n     */\n    static _fromProtobuf(hookStorageUpdate) {\n        return new EvmHookMappingEntries({\n            mappingSlot:\n                hookStorageUpdate.mappingEntries?.mappingSlot != null\n                    ? hookStorageUpdate.mappingEntries.mappingSlot\n                    : undefined,\n            entries: hookStorageUpdate.mappingEntries?.entries?.map((entry) =>\n                EvmHookMappingEntry._fromProtobuf(entry),\n            ),\n        });\n    }\n\n    /**\n     *\n     * @returns {import(\"@hiero-ledger/proto\").com.hedera.hapi.node.hooks.EvmHookStorageUpdate}\n     */\n    _toProtobuf() {\n        return {\n            mappingEntries: {\n                mappingSlot: this._mappingSlot,\n                entries:\n                    this._entries != null\n                        ? this._entries.map((entry) => entry._toProtobuf())\n                        : null,\n            },\n        };\n    }\n}\n\nexport { EvmHookStorageUpdate, EvmHookStorageSlot, EvmHookMappingEntries };\n"],"names":["EvmHookStorageUpdate","_fromProtobuf","hookStorageUpdate","storageSlot","EvmHookStorageSlot","mappingEntries","EvmHookMappingEntries","Error","_toProtobuf","constructor","props","super","this","_key","_value","key","setKey","value","setValue","hookStorageSlot","undefined","_mappingSlot","_entries","mappingSlot","setMappingSlot","entries","setEntries","map","entry","EvmHookMappingEntry"],"mappings":"wCASA,MAAMA,EAMF,oBAAOC,CAAcC,GACjB,GAAqC,MAAjCA,EAAkBC,YAClB,OAAOC,EAAmBH,cAAcC,GAG5C,GAAwC,MAApCA,EAAkBG,eAClB,OAAOC,EAAsBL,cAAcC,GAG/C,MAAM,IAAIK,MACN,4EAEZ,CAMI,WAAAC,GACI,MAAM,IAAID,MACN,qEAEZ,EAMA,MAAMH,UAA2BJ,EAM7B,WAAAS,CAAYC,EAAQ,IAChBC,QAKAC,KAAKC,KAAO,KAMZD,KAAKE,OAAS,KAEG,MAAbJ,EAAMK,KACNH,KAAKI,OAAON,EAAMK,KAGH,MAAfL,EAAMO,OACNL,KAAKM,SAASR,EAAMO,MAEhC,CAOI,MAAAD,CAAOD,GAEH,OADAH,KAAKC,KAAOE,EACLH,IACf,CAOI,QAAAM,CAASD,GAEL,OADAL,KAAKE,OAASG,EACPL,IACf,CAMI,OAAIG,GACA,OAAOH,KAAKC,IACpB,CAMI,SAAII,GACA,OAAOL,KAAKE,MACpB,CAOI,oBAAOb,CAAckB,GACjB,GAAmC,MAA/BA,EAAgBhB,YAChB,OAAO,IAAIC,EAAmB,CAC1BW,IACuC,MAAnCI,EAAgBhB,YAAYY,IACtBI,EAAgBhB,YAAYY,SAC5BK,EACVH,MACyC,MAArCE,EAAgBhB,YAAYc,MACtBE,EAAgBhB,YAAYc,WAC5BG,IAGlB,MAAM,IAAIb,MACN,qEAEZ,CAKI,WAAAC,GACI,MAAO,CACHL,YAAa,CACTY,IAAKH,KAAKC,KACVI,MAAOL,KAAKE,QAG5B,EAeA,MAAMR,UAA8BN,EAOhC,WAAAS,CAAYC,EAAQ,IAChBC,QAKAC,KAAKS,aAAe,KAMpBT,KAAKU,SAAW,KAES,MAArBZ,EAAMa,aACNX,KAAKY,eAAed,EAAMa,aAGT,MAAjBb,EAAMe,SACNb,KAAKc,WAAWhB,EAAMe,QAElC,CAOI,cAAAD,CAAeD,GAEX,OADAX,KAAKS,aAAeE,EACbX,IACf,CAOI,UAAAc,CAAWD,GAEP,OADAb,KAAKU,SAAWG,EACTb,IACf,CAMI,eAAIW,GACA,OAAOX,KAAKS,YACpB,CAMI,WAAII,GACA,OAAOb,KAAKU,QACpB,CAOI,oBAAOrB,CAAcC,GACjB,OAAO,IAAII,EAAsB,CAC7BiB,YACqD,MAAjDrB,EAAkBG,gBAAgBkB,YAC5BrB,EAAkBG,eAAekB,iBACjCH,EACVK,QAASvB,EAAkBG,gBAAgBoB,SAASE,IAAKC,GACrDC,EAAoB5B,cAAc2B,KAGlD,CAMI,WAAApB,GACI,MAAO,CACHH,eAAgB,CACZkB,YAAaX,KAAKS,aAClBI,QACqB,MAAjBb,KAAKU,SACCV,KAAKU,SAASK,IAAKC,GAAUA,EAAMpB,eACnC,MAG1B"}

package/lib/hooks/FungibleHookCall.cjs

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _HookCall = _interopRequireDefault(require("./HookCall.cjs"));
+var _EvmHookCall = _interopRequireDefault(require("./EvmHookCall.cjs"));
+var _FungibleHookType = _interopRequireDefault(require("./FungibleHookType.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @namespace proto
+ * @typedef {import("@hiero-ledger/proto").proto.IHookCall} HieroProto.proto.IHookCall
+ */
+
+/**
+ * @typedef {typeof FungibleHookType[keyof typeof FungibleHookType]} FungibleHookTypeValue
+ */
+
+/**
+ * A typed hook call for fungible (HBAR and FT) transfers.
+ */
+class FungibleHookCall extends _HookCall.default {
+  /**
+   * @param {object} props
+   * @param {Long} [props.hookId]
+   * @param {import("../hooks/EvmHookCall.js").default} [props.evmHookCall]
+   * @param {FungibleHookTypeValue} props.type - One of FungibleHookType.PRE_TX_ALLOWANCE_HOOK or FungibleHookType.PRE_POST_TX_ALLOWANCE_HOOK
+   */
+  constructor(props) {
+    super(props);
+    if (props.type == null) {
+      throw new Error("type cannot be null");
+    }
+
+    /**
+     * The type of fungible hook
+     * @private
+     * @type {FungibleHookTypeValue}
+     */
+    this._type = props.type;
+  }
+
+  /**
+   * @returns {FungibleHookTypeValue}
+   */
+  get type() {
+    return this._type;
+  }
+
+  /**
+   * @internal
+   * @param {HieroProto.proto.IHookCall} hookCall
+   * @param {FungibleHookTypeValue} type
+   * @returns {FungibleHookCall}
+   */
+  static _fromProtobufWithType(hookCall, type) {
+    return new FungibleHookCall({
+      hookId: hookCall.hookId != null ? hookCall.hookId : undefined,
+      evmHookCall: hookCall.evmHookCall ? _EvmHookCall.default._fromProtobuf(hookCall.evmHookCall) : undefined,
+      type
+    });
+  }
+}
+var _default = exports.default = FungibleHookCall;

package/lib/hooks/FungibleHookCall.d.ts

@@ -0,0 +1,50 @@
+export default FungibleHookCall;
+export namespace HieroProto {
+    namespace proto {
+        type IHookCall = import("@hiero-ledger/proto").proto.IHookCall;
+    }
+}
+export type FungibleHookTypeValue = (typeof FungibleHookType)[keyof typeof FungibleHookType];
+/**
+ * @namespace proto
+ * @typedef {import("@hiero-ledger/proto").proto.IHookCall} HieroProto.proto.IHookCall
+ */
+/**
+ * @typedef {typeof FungibleHookType[keyof typeof FungibleHookType]} FungibleHookTypeValue
+ */
+/**
+ * A typed hook call for fungible (HBAR and FT) transfers.
+ */
+declare class FungibleHookCall extends HookCall {
+    /**
+     * @internal
+     * @param {HieroProto.proto.IHookCall} hookCall
+     * @param {FungibleHookTypeValue} type
+     * @returns {FungibleHookCall}
+     */
+    static _fromProtobufWithType(hookCall: HieroProto.proto.IHookCall, type: FungibleHookTypeValue): FungibleHookCall;
+    /**
+     * @param {object} props
+     * @param {Long} [props.hookId]
+     * @param {import("../hooks/EvmHookCall.js").default} [props.evmHookCall]
+     * @param {FungibleHookTypeValue} props.type - One of FungibleHookType.PRE_TX_ALLOWANCE_HOOK or FungibleHookType.PRE_POST_TX_ALLOWANCE_HOOK
+     */
+    constructor(props: {
+        hookId?: import("long") | undefined;
+        evmHookCall?: EvmHookCall | undefined;
+        type: FungibleHookTypeValue;
+    });
+    /**
+     * The type of fungible hook
+     * @private
+     * @type {FungibleHookTypeValue}
+     */
+    private _type;
+    /**
+     * @returns {FungibleHookTypeValue}
+     */
+    get type(): FungibleHookTypeValue;
+}
+import FungibleHookType from "./FungibleHookType.js";
+import HookCall from "./HookCall.js";
+import EvmHookCall from "./EvmHookCall.js";

package/lib/hooks/FungibleHookCall.js

@@ -0,0 +1,2 @@
+import o from"./HookCall.js";import t from"./EvmHookCall.js";class e extends o{constructor(o){if(super(o),null==o.type)throw new Error("type cannot be null");this._type=o.type}get type(){return this._type}static _fromProtobufWithType(o,r){return new e({hookId:null!=o.hookId?o.hookId:void 0,evmHookCall:o.evmHookCall?t._fromProtobuf(o.evmHookCall):void 0,type:r})}}export{e as default};
+//# sourceMappingURL=FungibleHookCall.js.map

package/lib/hooks/FungibleHookCall.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FungibleHookCall.js","sources":["../../src/hooks/FungibleHookCall.js"],"sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\nimport HookCall from \"./HookCall.js\";\nimport EvmHookCall from \"./EvmHookCall.js\";\nimport FungibleHookType from \"./FungibleHookType.js\";\n\n/**\n * @namespace proto\n * @typedef {import(\"@hiero-ledger/proto\").proto.IHookCall} HieroProto.proto.IHookCall\n */\n\n/**\n * @typedef {typeof FungibleHookType[keyof typeof FungibleHookType]} FungibleHookTypeValue\n */\n\n/**\n * A typed hook call for fungible (HBAR and FT) transfers.\n */\nclass FungibleHookCall extends HookCall {\n    /**\n     * @param {object} props\n     * @param {Long} [props.hookId]\n     * @param {import(\"../hooks/EvmHookCall.js\").default} [props.evmHookCall]\n     * @param {FungibleHookTypeValue} props.type - One of FungibleHookType.PRE_TX_ALLOWANCE_HOOK or FungibleHookType.PRE_POST_TX_ALLOWANCE_HOOK\n     */\n    constructor(props) {\n        super(props);\n\n        if (props.type == null) {\n            throw new Error(\"type cannot be null\");\n        }\n\n        /**\n         * The type of fungible hook\n         * @private\n         * @type {FungibleHookTypeValue}\n         */\n        this._type = props.type;\n    }\n\n    /**\n     * @returns {FungibleHookTypeValue}\n     */\n    get type() {\n        return this._type;\n    }\n\n    /**\n     * @internal\n     * @param {HieroProto.proto.IHookCall} hookCall\n     * @param {FungibleHookTypeValue} type\n     * @returns {FungibleHookCall}\n     */\n    static _fromProtobufWithType(hookCall, type) {\n        return new FungibleHookCall({\n            hookId: hookCall.hookId != null ? hookCall.hookId : undefined,\n            evmHookCall: hookCall.evmHookCall\n                ? EvmHookCall._fromProtobuf(hookCall.evmHookCall)\n                : undefined,\n            type,\n        });\n    }\n}\n\nexport default FungibleHookCall;\n"],"names":["FungibleHookCall","HookCall","constructor","props","super","type","Error","this","_type","_fromProtobufWithType","hookCall","hookId","undefined","evmHookCall","EvmHookCall","_fromProtobuf"],"mappings":"6DAkBA,MAAMA,UAAyBC,EAO3B,WAAAC,CAAYC,GAGR,GAFAC,MAAMD,GAEY,MAAdA,EAAME,KACN,MAAM,IAAIC,MAAM,uBAQpBC,KAAKC,MAAQL,EAAME,IAC3B,CAKI,QAAIA,GACA,OAAOE,KAAKC,KACpB,CAQI,4BAAOC,CAAsBC,EAAUL,GACnC,OAAO,IAAIL,EAAiB,CACxBW,OAA2B,MAAnBD,EAASC,OAAiBD,EAASC,YAASC,EACpDC,YAAaH,EAASG,YAChBC,EAAYC,cAAcL,EAASG,kBACnCD,EACNP,QAEZ"}

package/lib/hooks/FungibleHookType.cjs

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const FungibleHookType = Object.freeze({
+  PRE_TX_ALLOWANCE_HOOK: 0,
+  PRE_POST_TX_ALLOWANCE_HOOK: 1
+});
+var _default = exports.default = FungibleHookType;

package/lib/hooks/FungibleHookType.d.ts

@@ -0,0 +1,5 @@
+export default FungibleHookType;
+declare const FungibleHookType: Readonly<{
+    PRE_TX_ALLOWANCE_HOOK: 0;
+    PRE_POST_TX_ALLOWANCE_HOOK: 1;
+}>;

package/lib/hooks/FungibleHookType.js

@@ -0,0 +1,2 @@
+const O=Object.freeze({PRE_TX_ALLOWANCE_HOOK:0,PRE_POST_TX_ALLOWANCE_HOOK:1});export{O as default};
+//# sourceMappingURL=FungibleHookType.js.map

package/lib/hooks/FungibleHookType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FungibleHookType.js","sources":["../../src/hooks/FungibleHookType.js"],"sourcesContent":["const FungibleHookType = Object.freeze({\n    PRE_TX_ALLOWANCE_HOOK: 0,\n    PRE_POST_TX_ALLOWANCE_HOOK: 1,\n});\n\nexport default FungibleHookType;\n"],"names":["FungibleHookType","Object","freeze","PRE_TX_ALLOWANCE_HOOK","PRE_POST_TX_ALLOWANCE_HOOK"],"mappings":"AAAK,MAACA,EAAmBC,OAAOC,OAAO,CACnCC,sBAAuB,EACvBC,2BAA4B"}