@hiero-ledger/sdk 2.70.0

package/lib/Timestamp.cjs

@@ -0,0 +1,144 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _long = _interopRequireDefault(require("long"));
+var _Cache = _interopRequireDefault(require("./Cache.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @namespace proto
+ * @typedef {import("@hashgraph/proto").proto.ITimestamp} HieroProto.proto.ITimestamp
+ */
+
+const MAX_NS = _long.default.fromNumber(1000000000);
+const generatedIds = new Set();
+
+/**
+ * Represents a point in time with seconds and nanoseconds precision.
+ *
+ * The `Timestamp` class provides methods for creating, manipulating, and converting
+ * timestamps. It supports operations such as addition of nanoseconds, conversion to
+ * JavaScript Date objects, and generation of timestamps based on the current time.
+ */
+class Timestamp {
+  /**
+   * @param {Long | number} seconds
+   * @param {Long | number} nanos
+   */
+  constructor(seconds, nanos) {
+    /**
+     * @readonly
+     * @type {Long}
+     */
+    this.seconds = seconds instanceof _long.default ? seconds : _long.default.fromNumber(seconds);
+
+    /**
+     * @readonly
+     * @type {Long}
+     */
+    this.nanos = nanos instanceof _long.default ? nanos : _long.default.fromNumber(nanos);
+    Object.freeze(this);
+  }
+
+  /**
+   * @param {boolean} hasJitter
+   * @returns {Timestamp}
+   */
+  static generate(hasJitter = true) {
+    let jitter;
+    if (hasJitter) {
+      jitter = Math.floor(Math.random() * 5000) + 3000;
+    } else {
+      jitter = 0;
+    }
+    const now = Date.now() - jitter;
+    const seconds = Math.floor(now / 1000) + _Cache.default.timeDrift;
+    const nanos = Math.floor(now % 1000) * 1000000 + Math.floor(Math.random() * 1000000);
+    const timestamp = new Timestamp(seconds, nanos);
+    if (generatedIds.has(timestamp.toString())) {
+      return this.generate();
+    } else {
+      generatedIds.add(timestamp.toString());
+      return timestamp;
+    }
+  }
+
+  /**
+   * @param {string | number | Date} date
+   * @returns {Timestamp}
+   */
+  static fromDate(date) {
+    let nanos;
+    if (typeof date === "number") {
+      nanos = _long.default.fromNumber(date);
+    } else if (typeof date === "string") {
+      nanos = _long.default.fromNumber(Date.parse(date)).mul(1000000);
+    } else if (date instanceof Date) {
+      nanos = _long.default.fromNumber(date.getTime()).mul(1000000);
+    } else {
+      throw new TypeError(`invalid type '${typeof date}' for 'data', expected 'Date'`);
+    }
+    return new Timestamp(0, 0).plusNanos(nanos);
+  }
+
+  /**
+   * @returns {Date}
+   */
+  toDate() {
+    return new Date(this.seconds.toInt() * 1000 + Math.floor(this.nanos.toInt() / 1000000));
+  }
+
+  /**
+   * @param {Long | number} nanos
+   * @returns {Timestamp}
+   */
+  plusNanos(nanos) {
+    const ns = this.nanos.add(nanos);
+    return new Timestamp(this.seconds.add(ns.div(MAX_NS)), ns.mod(MAX_NS));
+  }
+
+  /**
+   * @internal
+   * @returns {HieroProto.proto.ITimestamp}
+   */
+  _toProtobuf() {
+    return {
+      seconds: this.seconds,
+      nanos: this.nanos.toInt()
+    };
+  }
+
+  /**
+   * @internal
+   * @param {HieroProto.proto.ITimestamp} timestamp
+   * @returns {Timestamp}
+   */
+  static _fromProtobuf(timestamp) {
+    return new Timestamp(timestamp.seconds instanceof _long.default ? timestamp.seconds.toInt() : timestamp.seconds != null ? timestamp.seconds : 0, timestamp.nanos != null ? timestamp.nanos : 0);
+  }
+
+  /**
+   * @returns {string}
+   */
+  toString() {
+    const zeroPaddedNanos = String(this.nanos).padStart(9, "0");
+    return `${this.seconds.toString()}.${zeroPaddedNanos}`;
+  }
+
+  /**
+   * @param {Timestamp} other
+   * @returns {number}
+   */
+  compare(other) {
+    const comparison = this.seconds.compare(other.seconds);
+    if (comparison != 0) {
+      return comparison;
+    }
+    return this.nanos.compare(other.nanos);
+  }
+}
+exports.default = Timestamp;

package/lib/Timestamp.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Represents a point in time with seconds and nanoseconds precision.
+ *
+ * The `Timestamp` class provides methods for creating, manipulating, and converting
+ * timestamps. It supports operations such as addition of nanoseconds, conversion to
+ * JavaScript Date objects, and generation of timestamps based on the current time.
+ */
+export default class Timestamp {
+    /**
+     * @param {boolean} hasJitter
+     * @returns {Timestamp}
+     */
+    static generate(hasJitter?: boolean): Timestamp;
+    /**
+     * @param {string | number | Date} date
+     * @returns {Timestamp}
+     */
+    static fromDate(date: string | number | Date): Timestamp;
+    /**
+     * @internal
+     * @param {HieroProto.proto.ITimestamp} timestamp
+     * @returns {Timestamp}
+     */
+    static _fromProtobuf(timestamp: HieroProto.proto.ITimestamp): Timestamp;
+    /**
+     * @param {Long | number} seconds
+     * @param {Long | number} nanos
+     */
+    constructor(seconds: Long | number, nanos: Long | number);
+    /**
+     * @readonly
+     * @type {Long}
+     */
+    readonly seconds: Long;
+    /**
+     * @readonly
+     * @type {Long}
+     */
+    readonly nanos: Long;
+    /**
+     * @returns {Date}
+     */
+    toDate(): Date;
+    /**
+     * @param {Long | number} nanos
+     * @returns {Timestamp}
+     */
+    plusNanos(nanos: Long | number): Timestamp;
+    /**
+     * @internal
+     * @returns {HieroProto.proto.ITimestamp}
+     */
+    _toProtobuf(): HieroProto.proto.ITimestamp;
+    /**
+     * @returns {string}
+     */
+    toString(): string;
+    /**
+     * @param {Timestamp} other
+     * @returns {number}
+     */
+    compare(other: Timestamp): number;
+}
+export namespace HieroProto {
+    namespace proto {
+        type ITimestamp = import("@hashgraph/proto").proto.ITimestamp;
+    }
+}
+import Long from "long";

package/lib/Timestamp.js

@@ -0,0 +1,2 @@
+import t from"long";import e from"./Cache.js";const o=t.fromNumber(1e9),n=new Set;class s{constructor(e,o){this.seconds=e instanceof t?e:t.fromNumber(e),this.nanos=o instanceof t?o:t.fromNumber(o),Object.freeze(this)}static generate(t=!0){let o;o=t?Math.floor(5e3*Math.random())+3e3:0;const r=Date.now()-o,a=Math.floor(r/1e3)+e.timeDrift,i=1e6*Math.floor(r%1e3)+Math.floor(1e6*Math.random()),c=new s(a,i);return n.has(c.toString())?this.generate():(n.add(c.toString()),c)}static fromDate(e){let o;if("number"==typeof e)o=t.fromNumber(e);else if("string"==typeof e)o=t.fromNumber(Date.parse(e)).mul(1e6);else{if(!(e instanceof Date))throw new TypeError(`invalid type '${typeof e}' for 'data', expected 'Date'`);o=t.fromNumber(e.getTime()).mul(1e6)}return new s(0,0).plusNanos(o)}toDate(){return new Date(1e3*this.seconds.toInt()+Math.floor(this.nanos.toInt()/1e6))}plusNanos(t){const e=this.nanos.add(t);return new s(this.seconds.add(e.div(o)),e.mod(o))}_toProtobuf(){return{seconds:this.seconds,nanos:this.nanos.toInt()}}static _fromProtobuf(e){return new s(e.seconds instanceof t?e.seconds.toInt():null!=e.seconds?e.seconds:0,null!=e.nanos?e.nanos:0)}toString(){const t=String(this.nanos).padStart(9,"0");return`${this.seconds.toString()}.${t}`}compare(t){const e=this.seconds.compare(t.seconds);return 0!=e?e:this.nanos.compare(t.nanos)}}export{s as default};
+//# sourceMappingURL=Timestamp.js.map

package/lib/Timestamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Timestamp.js","sources":["../src/Timestamp.js"],"sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\nimport Long from \"long\";\nimport Cache from \"./Cache.js\";\n\n/**\n * @namespace proto\n * @typedef {import(\"@hashgraph/proto\").proto.ITimestamp} HieroProto.proto.ITimestamp\n */\n\nconst MAX_NS = Long.fromNumber(1000000000);\nconst generatedIds = new Set();\n\n/**\n * Represents a point in time with seconds and nanoseconds precision.\n *\n * The `Timestamp` class provides methods for creating, manipulating, and converting\n * timestamps. It supports operations such as addition of nanoseconds, conversion to\n * JavaScript Date objects, and generation of timestamps based on the current time.\n */\nexport default class Timestamp {\n    /**\n     * @param {Long | number} seconds\n     * @param {Long | number} nanos\n     */\n    constructor(seconds, nanos) {\n        /**\n         * @readonly\n         * @type {Long}\n         */\n        this.seconds =\n            seconds instanceof Long ? seconds : Long.fromNumber(seconds);\n\n        /**\n         * @readonly\n         * @type {Long}\n         */\n        this.nanos = nanos instanceof Long ? nanos : Long.fromNumber(nanos);\n\n        Object.freeze(this);\n    }\n\n    /**\n     * @param {boolean} hasJitter\n     * @returns {Timestamp}\n     */\n    static generate(hasJitter = true) {\n        let jitter;\n        if (hasJitter) {\n            jitter = Math.floor(Math.random() * 5000) + 3000;\n        } else {\n            jitter = 0;\n        }\n        const now = Date.now() - jitter;\n        const seconds = Math.floor(now / 1000) + Cache.timeDrift;\n        const nanos =\n            Math.floor(now % 1000) * 1000000 +\n            Math.floor(Math.random() * 1000000);\n\n        const timestamp = new Timestamp(seconds, nanos);\n        if (generatedIds.has(timestamp.toString())) {\n            return this.generate();\n        } else {\n            generatedIds.add(timestamp.toString());\n            return timestamp;\n        }\n    }\n\n    /**\n     * @param {string | number | Date} date\n     * @returns {Timestamp}\n     */\n    static fromDate(date) {\n        let nanos;\n\n        if (typeof date === \"number\") {\n            nanos = Long.fromNumber(date);\n        } else if (typeof date === \"string\") {\n            nanos = Long.fromNumber(Date.parse(date)).mul(1000000);\n        } else if (date instanceof Date) {\n            nanos = Long.fromNumber(date.getTime()).mul(1000000);\n        } else {\n            throw new TypeError(\n                `invalid type '${typeof date}' for 'data', expected 'Date'`,\n            );\n        }\n\n        return new Timestamp(0, 0).plusNanos(nanos);\n    }\n\n    /**\n     * @returns {Date}\n     */\n    toDate() {\n        return new Date(\n            this.seconds.toInt() * 1000 +\n                Math.floor(this.nanos.toInt() / 1000000),\n        );\n    }\n\n    /**\n     * @param {Long | number} nanos\n     * @returns {Timestamp}\n     */\n    plusNanos(nanos) {\n        const ns = this.nanos.add(nanos);\n\n        return new Timestamp(this.seconds.add(ns.div(MAX_NS)), ns.mod(MAX_NS));\n    }\n\n    /**\n     * @internal\n     * @returns {HieroProto.proto.ITimestamp}\n     */\n    _toProtobuf() {\n        return {\n            seconds: this.seconds,\n            nanos: this.nanos.toInt(),\n        };\n    }\n\n    /**\n     * @internal\n     * @param {HieroProto.proto.ITimestamp} timestamp\n     * @returns {Timestamp}\n     */\n    static _fromProtobuf(timestamp) {\n        return new Timestamp(\n            timestamp.seconds instanceof Long\n                ? timestamp.seconds.toInt()\n                : timestamp.seconds != null\n                  ? timestamp.seconds\n                  : 0,\n\n            timestamp.nanos != null ? timestamp.nanos : 0,\n        );\n    }\n\n    /**\n     * @returns {string}\n     */\n    toString() {\n        const zeroPaddedNanos = String(this.nanos).padStart(9, \"0\");\n        return `${this.seconds.toString()}.${zeroPaddedNanos}`;\n    }\n\n    /**\n     * @param {Timestamp} other\n     * @returns {number}\n     */\n    compare(other) {\n        const comparison = this.seconds.compare(other.seconds);\n\n        if (comparison != 0) {\n            return comparison;\n        }\n\n        return this.nanos.compare(other.nanos);\n    }\n}\n"],"names":["MAX_NS","Long","fromNumber","generatedIds","Set","Timestamp","constructor","seconds","nanos","this","Object","freeze","generate","hasJitter","jitter","Math","floor","random","now","Date","Cache","timeDrift","timestamp","has","toString","add","fromDate","date","parse","mul","TypeError","getTime","plusNanos","toDate","toInt","ns","div","mod","_toProtobuf","_fromProtobuf","zeroPaddedNanos","String","padStart","compare","other","comparison"],"mappings":"8CAUA,MAAMA,EAASC,EAAKC,WAAW,KACzBC,EAAe,IAAIC,IASV,MAAMC,EAKjB,WAAAC,CAAYC,EAASC,GAKjBC,KAAKF,QACDA,aAAmBN,EAAOM,EAAUN,EAAKC,WAAWK,GAMxDE,KAAKD,MAAQA,aAAiBP,EAAOO,EAAQP,EAAKC,WAAWM,GAE7DE,OAAOC,OAAOF,KACtB,CAMI,eAAOG,CAASC,GAAY,GACxB,IAAIC,EAEAA,EADAD,EACSE,KAAKC,MAAsB,IAAhBD,KAAKE,UAAmB,IAEnC,EAEb,MAAMC,EAAMC,KAAKD,MAAQJ,EACnBP,EAAUQ,KAAKC,MAAME,EAAM,KAAQE,EAAMC,UACzCb,EACuB,IAAzBO,KAAKC,MAAME,EAAM,KACjBH,KAAKC,MAAsB,IAAhBD,KAAKE,UAEdK,EAAY,IAAIjB,EAAUE,EAASC,GACzC,OAAIL,EAAaoB,IAAID,EAAUE,YACpBf,KAAKG,YAEZT,EAAasB,IAAIH,EAAUE,YACpBF,EAEnB,CAMI,eAAOI,CAASC,GACZ,IAAInB,EAEJ,GAAoB,iBAATmB,EACPnB,EAAQP,EAAKC,WAAWyB,QACrB,GAAoB,iBAATA,EACdnB,EAAQP,EAAKC,WAAWiB,KAAKS,MAAMD,IAAOE,IAAI,SAC3C,MAAIF,aAAgBR,MAGvB,MAAM,IAAIW,UACN,wBAAwBH,kCAH5BnB,EAAQP,EAAKC,WAAWyB,EAAKI,WAAWF,IAAI,IAKxD,CAEQ,OAAO,IAAIxB,EAAU,EAAG,GAAG2B,UAAUxB,EAC7C,CAKI,MAAAyB,GACI,OAAO,IAAId,KACgB,IAAvBV,KAAKF,QAAQ2B,QACTnB,KAAKC,MAAMP,KAAKD,MAAM0B,QAAU,KAEhD,CAMI,SAAAF,CAAUxB,GACN,MAAM2B,EAAK1B,KAAKD,MAAMiB,IAAIjB,GAE1B,OAAO,IAAIH,EAAUI,KAAKF,QAAQkB,IAAIU,EAAGC,IAAIpC,IAAUmC,EAAGE,IAAIrC,GACtE,CAMI,WAAAsC,GACI,MAAO,CACH/B,QAASE,KAAKF,QACdC,MAAOC,KAAKD,MAAM0B,QAE9B,CAOI,oBAAOK,CAAcjB,GACjB,OAAO,IAAIjB,EACPiB,EAAUf,mBAAmBN,EACvBqB,EAAUf,QAAQ2B,QACG,MAArBZ,EAAUf,QACRe,EAAUf,QACV,EAEW,MAAnBe,EAAUd,MAAgBc,EAAUd,MAAQ,EAExD,CAKI,QAAAgB,GACI,MAAMgB,EAAkBC,OAAOhC,KAAKD,OAAOkC,SAAS,EAAG,KACvD,MAAO,GAAGjC,KAAKF,QAAQiB,cAAcgB,GAC7C,CAMI,OAAAG,CAAQC,GACJ,MAAMC,EAAapC,KAAKF,QAAQoC,QAAQC,EAAMrC,SAE9C,OAAkB,GAAdsC,EACOA,EAGJpC,KAAKD,MAAMmC,QAAQC,EAAMpC,MACxC"}

