@hiero-ledger/sdk 2.70.0

package/lib/ObjectMap.cjs

@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * A simple "map" type that allows indexing by objects other than
+ * strings, numbers, or booleans, and doesn't use the object pointer.
+ *
+ * @abstract
+ * @template {{ toString(): string }} KeyT
+ * @template {any} ValueT
+ */
+class ObjectMap {
+  /**
+   * @param {(s: string) => KeyT} fromString
+   */
+  constructor(fromString) {
+    /**
+     * This map is from the stringified version of the key, to the value
+     *
+     * @type {Map<string, ValueT>}
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    this._map = new Map();
+
+    /**
+     * This map is from the key, to the value
+     *
+     * @type {Map<KeyT, ValueT>}
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    this.__map = new Map();
+
+    /**
+     * A function pointer to convert a key into a string. So we can set each
+     * value in both maps.
+     */
+    this._fromString = fromString;
+  }
+
+  /**
+   * Get a value by key or string.
+   *
+   * This is the main benefit of this class. If a user provides a `KeyT` we
+   * implicitly serialize it to a string and use the string version. Otherwise
+   * the user will get `undefined` even for a key that exists in the map since
+   * the `KeyT` the provided has a different pointer than the one we have stored.
+   * The string version doesn't have this issue since JS hashes the string and
+   * that would result in both `KeyT` hitting the same value even if they're
+   * different pointers.
+   *
+   * @param {KeyT | string} key
+   * @returns {?ValueT}
+   */
+  get(key) {
+    const k = typeof key === "string" ? key : key.toString();
+    const value = this._map.get(k);
+    return value != null ? value : null;
+  }
+
+  /**
+   * Set the key to a value in both maps
+   *
+   * @internal
+   * @param {KeyT} key
+   * @param {ValueT} value
+   */
+  _set(key, value) {
+    const k = typeof key === "string" ? key : key.toString();
+    this._map.set(k, value);
+    this.__map.set(key, value);
+  }
+
+  /**
+   * Create iterator of values
+   *
+   * @returns {IterableIterator<ValueT>}
+   */
+  values() {
+    return this._map.values();
+  }
+
+  /**
+   * Get the size of the map
+   *
+   * @returns {number}
+   */
+  get size() {
+    return this._map.size;
+  }
+
+  /**
+   * Get the keys of the map.
+   *
+   * @returns {IterableIterator<KeyT>}
+   */
+  keys() {
+    return this.__map.keys();
+  }
+
+  /**
+   * Create an iterator over key, value pairs
+   *
+   * @returns {IterableIterator<[KeyT, ValueT]>}
+   */
+  [Symbol.iterator]() {
+    return this.__map[Symbol.iterator]();
+  }
+
+  /**
+   * Stringify the map into _something_ readable.
+   * **NOTE**: This implementation is not stable and can change.
+   *
+   * @returns {string}
+   */
+  toString() {
+    /** @type {{[key: string]: any}} */
+    const map = {};
+    for (const [key, value] of this._map) {
+      map[key] = value;
+    }
+    return JSON.stringify(map);
+  }
+  toJSON() {
+    const obj = {};
+    this._map.forEach((value, key) => {
+      // @ts-ignore
+      obj[key] = value;
+    });
+    return obj;
+  }
+}
+exports.default = ObjectMap;

package/lib/ObjectMap.d.ts