package/lib/TransactionFeeSchedule.cjs

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var HieroProto = _interopRequireWildcard(require("@hashgraph/proto"));
+var _RequestType = _interopRequireDefault(require("./RequestType.cjs"));
+var _FeeData = _interopRequireDefault(require("./FeeData.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+// SPDX-License-Identifier: Apache-2.0
+
+class TransactionFeeSchedule {
+  /**
+   * @param {object} [props]
+   * @param {RequestType} [props.hederaFunctionality]
+   * @param {FeeData} [props.feeData]
+   * @param {FeeData[]} [props.fees]
+   */
+  constructor(props = {}) {
+    /*
+     * A particular transaction or query
+     *
+     * @type {RequestType}
+     */
+    this.hederaFunctionality = props.hederaFunctionality;
+
+    /*
+     * Resource price coefficients
+     *
+     * @type {FeeData}
+     */
+    this.feeData = props.feeData;
+
+    /*
+     * Resource price coefficients
+     *
+     * @type {FeeData[]}
+     */
+    this.fees = props.fees;
+  }
+
+  /**
+   * @param {Uint8Array} bytes
+   * @returns {TransactionFeeSchedule}
+   */
+  static fromBytes(bytes) {
+    return TransactionFeeSchedule._fromProtobuf(HieroProto.proto.TransactionFeeSchedule.decode(bytes));
+  }
+
+  /**
+   * @internal
+   * @param {HieroProto.proto.ITransactionFeeSchedule} transactionFeeSchedule
+   * @returns {TransactionFeeSchedule}
+   */
+  static _fromProtobuf(transactionFeeSchedule) {
+    return new TransactionFeeSchedule({
+      hederaFunctionality: transactionFeeSchedule.hederaFunctionality != null ? _RequestType.default._fromCode(transactionFeeSchedule.hederaFunctionality) : undefined,
+      feeData: transactionFeeSchedule.feeData != null ? _FeeData.default._fromProtobuf(transactionFeeSchedule.feeData) : undefined,
+      fees: transactionFeeSchedule.fees != null ? transactionFeeSchedule.fees.map(fee => _FeeData.default._fromProtobuf(fee)) : undefined
+    });
+  }
+
+  /**
+   * @internal
+   * @returns {HieroProto.proto.ITransactionFeeSchedule}
+   */
+  _toProtobuf() {
+    return {
+      hederaFunctionality: this.hederaFunctionality != null ? this.hederaFunctionality.valueOf() : undefined,
+      feeData: this.feeData != null ? this.feeData._toProtobuf() : undefined,
+      fees: this.fees != null ? this.fees.map(fee => fee._toProtobuf()) : undefined
+    };
+  }
+
+  /**
+   * @returns {Uint8Array}
+   */
+  toBytes() {
+    return HieroProto.proto.TransactionFeeSchedule.encode(this._toProtobuf()).finish();
+  }
+}
+exports.default = TransactionFeeSchedule;

package/lib/TransactionFeeSchedule.d.ts

@@ -0,0 +1,39 @@
+export default class TransactionFeeSchedule {
+    /**
+     * @param {Uint8Array} bytes
+     * @returns {TransactionFeeSchedule}
+     */
+    static fromBytes(bytes: Uint8Array): TransactionFeeSchedule;
+    /**
+     * @internal
+     * @param {HieroProto.proto.ITransactionFeeSchedule} transactionFeeSchedule
+     * @returns {TransactionFeeSchedule}
+     */
+    static _fromProtobuf(transactionFeeSchedule: HieroProto.proto.ITransactionFeeSchedule): TransactionFeeSchedule;
+    /**
+     * @param {object} [props]
+     * @param {RequestType} [props.hederaFunctionality]
+     * @param {FeeData} [props.feeData]
+     * @param {FeeData[]} [props.fees]
+     */
+    constructor(props?: {
+        hederaFunctionality?: RequestType | undefined;
+        feeData?: FeeData | undefined;
+        fees?: FeeData[] | undefined;
+    });
+    hederaFunctionality: RequestType | undefined;
+    feeData: FeeData | undefined;
+    fees: FeeData[] | undefined;
+    /**
+     * @internal
+     * @returns {HieroProto.proto.ITransactionFeeSchedule}
+     */
+    _toProtobuf(): HieroProto.proto.ITransactionFeeSchedule;
+    /**
+     * @returns {Uint8Array}
+     */
+    toBytes(): Uint8Array;
+}
+import RequestType from "./RequestType.js";
+import FeeData from "./FeeData.js";
+import * as HieroProto from "@hashgraph/proto";

package/lib/TransactionFeeSchedule.js

@@ -0,0 +1,2 @@
+import*as e from"@hashgraph/proto";import t from"./RequestType.js";import o from"./FeeData.js";class a{constructor(e={}){this.hederaFunctionality=e.hederaFunctionality,this.feeData=e.feeData,this.fees=e.fees}static fromBytes(t){return a._fromProtobuf(e.proto.TransactionFeeSchedule.decode(t))}static _fromProtobuf(e){return new a({hederaFunctionality:null!=e.hederaFunctionality?t._fromCode(e.hederaFunctionality):void 0,feeData:null!=e.feeData?o._fromProtobuf(e.feeData):void 0,fees:null!=e.fees?e.fees.map((e=>o._fromProtobuf(e))):void 0})}_toProtobuf(){return{hederaFunctionality:null!=this.hederaFunctionality?this.hederaFunctionality.valueOf():void 0,feeData:null!=this.feeData?this.feeData._toProtobuf():void 0,fees:null!=this.fees?this.fees.map((e=>e._toProtobuf())):void 0}}toBytes(){return e.proto.TransactionFeeSchedule.encode(this._toProtobuf()).finish()}}export{a as default};
+//# sourceMappingURL=TransactionFeeSchedule.js.map

package/lib/TransactionFeeSchedule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionFeeSchedule.js","sources":["../src/TransactionFeeSchedule.js"],"sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\nimport * as HieroProto from \"@hashgraph/proto\";\nimport RequestType from \"./RequestType.js\";\nimport FeeData from \"./FeeData.js\";\n\nexport default class TransactionFeeSchedule {\n    /**\n     * @param {object} [props]\n     * @param {RequestType} [props.hederaFunctionality]\n     * @param {FeeData} [props.feeData]\n     * @param {FeeData[]} [props.fees]\n     */\n    constructor(props = {}) {\n        /*\n         * A particular transaction or query\n         *\n         * @type {RequestType}\n         */\n        this.hederaFunctionality = props.hederaFunctionality;\n\n        /*\n         * Resource price coefficients\n         *\n         * @type {FeeData}\n         */\n        this.feeData = props.feeData;\n\n        /*\n         * Resource price coefficients\n         *\n         * @type {FeeData[]}\n         */\n        this.fees = props.fees;\n    }\n\n    /**\n     * @param {Uint8Array} bytes\n     * @returns {TransactionFeeSchedule}\n     */\n    static fromBytes(bytes) {\n        return TransactionFeeSchedule._fromProtobuf(\n            HieroProto.proto.TransactionFeeSchedule.decode(bytes),\n        );\n    }\n\n    /**\n     * @internal\n     * @param {HieroProto.proto.ITransactionFeeSchedule} transactionFeeSchedule\n     * @returns {TransactionFeeSchedule}\n     */\n    static _fromProtobuf(transactionFeeSchedule) {\n        return new TransactionFeeSchedule({\n            hederaFunctionality:\n                transactionFeeSchedule.hederaFunctionality != null\n                    ? RequestType._fromCode(\n                          transactionFeeSchedule.hederaFunctionality,\n                      )\n                    : undefined,\n            feeData:\n                transactionFeeSchedule.feeData != null\n                    ? FeeData._fromProtobuf(transactionFeeSchedule.feeData)\n                    : undefined,\n            fees:\n                transactionFeeSchedule.fees != null\n                    ? transactionFeeSchedule.fees.map((fee) =>\n                          FeeData._fromProtobuf(fee),\n                      )\n                    : undefined,\n        });\n    }\n\n    /**\n     * @internal\n     * @returns {HieroProto.proto.ITransactionFeeSchedule}\n     */\n    _toProtobuf() {\n        return {\n            hederaFunctionality:\n                this.hederaFunctionality != null\n                    ? this.hederaFunctionality.valueOf()\n                    : undefined,\n            feeData:\n                this.feeData != null ? this.feeData._toProtobuf() : undefined,\n            fees:\n                this.fees != null\n                    ? this.fees.map((fee) => fee._toProtobuf())\n                    : undefined,\n        };\n    }\n\n    /**\n     * @returns {Uint8Array}\n     */\n    toBytes() {\n        return HieroProto.proto.TransactionFeeSchedule.encode(\n            this._toProtobuf(),\n        ).finish();\n    }\n}\n"],"names":["TransactionFeeSchedule","constructor","props","this","hederaFunctionality","feeData","fees","fromBytes","bytes","_fromProtobuf","HieroProto","proto","decode","transactionFeeSchedule","RequestType","_fromCode","undefined","FeeData","map","fee","_toProtobuf","valueOf","toBytes","encode","finish"],"mappings":"+FAMe,MAAMA,EAOjB,WAAAC,CAAYC,EAAQ,IAMhBC,KAAKC,oBAAsBF,EAAME,oBAOjCD,KAAKE,QAAUH,EAAMG,QAOrBF,KAAKG,KAAOJ,EAAMI,IAC1B,CAMI,gBAAOC,CAAUC,GACb,OAAOR,EAAuBS,cAC1BC,EAAWC,MAAMX,uBAAuBY,OAAOJ,GAE3D,CAOI,oBAAOC,CAAcI,GACjB,OAAO,IAAIb,EAAuB,CAC9BI,oBACkD,MAA9CS,EAAuBT,oBACjBU,EAAYC,UACRF,EAAuBT,0BAE3BY,EACVX,QACsC,MAAlCQ,EAAuBR,QACjBY,EAAQR,cAAcI,EAAuBR,cAC7CW,EACVV,KACmC,MAA/BO,EAAuBP,KACjBO,EAAuBP,KAAKY,KAAKC,GAC7BF,EAAQR,cAAcU,UAE1BH,GAEtB,CAMI,WAAAI,GACI,MAAO,CACHhB,oBACgC,MAA5BD,KAAKC,oBACCD,KAAKC,oBAAoBiB,eACzBL,EACVX,QACoB,MAAhBF,KAAKE,QAAkBF,KAAKE,QAAQe,mBAAgBJ,EACxDV,KACiB,MAAbH,KAAKG,KACCH,KAAKG,KAAKY,KAAKC,GAAQA,EAAIC,qBAC3BJ,EAEtB,CAKI,OAAAM,GACI,OAAOZ,EAAWC,MAAMX,uBAAuBuB,OAC3CpB,KAAKiB,eACPI,QACV"}