@@ -0,0 +1,88 @@
+/**
+ * A simple "map" type that allows indexing by objects other than
+ * strings, numbers, or booleans, and doesn't use the object pointer.
+ *
+ * @abstract
+ * @template {{ toString(): string }} KeyT
+ * @template {any} ValueT
+ */
+export default class ObjectMap<KeyT extends {
+    toString(): string;
+}, ValueT extends unknown> {
+    /**
+     * @param {(s: string) => KeyT} fromString
+     */
+    constructor(fromString: (s: string) => KeyT);
+    /**
+     * This map is from the stringified version of the key, to the value
+     *
+     * @type {Map<string, ValueT>}
+     */
+    _map: Map<string, ValueT>;
+    /**
+     * This map is from the key, to the value
+     *
+     * @type {Map<KeyT, ValueT>}
+     */
+    __map: Map<KeyT, ValueT>;
+    /**
+     * A function pointer to convert a key into a string. So we can set each
+     * value in both maps.
+     */
+    _fromString: (s: string) => KeyT;
+    /**
+     * Get a value by key or string.
+     *
+     * This is the main benefit of this class. If a user provides a `KeyT` we
+     * implicitly serialize it to a string and use the string version. Otherwise
+     * the user will get `undefined` even for a key that exists in the map since
+     * the `KeyT` the provided has a different pointer than the one we have stored.
+     * The string version doesn't have this issue since JS hashes the string and
+     * that would result in both `KeyT` hitting the same value even if they're
+     * different pointers.
+     *
+     * @param {KeyT | string} key
+     * @returns {?ValueT}
+     */
+    get(key: KeyT | string): ValueT | null;
+    /**
+     * Set the key to a value in both maps
+     *
+     * @internal
+     * @param {KeyT} key
+     * @param {ValueT} value
+     */
+    _set(key: KeyT, value: ValueT): void;
+    /**
+     * Create iterator of values
+     *
+     * @returns {IterableIterator<ValueT>}
+     */
+    values(): IterableIterator<ValueT>;
+    /**
+     * Get the size of the map
+     *
+     * @returns {number}
+     */
+    get size(): number;
+    /**
+     * Get the keys of the map.
+     *
+     * @returns {IterableIterator<KeyT>}
+     */
+    keys(): IterableIterator<KeyT>;
+    /**
+     * Stringify the map into _something_ readable.
+     * **NOTE**: This implementation is not stable and can change.
+     *
+     * @returns {string}
+     */
+    toString(): string;
+    toJSON(): {};
+    /**
+     * Create an iterator over key, value pairs
+     *
+     * @returns {IterableIterator<[KeyT, ValueT]>}
+     */
+    [Symbol.iterator](): IterableIterator<[KeyT, ValueT]>;
+}

package/lib/ObjectMap.js

@@ -0,0 +1,2 @@
+class t{constructor(t){this._map=new Map,this.__map=new Map,this._fromString=t}get(t){const s="string"==typeof t?t:t.toString(),r=this._map.get(s);return null!=r?r:null}_set(t,s){const r="string"==typeof t?t:t.toString();this._map.set(r,s),this.__map.set(t,s)}values(){return this._map.values()}get size(){return this._map.size}keys(){return this.__map.keys()}[Symbol.iterator](){return this.__map[Symbol.iterator]()}toString(){const t={};for(const[s,r]of this._map)t[s]=r;return JSON.stringify(t)}toJSON(){const t={};return this._map.forEach(((s,r)=>{t[r]=s})),t}}export{t as default};
+//# sourceMappingURL=ObjectMap.js.map