package/lib/Transfer.cjs

@@ -0,0 +1,104 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _AccountId = _interopRequireDefault(require("./account/AccountId.cjs"));
+var _Hbar = _interopRequireDefault(require("./Hbar.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @typedef {object} TransferJSON
+ * @property {string} accountId
+ * @property {string} amount
+ * @property {boolean} isApproved
+ */
+
+/**
+ * @namespace proto
+ * @typedef {import("@hashgraph/proto").proto.IAccountAmount} HieroProto.proto.IAccountAmount
+ * @typedef {import("@hashgraph/proto").proto.IAccountID} HieroProto.proto.IAccountID
+ */
+
+/**
+ * @typedef {import("bignumber.js").default} BigNumber
+ * @typedef {import("long")} Long
+ */
+
+/**
+ * An account, and the amount that it sends or receives during a cryptocurrency transfer.
+ */
+class Transfer {
+  /**
+   * @internal
+   * @param {object} props
+   * @param {AccountId | string} props.accountId
+   * @param {number | string | Long | BigNumber | Hbar} props.amount
+   * @param {boolean} props.isApproved
+   */
+  constructor(props) {
+    /**
+     * The Account ID that sends or receives cryptocurrency.
+     *
+     * @readonly
+     */
+    this.accountId = props.accountId instanceof _AccountId.default ? props.accountId : _AccountId.default.fromString(props.accountId);
+
+    /**
+     * The amount of tinybars that the account sends(negative) or receives(positive).
+     */
+    this.amount = props.amount instanceof _Hbar.default ? props.amount : new _Hbar.default(props.amount);
+    this.isApproved = props.isApproved;
+  }
+
+  /**
+   * @internal
+   * @param {HieroProto.proto.IAccountAmount[]} accountAmounts
+   * @returns {Transfer[]}
+   */
+  static _fromProtobuf(accountAmounts) {
+    const transfers = [];
+    for (const transfer of accountAmounts) {
+      transfers.push(new Transfer({
+        accountId: _AccountId.default._fromProtobuf(/** @type {HieroProto.proto.IAccountID} */
+        transfer.accountID),
+        amount: _Hbar.default.fromTinybars(transfer.amount != null ? transfer.amount : 0),
+        isApproved: (/** @type {boolean} */transfer.isApproval)
+      }));
+    }
+    return transfers;
+  }
+
+  /**
+   * @internal
+   * @returns {HieroProto.proto.IAccountAmount}
+   */
+  _toProtobuf() {
+    return {
+      accountID: this.accountId._toProtobuf(),
+      amount: this.amount.toTinybars(),
+      isApproval: this.isApproved
+    };
+  }
+
+  /**
+   * @returns {TransferJSON}
+   */
+  toJSON() {
+    return {
+      accountId: this.accountId.toString(),
+      amount: this.amount.toTinybars().toString(),
+      isApproved: this.isApproved
+    };
+  }
+
+  /**
+   * @returns {string}
+   */
+  toString() {
+    return JSON.stringify(this.toJSON());
+  }
+}
+exports.default = Transfer;

package/lib/Transfer.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @typedef {object} TransferJSON
+ * @property {string} accountId
+ * @property {string} amount
+ * @property {boolean} isApproved
+ */
+/**
+ * @namespace proto
+ * @typedef {import("@hashgraph/proto").proto.IAccountAmount} HieroProto.proto.IAccountAmount
+ * @typedef {import("@hashgraph/proto").proto.IAccountID} HieroProto.proto.IAccountID
+ */
+/**
+ * @typedef {import("bignumber.js").default} BigNumber
+ * @typedef {import("long")} Long
+ */
+/**
+ * An account, and the amount that it sends or receives during a cryptocurrency transfer.
+ */
+export default class Transfer {
+    /**
+     * @internal
+     * @param {HieroProto.proto.IAccountAmount[]} accountAmounts
+     * @returns {Transfer[]}
+     */
+    static _fromProtobuf(accountAmounts: HieroProto.proto.IAccountAmount[]): Transfer[];
+    /**
+     * @internal
+     * @param {object} props
+     * @param {AccountId | string} props.accountId
+     * @param {number | string | Long | BigNumber | Hbar} props.amount
+     * @param {boolean} props.isApproved
+     */
+    constructor(props: {
+        accountId: AccountId | string;
+        amount: number | string | Long | BigNumber | Hbar;
+        isApproved: boolean;
+    });
+    /**
+     * The Account ID that sends or receives cryptocurrency.
+     *
+     * @readonly
+     */
+    readonly accountId: AccountId;
+    /**
+     * The amount of tinybars that the account sends(negative) or receives(positive).
+     */
+    amount: Hbar;
+    isApproved: boolean;
+    /**
+     * @internal
+     * @returns {HieroProto.proto.IAccountAmount}
+     */
+    _toProtobuf(): HieroProto.proto.IAccountAmount;
+    /**
+     * @returns {TransferJSON}
+     */
+    toJSON(): TransferJSON;
+    /**
+     * @returns {string}
+     */
+    toString(): string;
+}
+export type TransferJSON = {
+    accountId: string;
+    amount: string;
+    isApproved: boolean;
+};
+export namespace HieroProto {
+    namespace proto {
+        type IAccountAmount = import("@hashgraph/proto").proto.IAccountAmount;
+        type IAccountID = import("@hashgraph/proto").proto.IAccountID;
+    }
+}
+export type BigNumber = import("bignumber.js").default;
+export type Long = import("long");
+import AccountId from "./account/AccountId.js";
+import Hbar from "./Hbar.js";

package/lib/Transfer.js

@@ -0,0 +1,2 @@
+import t from"./account/AccountId.js";import o from"./Hbar.js";class n{constructor(n){this.accountId=n.accountId instanceof t?n.accountId:t.fromString(n.accountId),this.amount=n.amount instanceof o?n.amount:new o(n.amount),this.isApproved=n.isApproved}static _fromProtobuf(r){const u=[];for(const a of r)u.push(new n({accountId:t._fromProtobuf(a.accountID),amount:o.fromTinybars(null!=a.amount?a.amount:0),isApproved:a.isApproval}));return u}_toProtobuf(){return{accountID:this.accountId._toProtobuf(),amount:this.amount.toTinybars(),isApproval:this.isApproved}}toJSON(){return{accountId:this.accountId.toString(),amount:this.amount.toTinybars().toString(),isApproved:this.isApproved}}toString(){return JSON.stringify(this.toJSON())}}export{n as default};
+//# sourceMappingURL=Transfer.js.map

package/lib/Transfer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Transfer.js","sources":["../src/Transfer.js"],"sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\nimport AccountId from \"./account/AccountId.js\";\nimport Hbar from \"./Hbar.js\";\n\n/**\n * @typedef {object} TransferJSON\n * @property {string} accountId\n * @property {string} amount\n * @property {boolean} isApproved\n */\n\n/**\n * @namespace proto\n * @typedef {import(\"@hashgraph/proto\").proto.IAccountAmount} HieroProto.proto.IAccountAmount\n * @typedef {import(\"@hashgraph/proto\").proto.IAccountID} HieroProto.proto.IAccountID\n */\n\n/**\n * @typedef {import(\"bignumber.js\").default} BigNumber\n * @typedef {import(\"long\")} Long\n */\n\n/**\n * An account, and the amount that it sends or receives during a cryptocurrency transfer.\n */\nexport default class Transfer {\n    /**\n     * @internal\n     * @param {object} props\n     * @param {AccountId | string} props.accountId\n     * @param {number | string | Long | BigNumber | Hbar} props.amount\n     * @param {boolean} props.isApproved\n     */\n    constructor(props) {\n        /**\n         * The Account ID that sends or receives cryptocurrency.\n         *\n         * @readonly\n         */\n        this.accountId =\n            props.accountId instanceof AccountId\n                ? props.accountId\n                : AccountId.fromString(props.accountId);\n\n        /**\n         * The amount of tinybars that the account sends(negative) or receives(positive).\n         */\n        this.amount =\n            props.amount instanceof Hbar\n                ? props.amount\n                : new Hbar(props.amount);\n\n        this.isApproved = props.isApproved;\n    }\n\n    /**\n     * @internal\n     * @param {HieroProto.proto.IAccountAmount[]} accountAmounts\n     * @returns {Transfer[]}\n     */\n    static _fromProtobuf(accountAmounts) {\n        const transfers = [];\n\n        for (const transfer of accountAmounts) {\n            transfers.push(\n                new Transfer({\n                    accountId: AccountId._fromProtobuf(\n                        /** @type {HieroProto.proto.IAccountID} */ (\n                            transfer.accountID\n                        ),\n                    ),\n                    amount: Hbar.fromTinybars(\n                        transfer.amount != null ? transfer.amount : 0,\n                    ),\n                    isApproved: /** @type {boolean} */ (transfer.isApproval),\n                }),\n            );\n        }\n\n        return transfers;\n    }\n\n    /**\n     * @internal\n     * @returns {HieroProto.proto.IAccountAmount}\n     */\n    _toProtobuf() {\n        return {\n            accountID: this.accountId._toProtobuf(),\n            amount: this.amount.toTinybars(),\n            isApproval: this.isApproved,\n        };\n    }\n\n    /**\n     * @returns {TransferJSON}\n     */\n    toJSON() {\n        return {\n            accountId: this.accountId.toString(),\n            amount: this.amount.toTinybars().toString(),\n            isApproved: this.isApproved,\n        };\n    }\n\n    /**\n     * @returns {string}\n     */\n    toString() {\n        return JSON.stringify(this.toJSON());\n    }\n}\n"],"names":["Transfer","constructor","props","this","accountId","AccountId","fromString","amount","Hbar","isApproved","_fromProtobuf","accountAmounts","transfers","transfer","push","fromTinybars","_toProtobuf","accountID","toTinybars","isApproval","toJSON","toString","JSON","stringify"],"mappings":"+DA0Be,MAAMA,EAQjB,WAAAC,CAAYC,GAMRC,KAAKC,UACDF,EAAME,qBAAqBC,EACrBH,EAAME,UACNC,EAAUC,WAAWJ,EAAME,WAKrCD,KAAKI,OACDL,EAAMK,kBAAkBC,EAClBN,EAAMK,OACN,IAAIC,EAAKN,EAAMK,QAEzBJ,KAAKM,WAAaP,EAAMO,UAChC,CAOI,oBAAOC,CAAcC,GACjB,MAAMC,EAAY,GAElB,IAAK,MAAMC,KAAYF,EACnBC,EAAUE,KACN,IAAId,EAAS,CACTI,UAAWC,EAAUK,cAEbG,EAC5B,WAEoBN,OAAQC,EAAKO,aACU,MAAnBF,EAASN,OAAiBM,EAASN,OAAS,GAEhDE,WAAoCI,EAAmB,cAKnE,OAAOD,CACf,CAMI,WAAAI,GACI,MAAO,CACHC,UAAWd,KAAKC,UAAUY,cAC1BT,OAAQJ,KAAKI,OAAOW,aACpBC,WAAYhB,KAAKM,WAE7B,CAKI,MAAAW,GACI,MAAO,CACHhB,UAAWD,KAAKC,UAAUiB,WAC1Bd,OAAQJ,KAAKI,OAAOW,aAAaG,WACjCZ,WAAYN,KAAKM,WAE7B,CAKI,QAAAY,GACI,OAAOC,KAAKC,UAAUpB,KAAKiB,SACnC"}