package/lib/ObjectMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectMap.js","sources":["../src/ObjectMap.js"],"sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * A simple \"map\" type that allows indexing by objects other than\n * strings, numbers, or booleans, and doesn't use the object pointer.\n *\n * @abstract\n * @template {{ toString(): string }} KeyT\n * @template {any} ValueT\n */\nexport default class ObjectMap {\n    /**\n     * @param {(s: string) => KeyT} fromString\n     */\n    constructor(fromString) {\n        /**\n         * This map is from the stringified version of the key, to the value\n         *\n         * @type {Map<string, ValueT>}\n         */\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n        this._map = new Map();\n\n        /**\n         * This map is from the key, to the value\n         *\n         * @type {Map<KeyT, ValueT>}\n         */\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n        this.__map = new Map();\n\n        /**\n         * A function pointer to convert a key into a string. So we can set each\n         * value in both maps.\n         */\n        this._fromString = fromString;\n    }\n\n    /**\n     * Get a value by key or string.\n     *\n     * This is the main benefit of this class. If a user provides a `KeyT` we\n     * implicitly serialize it to a string and use the string version. Otherwise\n     * the user will get `undefined` even for a key that exists in the map since\n     * the `KeyT` the provided has a different pointer than the one we have stored.\n     * The string version doesn't have this issue since JS hashes the string and\n     * that would result in both `KeyT` hitting the same value even if they're\n     * different pointers.\n     *\n     * @param {KeyT | string} key\n     * @returns {?ValueT}\n     */\n    get(key) {\n        const k = typeof key === \"string\" ? key : key.toString();\n\n        const value = this._map.get(k);\n        return value != null ? value : null;\n    }\n\n    /**\n     * Set the key to a value in both maps\n     *\n     * @internal\n     * @param {KeyT} key\n     * @param {ValueT} value\n     */\n    _set(key, value) {\n        const k = typeof key === \"string\" ? key : key.toString();\n\n        this._map.set(k, value);\n        this.__map.set(key, value);\n    }\n\n    /**\n     * Create iterator of values\n     *\n     * @returns {IterableIterator<ValueT>}\n     */\n    values() {\n        return this._map.values();\n    }\n\n    /**\n     * Get the size of the map\n     *\n     * @returns {number}\n     */\n    get size() {\n        return this._map.size;\n    }\n\n    /**\n     * Get the keys of the map.\n     *\n     * @returns {IterableIterator<KeyT>}\n     */\n    keys() {\n        return this.__map.keys();\n    }\n\n    /**\n     * Create an iterator over key, value pairs\n     *\n     * @returns {IterableIterator<[KeyT, ValueT]>}\n     */\n    [Symbol.iterator]() {\n        return this.__map[Symbol.iterator]();\n    }\n\n    /**\n     * Stringify the map into _something_ readable.\n     * **NOTE**: This implementation is not stable and can change.\n     *\n     * @returns {string}\n     */\n    toString() {\n        /** @type {{[key: string]: any}} */\n        const map = {};\n\n        for (const [key, value] of this._map) {\n            map[key] = value;\n        }\n\n        return JSON.stringify(map);\n    }\n\n    toJSON() {\n        const obj = {};\n\n        this._map.forEach((value, key) => {\n            // @ts-ignore\n            obj[key] = value;\n        });\n\n        return obj;\n    }\n}\n"],"names":["ObjectMap","constructor","fromString","this","_map","Map","__map","_fromString","get","key","k","toString","value","_set","set","values","size","keys","Symbol","iterator","map","JSON","stringify","toJSON","obj","forEach"],"mappings":"AAUe,MAAMA,EAIjB,WAAAC,CAAYC,GAORC,KAAKC,KAAO,IAAIC,IAQhBF,KAAKG,MAAQ,IAAID,IAMjBF,KAAKI,YAAcL,CAC3B,CAgBI,GAAAM,CAAIC,GACA,MAAMC,EAAmB,iBAARD,EAAmBA,EAAMA,EAAIE,WAExCC,EAAQT,KAAKC,KAAKI,IAAIE,GAC5B,OAAgB,MAATE,EAAgBA,EAAQ,IACvC,CASI,IAAAC,CAAKJ,EAAKG,GACN,MAAMF,EAAmB,iBAARD,EAAmBA,EAAMA,EAAIE,WAE9CR,KAAKC,KAAKU,IAAIJ,EAAGE,GACjBT,KAAKG,MAAMQ,IAAIL,EAAKG,EAC5B,CAOI,MAAAG,GACI,OAAOZ,KAAKC,KAAKW,QACzB,CAOI,QAAIC,GACA,OAAOb,KAAKC,KAAKY,IACzB,CAOI,IAAAC,GACI,OAAOd,KAAKG,MAAMW,MAC1B,CAOI,CAACC,OAAOC,YACJ,OAAOhB,KAAKG,MAAMY,OAAOC,WACjC,CAQI,QAAAR,GAEI,MAAMS,EAAM,CAAE,EAEd,IAAK,MAAOX,EAAKG,KAAUT,KAAKC,KAC5BgB,EAAIX,GAAOG,EAGf,OAAOS,KAAKC,UAAUF,EAC9B,CAEI,MAAAG,GACI,MAAMC,EAAM,CAAE,EAOd,OALArB,KAAKC,KAAKqB,SAAQ,CAACb,EAAOH,KAEtBe,EAAIf,GAAOG,CAAK,IAGbY,CACf"}

package/lib/PrecheckStatusError.cjs

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _StatusError = _interopRequireDefault(require("./StatusError.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @typedef {import("./Status.js").default} Status
+ * @typedef {import("./transaction/TransactionId.js").default} TransactionId
+ * @typedef {import("./contract/ContractFunctionResult.js").default} ContractFunctionResult
+ * @typedef {import("./account/AccountId.js").default} AccountId
+ */
+
+/**
+ * @typedef {object} PrecheckStatusErrorJSON
+ * @property {string} name
+ * @property {string} status
+ * @property {string} transactionId
+ * @property {?string | null} nodeId
+ * @property {string} message
+ * @property {?ContractFunctionResult} contractFunctionResult
+ */
+
+/**
+ * Represents an error that occurs during the pre-check phase of a transaction
+ * on the Hedera network. The `PrecheckStatusError` class extends the base
+ * `StatusError` class and provides additional context specific to pre-check
+ * failures, such as the transaction ID, status, and any associated messages.
+ *
+ * This error is typically thrown when a transaction fails to meet the necessary
+ * conditions before being processed, allowing developers to handle such errors
+ * gracefully in their applications. The error includes details about the failure,
+ * making it easier to diagnose issues related to transaction submissions.
+ */
+class PrecheckStatusError extends _StatusError.default {
+  /**
+   * @param {object} props
+   * @param {Status} props.status
+   * @param {TransactionId} props.transactionId
+   * @param {AccountId} props.nodeId
+   * @param {?ContractFunctionResult} props.contractFunctionResult
+   */
+  constructor(props) {
+    super(props, `transaction ${props.transactionId.toString()} failed precheck with status ${props.status.toString()} against node account id ${props.nodeId.toString()}`);
+
+    /**
+     * @type {?ContractFunctionResult}
+     * @readonly
+     */
+    this.contractFunctionResult = props.contractFunctionResult;
+
+    /**
+     * @type {AccountId}
+     * @readonly
+     */
+    this.nodeId = props.nodeId;
+  }
+
+  /**
+   * @returns {PrecheckStatusErrorJSON}
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      status: this.status.toString(),
+      transactionId: this.transactionId.toString(),
+      nodeId: this.nodeId.toString(),
+      message: this.message,
+      contractFunctionResult: this.contractFunctionResult
+    };
+  }
+}
+exports.default = PrecheckStatusError;

package/lib/PrecheckStatusError.d.ts

@@ -0,0 +1,68 @@
+/**
+ * @typedef {import("./Status.js").default} Status
+ * @typedef {import("./transaction/TransactionId.js").default} TransactionId
+ * @typedef {import("./contract/ContractFunctionResult.js").default} ContractFunctionResult
+ * @typedef {import("./account/AccountId.js").default} AccountId
+ */
+/**
+ * @typedef {object} PrecheckStatusErrorJSON
+ * @property {string} name
+ * @property {string} status
+ * @property {string} transactionId
+ * @property {?string | null} nodeId
+ * @property {string} message
+ * @property {?ContractFunctionResult} contractFunctionResult
+ */
+/**
+ * Represents an error that occurs during the pre-check phase of a transaction
+ * on the Hedera network. The `PrecheckStatusError` class extends the base
+ * `StatusError` class and provides additional context specific to pre-check
+ * failures, such as the transaction ID, status, and any associated messages.
+ *
+ * This error is typically thrown when a transaction fails to meet the necessary
+ * conditions before being processed, allowing developers to handle such errors
+ * gracefully in their applications. The error includes details about the failure,
+ * making it easier to diagnose issues related to transaction submissions.
+ */
+export default class PrecheckStatusError extends StatusError {
+    /**
+     * @param {object} props
+     * @param {Status} props.status
+     * @param {TransactionId} props.transactionId
+     * @param {AccountId} props.nodeId
+     * @param {?ContractFunctionResult} props.contractFunctionResult
+     */
+    constructor(props: {
+        status: Status;
+        transactionId: TransactionId;
+        nodeId: AccountId;
+        contractFunctionResult: ContractFunctionResult | null;
+    });
+    /**
+     * @type {?ContractFunctionResult}
+     * @readonly
+     */
+    readonly contractFunctionResult: ContractFunctionResult | null;
+    /**
+     * @type {AccountId}
+     * @readonly
+     */
+    readonly nodeId: AccountId;
+    /**
+     * @returns {PrecheckStatusErrorJSON}
+     */
+    toJSON(): PrecheckStatusErrorJSON;
+}
+export type Status = import("./Status.js").default;
+export type TransactionId = import("./transaction/TransactionId.js").default;
+export type ContractFunctionResult = import("./contract/ContractFunctionResult.js").default;
+export type AccountId = import("./account/AccountId.js").default;
+export type PrecheckStatusErrorJSON = {
+    name: string;
+    status: string;
+    transactionId: string;
+    nodeId: (string | null) | null;
+    message: string;
+    contractFunctionResult: ContractFunctionResult | null;
+};
+import StatusError from "./StatusError.js";

package/lib/PrecheckStatusError.js

@@ -0,0 +1,2 @@
+import t from"./StatusError.js";class n extends t{constructor(t){super(t,`transaction ${t.transactionId.toString()} failed precheck with status ${t.status.toString()} against node account id ${t.nodeId.toString()}`),this.contractFunctionResult=t.contractFunctionResult,this.nodeId=t.nodeId}toJSON(){return{name:this.name,status:this.status.toString(),transactionId:this.transactionId.toString(),nodeId:this.nodeId.toString(),message:this.message,contractFunctionResult:this.contractFunctionResult}}}export{n as default};
+//# sourceMappingURL=PrecheckStatusError.js.map

package/lib/PrecheckStatusError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrecheckStatusError.js","sources":["../src/PrecheckStatusError.js"],"sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\nimport StatusError from \"./StatusError.js\";\n\n/**\n * @typedef {import(\"./Status.js\").default} Status\n * @typedef {import(\"./transaction/TransactionId.js\").default} TransactionId\n * @typedef {import(\"./contract/ContractFunctionResult.js\").default} ContractFunctionResult\n * @typedef {import(\"./account/AccountId.js\").default} AccountId\n */\n\n/**\n * @typedef {object} PrecheckStatusErrorJSON\n * @property {string} name\n * @property {string} status\n * @property {string} transactionId\n * @property {?string | null} nodeId\n * @property {string} message\n * @property {?ContractFunctionResult} contractFunctionResult\n */\n\n/**\n * Represents an error that occurs during the pre-check phase of a transaction\n * on the Hedera network. The `PrecheckStatusError` class extends the base\n * `StatusError` class and provides additional context specific to pre-check\n * failures, such as the transaction ID, status, and any associated messages.\n *\n * This error is typically thrown when a transaction fails to meet the necessary\n * conditions before being processed, allowing developers to handle such errors\n * gracefully in their applications. The error includes details about the failure,\n * making it easier to diagnose issues related to transaction submissions.\n */\nexport default class PrecheckStatusError extends StatusError {\n    /**\n     * @param {object} props\n     * @param {Status} props.status\n     * @param {TransactionId} props.transactionId\n     * @param {AccountId} props.nodeId\n     * @param {?ContractFunctionResult} props.contractFunctionResult\n     */\n    constructor(props) {\n        super(\n            props,\n            `transaction ${props.transactionId.toString()} failed precheck with status ${props.status.toString()} against node account id ${props.nodeId.toString()}`,\n        );\n\n        /**\n         * @type {?ContractFunctionResult}\n         * @readonly\n         */\n        this.contractFunctionResult = props.contractFunctionResult;\n\n        /**\n         * @type {AccountId}\n         * @readonly\n         */\n        this.nodeId = props.nodeId;\n    }\n\n    /**\n     * @returns {PrecheckStatusErrorJSON}\n     */\n    toJSON() {\n        return {\n            name: this.name,\n            status: this.status.toString(),\n            transactionId: this.transactionId.toString(),\n            nodeId: this.nodeId.toString(),\n            message: this.message,\n            contractFunctionResult: this.contractFunctionResult,\n        };\n    }\n}\n"],"names":["PrecheckStatusError","StatusError","constructor","props","super","transactionId","toString","status","nodeId","this","contractFunctionResult","toJSON","name","message"],"mappings":"gCAgCe,MAAMA,UAA4BC,EAQ7C,WAAAC,CAAYC,GACRC,MACID,EACA,eAAeA,EAAME,cAAcC,0CAA0CH,EAAMI,OAAOD,sCAAsCH,EAAMK,OAAOF,cAOjJG,KAAKC,uBAAyBP,EAAMO,uBAMpCD,KAAKD,OAASL,EAAMK,MAC5B,CAKI,MAAAG,GACI,MAAO,CACHC,KAAMH,KAAKG,KACXL,OAAQE,KAAKF,OAAOD,WACpBD,cAAeI,KAAKJ,cAAcC,WAClCE,OAAQC,KAAKD,OAAOF,WACpBO,QAASJ,KAAKI,QACdH,uBAAwBD,KAAKC,uBAEzC"}