@hiero-ledger/sdk 2.70.0

package/lib/EntityIdHelper.d.ts

@@ -0,0 +1,203 @@
+/**
+ * This method is called by most entity ID constructors. It's purpose is to
+ * deduplicate the constuctors.
+ *
+ * @param {number | Long | IEntityId} props
+ * @param {(number | null | Long)=} realmOrNull
+ * @param {(number | null | Long)=} numOrNull
+ * @returns {IEntityIdResult}
+ */
+export function constructor(props: number | Long | IEntityId, realmOrNull?: (number | null | Long) | undefined, numOrNull?: (number | null | Long) | undefined): IEntityIdResult;
+/**
+ * A simple comparison function for comparing entity IDs
+ *
+ * @param {[Long, Long, Long]} a
+ * @param {[Long, Long, Long]} b
+ * @returns {number}
+ */
+export function compare(a: [Long, Long, Long], b: [Long, Long, Long]): number;
+/**
+ * This type is part of the entity ID checksums feature which
+ * is responsible for checking if an entity ID was created on
+ * the same ledger ID as the client is currently using.
+ *
+ * @typedef {object} ParseAddressResult
+ * @property {number} status
+ * @property {Long} [num1]
+ * @property {Long} [num2]
+ * @property {Long} [num3]
+ * @property {string} [correctChecksum]
+ * @property {string} [givenChecksum]
+ * @property {string} [noChecksumFormat]
+ * @property {string} [withChecksumFormat]
+ */
+/**
+ * @param {string} text
+ * @returns {IEntityIdParts}
+ */
+export function fromStringSplitter(text: string): IEntityIdParts;
+/**
+ * @param {string} text
+ * @returns {IEntityIdResultWithChecksum}
+ */
+export function fromString(text: string): IEntityIdResultWithChecksum;
+/**
+ * Return the shard, realm, and num from a solidity address.
+ *
+ * Solidity addresses are 20 bytes long and hex encoded, where the first 4
+ * bytes represent the shard, the next 8 bytes represent the realm, and
+ * the last 8 bytes represent the num. All in Big Endian format
+ *
+ * @param {string} address
+ * @returns {[Long, Long, Long]}
+ */
+export function fromSolidityAddress(address: string): [Long, Long, Long];
+/**
+ * Parse an EVM address and return shard, realm, entity num, and optional EVM address.
+ *
+ * For long zero addresses (first 12 bytes are zeros): returns [shard, realm, entityNum, null]
+ * For regular EVM addresses: returns [shard, realm, 0, EvmAddress]
+ *
+ * @param {Long | number} shard - The shard number to use
+ * @param {Long | number} realm - The realm number to use
+ * @param {string} address - The EVM address to parse (with or without 0x prefix)
+ * @returns {[Long, Long, Long, EvmAddress | null]} - [shard, realm, entityNum, evmAddressOrNull]
+ */
+export function fromEvmAddress(shard: Long | number, realm: Long | number, address: string): [Long, Long, Long, EvmAddress | null];
+/**
+ * Convert shard, realm, and num into a solidity address.
+ *
+ * See `fromSolidityAddress()` for more documentation.
+ *
+ * @param {[Long,Long,Long] | [number,number,number]} address
+ * @returns {string}
+ */
+export function toSolidityAddress(address: [Long, Long, Long] | [number, number, number]): string;
+/**
+ * @overload
+ * @param {Uint8Array} evmAddressBytes - EVM address bytes to convert to hex
+ * @returns {string}
+ */
+export function toEvmAddress(evmAddressBytes: Uint8Array): string;
+/**
+ * @overload
+ * @param {Long} accountNum - Account number to convert to long-zero EVM address
+ * @returns {string}
+ */
+export function toEvmAddress(accountNum: Long): string;
+/**
+ * Parse the address string addr and return an object with the results (8 fields).
+ * The first four fields are numbers, which could be implemented as signed 32 bit
+ * integers, and the last four are strings.
+ *
+ *   status;  //the status of the parsed address
+ *            //   0 = syntax error
+ *            //   1 = an invalid with-checksum address (bad checksum)
+ *            //   2 = a valid no-checksum address
+ *            //   3 = a valid with-checksum address
+ *   num1;    //the 3 numbers in the address, such as 1.2.3, with leading zeros removed
+ *   num2;
+ *   num3;
+ *   correctchecksum;    //the correct checksum
+ *   givenChecksum;      //the checksum in the address that was parsed
+ *   noChecksumFormat;   //the address in no-checksum format
+ *   withChecksumFormat; //the address in with-checksum format
+ *
+ * @param {Uint8Array} ledgerId
+ * @param {string} addr
+ * @returns {ParseAddressResult}
+ */
+export function _parseAddress(ledgerId: Uint8Array, addr: string): ParseAddressResult;
+/**
+ * Given an address like "0.0.123", return a checksum like "laujm"
+ *
+ * @param {Uint8Array} ledgerId
+ * @param {string} addr
+ * @returns {string}
+ */
+export function _checksum(ledgerId: Uint8Array, addr: string): string;
+/**
+ * Validate an entity ID checksum against a client
+ *
+ * @param {Long} shard
+ * @param {Long} realm
+ * @param {Long} num
+ * @param {string | null} checksum
+ * @param {Client} client
+ */
+export function validateChecksum(shard: Long, realm: Long, num: Long, checksum: string | null, client: Client): void;
+/**
+ * Stringify the entity ID with a checksum.
+ *
+ * @param {string} string
+ * @param {Client} client
+ * @returns {string}
+ */
+export function toStringWithChecksum(string: string, client: Client): string;
+/**
+ * Deserialize the alias to public key.
+ * Alias is created from ed25519 or ECDSASecp256k1 types of accounts. If hollow account is used, the alias is created from evm address.
+ * For hollow accounts, please use aliasToEvmAddress.
+ *
+ * @param {string} alias
+ * @returns {PublicKey | null}
+ */
+export function aliasToPublicKey(alias: string): PublicKey | null;
+/**
+ * Deserialize the alias to evm address.
+ * Alias is created from hollow account.
+ * For ed25519 or ECDSASecp256k1 accounts, please use aliasToPublicKey.
+ *
+ * @param {string} alias
+ * @returns {string | null}
+ */
+export function aliasToEvmAddress(alias: string): string | null;
+/**
+ * Serialize the public key to alias.
+ * Alias is created from ed25519 or ECDSASecp256k1 types of accounts. If hollow account is used, the alias is created from evm address.
+ *
+ * @param {string | PublicKey} publicKey
+ * @returns {string | null}
+ */
+export function publicKeyToAlias(publicKey: string | PublicKey): string | null;
+/**
+ * This type is part of the entity ID checksums feature which
+ * is responsible for checking if an entity ID was created on
+ * the same ledger ID as the client is currently using.
+ */
+export type ParseAddressResult = {
+    status: number;
+    num1?: Long | undefined;
+    num2?: Long | undefined;
+    num3?: Long | undefined;
+    correctChecksum?: string | undefined;
+    givenChecksum?: string | undefined;
+    noChecksumFormat?: string | undefined;
+    withChecksumFormat?: string | undefined;
+};
+export type Client = import("./client/Client.js").default<any, any>;
+export type IEntityId = {
+    num: number | Long;
+    shard?: (number | Long) | undefined;
+    realm?: (number | Long) | undefined;
+};
+export type IEntityIdResult = {
+    shard: Long;
+    realm: Long;
+    num: Long;
+};
+export type IEntityIdParts = {
+    shard: string | null;
+    realm: string | null;
+    numOrHex: string;
+    checksum: string | null;
+};
+export type IEntityIdResultWithChecksum = {
+    shard: Long;
+    realm: Long;
+    num: Long;
+    checksum: string | null;
+};
+import Long from "long";
+import EvmAddress from "./EvmAddress.js";
+import PublicKey from "./PublicKey.js";

package/lib/EntityIdHelper.js

@@ -0,0 +1,2 @@
+import e from"long";import{isHexString as r,decode as t,encode as n}from"./encoding/hex.js";import o from"./BadEntityIdError.js";import{isLongZeroAddress as l,safeView as i,convertToNumber as s}from"./util.js";import a from"./base32.js";import*as u from"@hashgraph/proto";import c from"./PublicKey.js";import{arrayify as m}from"@ethersproject/bytes";import f from"./EvmAddress.js";const h=/"^(0|(?:[1-9]\\d*))\\.(0|(?:[1-9]\\d*))\\.(0|(?:[1-9]\\d*))(?:-([a-z]{5}))?$/,d=/^(\d+)(?:\.(\d+)\.([a-fA-F0-9]+))?(?:-([a-z]{5}))?$/;function g(r,t,n){if(null==t&&null!=n||null!=t&&null==n)throw new Error("invalid entity ID");const[o,l,i]="number"==typeof r||e.isLong(r)?[null!=n?e.fromValue(r):e.ZERO,null!=t?e.fromValue(t):e.ZERO,null!=n?e.fromValue(n):e.fromValue(r)]:[null!=r.shard?e.fromValue(r.shard):e.ZERO,null!=r.realm?e.fromValue(r.realm):e.ZERO,e.fromValue(r.num)];if(o.isNegative()||l.isNegative()||i.isNegative())throw new Error("negative numbers are not allowed in IDs");return{shard:o,realm:l,num:i}}function w(e,r){let t=e[0].compare(r[0]);return 0!=t?t:(t=e[1].compare(r[1]),0!=t?t:e[2].compare(r[2]))}function y(e){const r=d.exec(e);if(null==r)throw new Error(`failed to parse entity id: ${e}`);return null==r[2]&&null==r[3]?{shard:"0",realm:"0",numOrHex:r[1],checksum:r[4]}:{shard:r[1],realm:r[2],numOrHex:r[3],checksum:r[4]}}function p(r){const t=y(r);if(Number.isNaN(t.shard)||Number.isNaN(t.realm)||Number.isNaN(t.numOrHex))throw new Error("invalid format for entity ID");return{shard:null!=t.shard?e.fromString(t.shard):e.ZERO,realm:null!=t.realm?e.fromString(t.realm):e.ZERO,num:e.fromString(t.numOrHex),checksum:t.checksum}}function E(r){const n=r.startsWith("0x")?t(r.slice(2)):t(r);if(20!==n.length)throw new Error(`Invalid hex encoded solidity address length:\n                expected length 40, got length ${r.length}`);return[e.fromBytesBE([0,0,0,0,...n.slice(0,4)]),e.fromBytesBE(Array.from(n.slice(4,12))),e.fromBytesBE(Array.from(n.slice(12,20)))]}function S(n,o,i){if(!r(i))throw new Error(`Invalid EVM address hex string: ${i}`);const s=i.startsWith("0x")?t(i.slice(2)):t(i);if(20!==s.length)throw new Error(`Invalid hex encoded evm address length:\n                expected length 20, got length ${i.length}`);let a=e.ZERO;return l(s)&&(a=e.fromBytesBE(Array.from(s.slice(12,20)))),[n instanceof e?n:e.fromNumber(n),o instanceof e?o:e.fromNumber(o),a,a.isZero()?f.fromBytes(s):null]}function x(e){const r=new Uint8Array(20),t=i(r),[o,l,a]=e;return t.setUint32(0,s(o)),t.setUint32(8,s(l)),t.setUint32(16,s(a)),n(r)}function k(e){if(e instanceof Uint8Array)return n(e);const r=e,t=new Uint8Array(20);return i(t).setUint32(16,s(r)),n(t)}function A(r,t){let n=h.exec(t);if(null===n){return{status:0}}let o=[e.fromString(n[1]),e.fromString(n[2]),e.fromString(n[3])],l=`${o[0].toString()}.${o[1].toString()}.${o[2].toString()}`,i=$(r,l);return{status:void 0===n[4]?2:i==n[4]?3:1,num1:o[0],num2:o[1],num3:o[2],givenChecksum:n[4],correctChecksum:i,noChecksumFormat:l,withChecksumFormat:`${l}-${i}`}}function $(e,r){let t="",n=[],o=0,l=0,i=0,s=0,a=0;const u=11881376,c="a".charCodeAt(0);let m=new Uint8Array(e.length+6);m.set(e,0),m.set([0,0,0,0,0,0],e.length);for(let e=0;e<r.length;e++)n.push("."===r[e]?10:parseInt(r[e],10));for(let e=0;e<n.length;e++)i=(31*i+n[e])%17576,e%2==0?o=(o+n[e])%11:l=(l+n[e])%11;for(let e=0;e<m.length;e++)s=(31*s+m[e])%u;a=(17576*(11*(r.length%5*11+o)+l)+i+s)%u,a=1000003*a%u;for(let e=0;e<5;e++)t=String.fromCharCode(c+a%26)+t,a/=26;return t}function b(e,r,t,n,l){if(null==l._network._ledgerId||null==n)return;const i=$(l._network._ledgerId._ledgerId,`${e.toString()}.${r.toString()}.${t.toString()}`);if(n!=i)throw new o(e,r,t,n,i)}function v(e,r){if(null==r)throw new Error("client cannot be null");if(null==r._network._ledgerId)throw new Error("cannot calculate checksum with a client that does not contain a recognzied ledger ID");return`${e}-${$(r._network._ledgerId._ledgerId,e)}`}function I(e){const r=a.decode(e);if(!r)return null;let t;try{t=u.proto.Key.decode(r)}catch(e){throw new Error("The alias is created with hollow account. Please use aliasToEvmAddress!")}return null!=t.ed25519&&t.ed25519.byteLength>0?c.fromBytes(t.ed25519):null!=t.ECDSASecp256k1&&t.ECDSASecp256k1.byteLength>0?c.fromBytes(t.ECDSASecp256k1):null}function N(e){const r=a.decode(e);if(!r)return null;try{throw u.proto.Key.decode(r),new Error("The alias is created with ed25519 or ECDSASecp256k1 account. Please use aliasToPublicKey!")}catch(e){return function(e){var r="0x";return e.forEach((function(e){r+=("0"+(255&e).toString(16)).slice(-2)})),r}(r)}}function _(e){if("string"==typeof e&&(e.startsWith("0x")&&42==e.length||40==e.length)){e.startsWith("0x")||(e=`0x${e}`);const r=m(e);return r?a.encode(r):null}const r="string"==typeof e?c.fromString(e):e;let t=r.toStringRaw(),n="";"secp256k1"===r._key._type&&(n="0x3A21"),"ED25519"===r._key._type&&(n="0x1220"),t.startsWith("0x")||(t=`0x${t}`);const o=m(n),l=m(t),i=(s=o,u=l,(f=new Uint8Array(s.byteLength+u.byteLength)).set(new Uint8Array(s),0),f.set(new Uint8Array(u),s.byteLength),f);var s,u,f;return a.encode(i)}export{$ as _checksum,A as _parseAddress,N as aliasToEvmAddress,I as aliasToPublicKey,w as compare,g as constructor,S as fromEvmAddress,E as fromSolidityAddress,p as fromString,y as fromStringSplitter,_ as publicKeyToAlias,k as toEvmAddress,x as toSolidityAddress,v as toStringWithChecksum,b as validateChecksum};
+//# sourceMappingURL=EntityIdHelper.js.map

package/lib/EntityIdHelper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityIdHelper.js","sources":["../src/EntityIdHelper.js"],"sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\nimport Long from \"long\";\nimport * as hex from \"./encoding/hex.js\";\nimport BadEntityIdError from \"./BadEntityIdError.js\";\nimport * as util from \"./util.js\";\nimport base32 from \"./base32.js\";\nimport * as HieroProto from \"@hashgraph/proto\";\nimport PublicKey from \"./PublicKey.js\";\nimport { arrayify } from \"@ethersproject/bytes\";\nimport EvmAddress from \"./EvmAddress.js\";\n\n/**\n * @typedef {import(\"./client/Client.js\").default<*, *>} Client\n */\n\n/**\n * @typedef {object} IEntityId\n * @property {number | Long} num\n * @property {(number | Long)=} shard\n * @property {(number | Long)=} realm\n */\n\n/**\n * @typedef {object} IEntityIdResult\n * @property {Long} shard\n * @property {Long} realm\n * @property {Long} num\n */\n\n/**\n * @typedef {object} IEntityIdParts\n * @property {string?} shard\n * @property {string?} realm\n * @property {string} numOrHex\n * @property {string?} checksum\n */\n\n/**\n * @typedef {object} IEntityIdResultWithChecksum\n * @property {Long} shard\n * @property {Long} realm\n * @property {Long} num\n * @property {string | null} checksum\n */\n\nconst regex =\n    /\"^(0|(?:[1-9]\\\\d*))\\\\.(0|(?:[1-9]\\\\d*))\\\\.(0|(?:[1-9]\\\\d*))(?:-([a-z]{5}))?$/;\n\n/**\n * This regex supports entity IDs\n *  - as stand alone nubmers\n *  - as shard.realm.num\n *  - as shard.realm.hex\n *  - can optionally provide checksum for any of the above\n */\nconst ENTITY_ID_REGEX = /^(\\d+)(?:\\.(\\d+)\\.([a-fA-F0-9]+))?(?:-([a-z]{5}))?$/;\n\n/**\n * @description The length of an EVM address in bytes.\n */\nconst EVM_ADDRESS_LENGTH = 20;\n\n/**\n * @description The length of the long-zero prefix in bytes.\n */\nconst LONG_ZERO_PREFIX_LENGTH = 12;\n\n/**\n * @description The offset of the entity number in the EVM address.\n */\nconst ENTITY_NUM_OFFSET = 16;\n\n/**\n * This method is called by most entity ID constructors. It's purpose is to\n * deduplicate the constuctors.\n *\n * @param {number | Long | IEntityId} props\n * @param {(number | null | Long)=} realmOrNull\n * @param {(number | null | Long)=} numOrNull\n * @returns {IEntityIdResult}\n */\nexport function constructor(props, realmOrNull, numOrNull) {\n    // Make sure either both the second and third parameter are\n    // set or not set; we shouldn't have one set, but the other not set.\n    //\n    //NOSONAR\n    if (\n        (realmOrNull == null && numOrNull != null) ||\n        (realmOrNull != null && numOrNull == null)\n    ) {\n        throw new Error(\"invalid entity ID\");\n    }\n\n    // If the first parameter is a number then we need to convert the\n    // first, second, and third parameters into numbers. Otherwise,\n    // we should look at the fields `shard`, `realm`, and `num` on\n    // `props`\n    const [shard, realm, num] =\n        typeof props === \"number\" || Long.isLong(props)\n            ? [\n                  numOrNull != null\n                      ? Long.fromValue(/** @type {Long | number} */ (props))\n                      : Long.ZERO,\n                  realmOrNull != null ? Long.fromValue(realmOrNull) : Long.ZERO,\n                  numOrNull != null\n                      ? Long.fromValue(numOrNull)\n                      : Long.fromValue(/** @type {Long | number} */ (props)),\n              ]\n            : [\n                  props.shard != null ? Long.fromValue(props.shard) : Long.ZERO,\n                  props.realm != null ? Long.fromValue(props.realm) : Long.ZERO,\n                  Long.fromValue(props.num),\n              ];\n\n    // Make sure none of the numbers are negative\n    if (shard.isNegative() || realm.isNegative() || num.isNegative()) {\n        throw new Error(\"negative numbers are not allowed in IDs\");\n    }\n\n    return {\n        shard,\n        realm,\n        num,\n    };\n}\n\n/**\n * A simple comparison function for comparing entity IDs\n *\n * @param {[Long, Long, Long]} a\n * @param {[Long, Long, Long]} b\n * @returns {number}\n */\nexport function compare(a, b) {\n    let comparison = a[0].compare(b[0]);\n    if (comparison != 0) {\n        return comparison;\n    }\n\n    comparison = a[1].compare(b[1]);\n    if (comparison != 0) {\n        return comparison;\n    }\n\n    return a[2].compare(b[2]);\n}\n\n/**\n * This type is part of the entity ID checksums feature which\n * is responsible for checking if an entity ID was created on\n * the same ledger ID as the client is currently using.\n *\n * @typedef {object} ParseAddressResult\n * @property {number} status\n * @property {Long} [num1]\n * @property {Long} [num2]\n * @property {Long} [num3]\n * @property {string} [correctChecksum]\n * @property {string} [givenChecksum]\n * @property {string} [noChecksumFormat]\n * @property {string} [withChecksumFormat]\n */\n\n/**\n * @param {string} text\n * @returns {IEntityIdParts}\n */\nexport function fromStringSplitter(text) {\n    const match = ENTITY_ID_REGEX.exec(text);\n\n    if (match == null) {\n        throw new Error(`failed to parse entity id: ${text}`);\n    }\n\n    if (match[2] == null && match[3] == null) {\n        return {\n            shard: \"0\",\n            realm: \"0\",\n            numOrHex: match[1],\n            checksum: match[4],\n        };\n    } else {\n        return {\n            shard: match[1],\n            realm: match[2],\n            numOrHex: match[3],\n            checksum: match[4],\n        };\n    }\n}\n\n/**\n * @param {string} text\n * @returns {IEntityIdResultWithChecksum}\n */\nexport function fromString(text) {\n    const result = fromStringSplitter(text);\n\n    if (\n        Number.isNaN(result.shard) ||\n        Number.isNaN(result.realm) ||\n        Number.isNaN(result.numOrHex)\n    ) {\n        throw new Error(\"invalid format for entity ID\");\n    }\n\n    return {\n        shard: result.shard != null ? Long.fromString(result.shard) : Long.ZERO,\n        realm: result.realm != null ? Long.fromString(result.realm) : Long.ZERO,\n        num: Long.fromString(result.numOrHex),\n        checksum: result.checksum,\n    };\n}\n\n/**\n * Return the shard, realm, and num from a solidity address.\n *\n * Solidity addresses are 20 bytes long and hex encoded, where the first 4\n * bytes represent the shard, the next 8 bytes represent the realm, and\n * the last 8 bytes represent the num. All in Big Endian format\n *\n * @param {string} address\n * @returns {[Long, Long, Long]}\n */\nexport function fromSolidityAddress(address) {\n    const addr = address.startsWith(\"0x\")\n        ? hex.decode(address.slice(2))\n        : hex.decode(address);\n\n    if (addr.length !== EVM_ADDRESS_LENGTH) {\n        throw new Error(`Invalid hex encoded solidity address length:\n                expected length 40, got length ${address.length}`);\n    }\n\n    const shard = Long.fromBytesBE([0, 0, 0, 0, ...addr.slice(0, 4)]);\n    const realm = Long.fromBytesBE(Array.from(addr.slice(4, 12)));\n    const num = Long.fromBytesBE(Array.from(addr.slice(12, 20)));\n\n    return [shard, realm, num];\n}\n\n/**\n * Parse an EVM address and return shard, realm, entity num, and optional EVM address.\n *\n * For long zero addresses (first 12 bytes are zeros): returns [shard, realm, entityNum, null]\n * For regular EVM addresses: returns [shard, realm, 0, EvmAddress]\n *\n * @param {Long | number} shard - The shard number to use\n * @param {Long | number} realm - The realm number to use\n * @param {string} address - The EVM address to parse (with or without 0x prefix)\n * @returns {[Long, Long, Long, EvmAddress | null]} - [shard, realm, entityNum, evmAddressOrNull]\n */\nexport function fromEvmAddress(shard, realm, address) {\n    if (!hex.isHexString(address)) {\n        throw new Error(`Invalid EVM address hex string: ${address}`);\n    }\n\n    const addr = address.startsWith(\"0x\")\n        ? hex.decode(address.slice(2))\n        : hex.decode(address);\n\n    if (addr.length !== EVM_ADDRESS_LENGTH) {\n        throw new Error(`Invalid hex encoded evm address length:\n                expected length ${EVM_ADDRESS_LENGTH}, got length ${address.length}`);\n    }\n\n    let num = Long.ZERO;\n\n    if (util.isLongZeroAddress(addr)) {\n        num = Long.fromBytesBE(\n            Array.from(addr.slice(LONG_ZERO_PREFIX_LENGTH, EVM_ADDRESS_LENGTH)),\n        );\n    }\n\n    let shardLong = shard instanceof Long ? shard : Long.fromNumber(shard);\n    let realmLong = realm instanceof Long ? realm : Long.fromNumber(realm);\n\n    return [\n        shardLong,\n        realmLong,\n        num,\n        num.isZero() ? EvmAddress.fromBytes(addr) : null,\n    ];\n}\n\n/**\n * Convert shard, realm, and num into a solidity address.\n *\n * See `fromSolidityAddress()` for more documentation.\n *\n * @param {[Long,Long,Long] | [number,number,number]} address\n * @returns {string}\n */\nexport function toSolidityAddress(address) {\n    const buffer = new Uint8Array(20);\n    const view = util.safeView(buffer);\n    const [shard, realm, num] = address;\n\n    view.setUint32(0, util.convertToNumber(shard));\n    view.setUint32(8, util.convertToNumber(realm));\n    view.setUint32(16, util.convertToNumber(num));\n\n    return hex.encode(buffer);\n}\n\n/**\n * @overload\n * @param {Uint8Array} evmAddressBytes - EVM address bytes to convert to hex\n * @returns {string}\n */\n\n/**\n * @overload\n * @param {Long} accountNum - Account number to convert to long-zero EVM address\n * @returns {string}\n */\n\n/**\n * Convert EVM address bytes to hex string or account num to long-zero EVM address.\n *\n * @param {Uint8Array | Long} evmAddressBytesOrAccountNum\n * @returns {string}\n */\nexport function toEvmAddress(evmAddressBytesOrAccountNum) {\n    if (evmAddressBytesOrAccountNum instanceof Uint8Array) {\n        return hex.encode(evmAddressBytesOrAccountNum);\n    }\n\n    const accountNum = evmAddressBytesOrAccountNum;\n    const buffer = new Uint8Array(EVM_ADDRESS_LENGTH);\n    const view = util.safeView(buffer);\n\n    view.setUint32(ENTITY_NUM_OFFSET, util.convertToNumber(accountNum));\n\n    return hex.encode(buffer);\n}\n\n/**\n * Parse the address string addr and return an object with the results (8 fields).\n * The first four fields are numbers, which could be implemented as signed 32 bit\n * integers, and the last four are strings.\n *\n *   status;  //the status of the parsed address\n *            //   0 = syntax error\n *            //   1 = an invalid with-checksum address (bad checksum)\n *            //   2 = a valid no-checksum address\n *            //   3 = a valid with-checksum address\n *   num1;    //the 3 numbers in the address, such as 1.2.3, with leading zeros removed\n *   num2;\n *   num3;\n *   correctchecksum;    //the correct checksum\n *   givenChecksum;      //the checksum in the address that was parsed\n *   noChecksumFormat;   //the address in no-checksum format\n *   withChecksumFormat; //the address in with-checksum format\n *\n * @param {Uint8Array} ledgerId\n * @param {string} addr\n * @returns {ParseAddressResult}\n */\nexport function _parseAddress(ledgerId, addr) {\n    let match = regex.exec(addr);\n    if (match === null) {\n        let result = { status: 0 }; // When status == 0, the rest of the fields should be ignored\n        return result;\n    }\n    let a = [\n        Long.fromString(match[1]),\n        Long.fromString(match[2]),\n        Long.fromString(match[3]),\n    ];\n    let ad = `${a[0].toString()}.${a[1].toString()}.${a[2].toString()}`;\n    let c = _checksum(ledgerId, ad);\n    let s = match[4] === undefined ? 2 : c == match[4] ? 3 : 1; //NOSONAR\n    return {\n        status: s,\n        num1: a[0],\n        num2: a[1],\n        num3: a[2],\n        givenChecksum: match[4],\n        correctChecksum: c,\n        noChecksumFormat: ad,\n        withChecksumFormat: `${ad}-${c}`,\n    };\n}\n\n/**\n * Given an address like \"0.0.123\", return a checksum like \"laujm\"\n *\n * @param {Uint8Array} ledgerId\n * @param {string} addr\n * @returns {string}\n */\nexport function _checksum(ledgerId, addr) {\n    let answer = \"\";\n    let d = []; // Digits with 10 for \".\", so if addr == \"0.0.123\" then d == [0, 10, 0, 10, 1, 2, 3]\n    let s0 = 0; // Sum of even positions (mod 11)\n    let s1 = 0; // Sum of odd positions (mod 11)\n    let s = 0; // Weighted sum of all positions (mod p3)\n    let sh = 0; // Hash of the ledger ID\n    let c = 0; // The checksum, as a single number\n    const p3 = 26 * 26 * 26; // 3 digits in base 26\n    const p5 = 26 * 26 * 26 * 26 * 26; // 5 digits in base 26\n    const ascii_a = \"a\".charCodeAt(0); // 97\n    const m = 1000003; // Min prime greater than a million. Used for the final permutation.\n    const w = 31; // Sum s of digit values weights them by powers of w. Should be coprime to p5.\n\n    let h = new Uint8Array(ledgerId.length + 6);\n    h.set(ledgerId, 0);\n    h.set([0, 0, 0, 0, 0, 0], ledgerId.length);\n    for (let i = 0; i < addr.length; i++) {\n        //NOSONAR\n        d.push(addr[i] === \".\" ? 10 : parseInt(addr[i], 10));\n    }\n    for (let i = 0; i < d.length; i++) {\n        s = (w * s + d[i]) % p3;\n        if (i % 2 === 0) {\n            s0 = (s0 + d[i]) % 11;\n        } else {\n            s1 = (s1 + d[i]) % 11;\n        }\n    }\n    for (let i = 0; i < h.length; i++) {\n        sh = (w * sh + h[i]) % p5;\n    }\n    c = ((((addr.length % 5) * 11 + s0) * 11 + s1) * p3 + s + sh) % p5;\n    c = (c * m) % p5;\n\n    for (let i = 0; i < 5; i++) {\n        answer = String.fromCharCode(ascii_a + (c % 26)) + answer;\n        c /= 26;\n    }\n\n    return answer;\n}\n\n/**\n * Validate an entity ID checksum against a client\n *\n * @param {Long} shard\n * @param {Long} realm\n * @param {Long} num\n * @param {string | null} checksum\n * @param {Client} client\n */\nexport function validateChecksum(shard, realm, num, checksum, client) {\n    if (client._network._ledgerId == null || checksum == null) {\n        return;\n    }\n\n    const expectedChecksum = _checksum(\n        client._network._ledgerId._ledgerId,\n        `${shard.toString()}.${realm.toString()}.${num.toString()}`,\n    );\n\n    if (checksum != expectedChecksum) {\n        throw new BadEntityIdError(\n            shard,\n            realm,\n            num,\n            checksum,\n            expectedChecksum,\n        );\n    }\n}\n\n/**\n * Stringify the entity ID with a checksum.\n *\n * @param {string} string\n * @param {Client} client\n * @returns {string}\n */\nexport function toStringWithChecksum(string, client) {\n    if (client == null) {\n        throw new Error(\"client cannot be null\");\n    }\n\n    if (client._network._ledgerId == null) {\n        throw new Error(\n            \"cannot calculate checksum with a client that does not contain a recognzied ledger ID\",\n        );\n    }\n\n    const checksum = _checksum(client._network._ledgerId._ledgerId, string);\n\n    return `${string}-${checksum}`;\n}\n\n/**\n * Append Buffers.\n * @param {Uint8Array} buffer1\n * @param {Uint8Array} buffer2\n * @returns {Uint8Array}\n */\nfunction appendBuffer(buffer1, buffer2) {\n    var tmp = new Uint8Array(buffer1.byteLength + buffer2.byteLength);\n    tmp.set(new Uint8Array(buffer1), 0);\n    tmp.set(new Uint8Array(buffer2), buffer1.byteLength);\n    return tmp;\n}\n\n/**\n * Convert bytes to hex string.\n * @param {Uint8Array} bytes\n * @returns {string}\n */\nfunction toHexString(bytes) {\n    var s = \"0x\";\n    bytes.forEach(function (byte) {\n        s += (\"0\" + (byte & 0xff).toString(16)).slice(-2);\n    });\n    return s;\n}\n\n/**\n * Deserialize the alias to public key.\n * Alias is created from ed25519 or ECDSASecp256k1 types of accounts. If hollow account is used, the alias is created from evm address.\n * For hollow accounts, please use aliasToEvmAddress.\n *\n * @param {string} alias\n * @returns {PublicKey | null}\n */\nexport function aliasToPublicKey(alias) {\n    const bytes = base32.decode(alias);\n    if (!bytes) {\n        return null;\n    }\n    let key;\n    try {\n        key = HieroProto.proto.Key.decode(bytes);\n    } catch (e) {\n        throw new Error(\n            \"The alias is created with hollow account. Please use aliasToEvmAddress!\",\n        );\n    }\n\n    if (key.ed25519 != null && key.ed25519.byteLength > 0) {\n        return PublicKey.fromBytes(key.ed25519);\n    }\n\n    if (key.ECDSASecp256k1 != null && key.ECDSASecp256k1.byteLength > 0) {\n        return PublicKey.fromBytes(key.ECDSASecp256k1);\n    }\n\n    return null;\n}\n\n/**\n * Deserialize the alias to evm address.\n * Alias is created from hollow account.\n * For ed25519 or ECDSASecp256k1 accounts, please use aliasToPublicKey.\n *\n * @param {string} alias\n * @returns {string | null}\n */\nexport function aliasToEvmAddress(alias) {\n    const bytes = base32.decode(alias);\n    if (!bytes) {\n        return null;\n    }\n    try {\n        HieroProto.proto.Key.decode(bytes);\n        throw new Error(\n            \"The alias is created with ed25519 or ECDSASecp256k1 account. Please use aliasToPublicKey!\",\n        );\n    } catch (e) {\n        return toHexString(bytes);\n    }\n}\n\n/**\n * Serialize the public key to alias.\n * Alias is created from ed25519 or ECDSASecp256k1 types of accounts. If hollow account is used, the alias is created from evm address.\n *\n * @param {string | PublicKey} publicKey\n * @returns {string | null}\n */\nexport function publicKeyToAlias(publicKey) {\n    if (\n        typeof publicKey === \"string\" &&\n        ((publicKey.startsWith(\"0x\") && publicKey.length == 42) ||\n            publicKey.length == 40)\n    ) {\n        if (!publicKey.startsWith(\"0x\")) {\n            publicKey = `0x${publicKey}`;\n        }\n\n        const bytes = arrayify(publicKey);\n        if (!bytes) {\n            return null;\n        }\n        return base32.encode(bytes);\n    }\n\n    const publicKeyRaw =\n        typeof publicKey === \"string\"\n            ? PublicKey.fromString(publicKey)\n            : publicKey;\n    let publicKeyHex = publicKeyRaw.toStringRaw();\n    let leadingHex = \"\";\n\n    if (publicKeyRaw._key._type === \"secp256k1\") {\n        leadingHex = \"0x3A21\"; // LEADING BYTES FROM PROTOBUFS\n    }\n\n    if (publicKeyRaw._key._type === \"ED25519\") {\n        leadingHex = \"0x1220\"; // LEADING BYTES FROM PROTOBUFS\n    }\n\n    if (!publicKeyHex.startsWith(\"0x\")) {\n        publicKeyHex = `0x${publicKeyHex}`;\n    }\n\n    const leadingBytes = arrayify(leadingHex);\n    const publicKeyBytes = arrayify(publicKeyHex);\n    const publicKeyInBytes = appendBuffer(leadingBytes, publicKeyBytes);\n    const alias = base32.encode(publicKeyInBytes);\n    return alias;\n}\n"],"names":["regex","ENTITY_ID_REGEX","constructor","props","realmOrNull","numOrNull","Error","shard","realm","num","Long","isLong","fromValue","ZERO","isNegative","compare","a","b","comparison","fromStringSplitter","text","match","exec","numOrHex","checksum","fromString","result","Number","isNaN","fromSolidityAddress","address","addr","startsWith","hex.decode","slice","length","fromBytesBE","Array","from","fromEvmAddress","hex.isHexString","util.isLongZeroAddress","fromNumber","isZero","EvmAddress","fromBytes","toSolidityAddress","buffer","Uint8Array","view","util.safeView","setUint32","util.convertToNumber","hex.encode","toEvmAddress","evmAddressBytesOrAccountNum","accountNum","_parseAddress","ledgerId","status","ad","toString","c","_checksum","undefined","num1","num2","num3","givenChecksum","correctChecksum","noChecksumFormat","withChecksumFormat","answer","d","s0","s1","s","sh","p5","ascii_a","charCodeAt","h","set","i","push","parseInt","String","fromCharCode","validateChecksum","client","_network","_ledgerId","expectedChecksum","BadEntityIdError","toStringWithChecksum","string","aliasToPublicKey","alias","bytes","base32","decode","key","HieroProto","proto","Key","e","ed25519","byteLength","PublicKey","ECDSASecp256k1","aliasToEvmAddress","forEach","byte","toHexString","publicKeyToAlias","publicKey","arrayify","encode","publicKeyRaw","publicKeyHex","toStringRaw","leadingHex","_key","_type","leadingBytes","publicKeyBytes","publicKeyInBytes","buffer1","buffer2","tmp"],"mappings":"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"}

package/lib/EthereumFlow.cjs

@@ -0,0 +1,207 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Hbar = _interopRequireDefault(require("./Hbar.cjs"));
+var _EthereumTransaction = _interopRequireDefault(require("./EthereumTransaction.cjs"));
+var _EthereumTransactionData = _interopRequireDefault(require("./EthereumTransactionData.cjs"));
+var _FileCreateTransaction = _interopRequireDefault(require("./file/FileCreateTransaction.cjs"));
+var _FileAppendTransaction = _interopRequireDefault(require("./file/FileAppendTransaction.cjs"));
+var hex = _interopRequireWildcard(require("./encoding/hex.cjs"));
+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; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @namespace proto
+ * @typedef {import("@hashgraph/proto").proto.ITransaction} HieroProto.proto.ITransaction
+ * @typedef {import("@hashgraph/proto").proto.ISignedTransaction} HieroProto.proto.ISignedTransaction
+ * @typedef {import("@hashgraph/proto").proto.TransactionBody} HieroProto.proto.TransactionBody
+ * @typedef {import("@hashgraph/proto").proto.ITransactionBody} HieroProto.proto.ITransactionBody
+ * @typedef {import("@hashgraph/proto").proto.ITransactionResponse} HieroProto.proto.ITransactionResponse
+ * @typedef {import("@hashgraph/proto").proto.IEthereumTransactionBody} HieroProto.proto.IEthereumTransactionBody
+ * @typedef {import("@hashgraph/proto").proto.IAccountID} HieroProto.proto.IAccountID
+ */
+
+/**
+ * @typedef {import("bignumber.js").default} BigNumber
+ * @typedef {import("./account/AccountId.js").default} AccountId
+ * @typedef {import("./file/FileId.js").default} FileId
+ * @typedef {import("./channel/Channel.js").default} Channel
+ * @typedef {import("./channel/MirrorChannel.js").default} MirrorChannel
+ * @typedef {import("./client/Client.js").default<*, *>} Client
+ * @typedef {import("./Timestamp.js").default} Timestamp
+ * @typedef {import("./transaction/TransactionId.js").default} TransactionId
+ * @typedef {import("./transaction/TransactionResponse.js").default} TransactionResponse
+ * @typedef {import("long")} Long
+ */
+
+/**
+ * Create a new Hedera™ transaction wrapped ethereum transaction.
+ * @deprecated - use EthereumTransaction instead. With the introduction of jumbo transactions, it should always be less cost and more efficient to use EthereumTransaction instead.
+ */
+class EthereumFlow {
+  /**
+   * @param {object} [props]
+   * @param {Uint8Array} [props.ethereumData]
+   * @param {FileId} [props.callData]
+   * @param {number | string | Long | BigNumber | Hbar} [props.maxGasAllowance]
+   */
+  constructor(props = {}) {
+    /**
+     * @private
+     * @type {?EthereumTransactionData}
+     */
+    this._ethereumData = null;
+
+    /**
+     * @private
+     * @type {?FileId}
+     */
+    this._callDataFileId = null;
+
+    /**
+     * @private
+     * @type {?Hbar}
+     */
+    this._maxGasAllowance = null;
+    if (props.ethereumData != null) {
+      this.setEthereumData(props.ethereumData);
+    }
+    if (props.maxGasAllowance != null) {
+      this.setMaxGasAllowanceHbar(props.maxGasAllowance);
+    }
+    this._maxChunks = null;
+  }
+
+  /**
+   * @returns {number | null}
+   */
+  get maxChunks() {
+    return this._maxChunks;
+  }
+
+  /**
+   * @param {number} maxChunks
+   * @returns {this}
+   */
+  setMaxChunks(maxChunks) {
+    this._maxChunks = maxChunks;
+    return this;
+  }
+
+  /**
+   * @returns {?EthereumTransactionData}
+   */
+  get ethereumData() {
+    return this._ethereumData;
+  }
+
+  /**
+   * The raw Ethereum transaction (RLP encoded type 0, 1, and 2). Complete
+   * unless the callData field is set.
+   *
+   * @param {EthereumTransactionData | Uint8Array} ethereumData
+   * @returns {this}
+   */
+  setEthereumData(ethereumData) {
+    this._ethereumData = ethereumData instanceof Uint8Array ? _EthereumTransactionData.default.fromBytes(ethereumData) : ethereumData;
+    return this;
+  }
+
+  /**
+   * @returns {?Hbar}
+   */
+  get maxGasAllowance() {
+    return this._maxGasAllowance;
+  }
+
+  /**
+   * @deprecated - use masGasAllowanceHbar instead.
+   * @param {number | string | Long | BigNumber | Hbar} maxGasAllowance
+   * @returns {this}
+   */
+  setMaxGasAllowance(maxGasAllowance) {
+    return this.setMaxGasAllowanceHbar(maxGasAllowance);
+  }
+
+  /**
+   * The maximum amount, in hbars, that the payer of the hedera transaction
+   * is willing to pay to complete the transaction.
+   *
+   * Ordinarily the account with the ECDSA alias corresponding to the public
+   * key that is extracted from the ethereum_data signature is responsible for
+   * fees that result from the execution of the transaction. If that amount of
+   * authorized fees is not sufficient then the payer of the transaction can be
+   * charged, up to but not exceeding this amount. If the ethereum_data
+   * transaction authorized an amount that was insufficient then the payer will
+   * only be charged the amount needed to make up the difference. If the gas
+   * price in the transaction was set to zero then the payer will be assessed
+   * the entire fee.
+   *
+   * @param {number | string | Long | BigNumber | Hbar} maxGasAllowance
+   * @returns {this}
+   */
+  setMaxGasAllowanceHbar(maxGasAllowance) {
+    this._maxGasAllowance = maxGasAllowance instanceof _Hbar.default ? maxGasAllowance : new _Hbar.default(maxGasAllowance);
+    return this;
+  }
+
+  /**
+   * @template {Channel} ChannelT
+   * @template {MirrorChannel} MirrorChannelT
+   * @param {import("./client/Client.js").default<ChannelT, MirrorChannelT>} client
+   * @returns {Promise<TransactionResponse>}
+   */
+  async execute(client) {
+    if (this._ethereumData == null) {
+      throw new Error("cannot submit ethereum transaction with no ethereum data");
+    }
+    const ethereumTransaction = new _EthereumTransaction.default();
+    const ethereumTransactionDataBytes = this._ethereumData.toBytes();
+    if (this._maxGasAllowance != null) {
+      ethereumTransaction.setMaxGasAllowanceHbar(this._maxGasAllowance);
+    }
+    if (this._callDataFileId != null) {
+      if (this._ethereumData.callData.length === 0) {
+        throw new Error("call data file ID provided, but ethereum data already contains call data");
+      }
+      ethereumTransaction.setEthereumData(ethereumTransactionDataBytes).setCallDataFileId(this._callDataFileId);
+      // in the consensus node config file, the maximum size of the call data file is 128000 bytes
+      // so we need to check if the call data is less than or equal to 128000 bytes
+    } else if (ethereumTransactionDataBytes.length <= 128000) {
+      ethereumTransaction.setEthereumData(ethereumTransactionDataBytes);
+    } else {
+      const fileId = await createFile(this._ethereumData.callData, client, this._maxChunks);
+      this._ethereumData.callData = new Uint8Array();
+      ethereumTransaction.setEthereumData(this._ethereumData.toBytes()).setCallDataFileId(fileId);
+    }
+    return ethereumTransaction.execute(client);
+  }
+}
+
+/**
+ * @template {Channel} ChannelT
+ * @template {MirrorChannel} MirrorChannelT
+ * @param {Uint8Array} callData
+ * @param {import("./client/Client.js").default<ChannelT, MirrorChannelT>} client
+ * @param {?number} maxChunks
+ * @returns {Promise<FileId>}
+ */
+exports.default = EthereumFlow;
+async function createFile(callData, client, maxChunks) {
+  const hexedCallData = hex.encode(callData);
+  const fileId = /** @type {FileId} */
+  (await (await new _FileCreateTransaction.default().setContents(hexedCallData.substring(0, 4096)).setKeys(client.operatorPublicKey ? [client.operatorPublicKey] : []).execute(client)).getReceipt(client)).fileId;
+  if (callData.length > 4096) {
+    let fileAppendTransaction = new _FileAppendTransaction.default().setFileId(fileId).setContents(hexedCallData.substring(4096, hexedCallData.length));
+    if (maxChunks != null) {
+      fileAppendTransaction.setMaxChunks(maxChunks);
+    }
+    await (await fileAppendTransaction.execute(client)).getReceipt(client);
+  }
+  return fileId;
+}

package/lib/EthereumFlow.d.ts

@@ -0,0 +1,134 @@
+/**
+ * @namespace proto
+ * @typedef {import("@hashgraph/proto").proto.ITransaction} HieroProto.proto.ITransaction
+ * @typedef {import("@hashgraph/proto").proto.ISignedTransaction} HieroProto.proto.ISignedTransaction
+ * @typedef {import("@hashgraph/proto").proto.TransactionBody} HieroProto.proto.TransactionBody
+ * @typedef {import("@hashgraph/proto").proto.ITransactionBody} HieroProto.proto.ITransactionBody
+ * @typedef {import("@hashgraph/proto").proto.ITransactionResponse} HieroProto.proto.ITransactionResponse
+ * @typedef {import("@hashgraph/proto").proto.IEthereumTransactionBody} HieroProto.proto.IEthereumTransactionBody
+ * @typedef {import("@hashgraph/proto").proto.IAccountID} HieroProto.proto.IAccountID
+ */
+/**
+ * @typedef {import("bignumber.js").default} BigNumber
+ * @typedef {import("./account/AccountId.js").default} AccountId
+ * @typedef {import("./file/FileId.js").default} FileId
+ * @typedef {import("./channel/Channel.js").default} Channel
+ * @typedef {import("./channel/MirrorChannel.js").default} MirrorChannel
+ * @typedef {import("./client/Client.js").default<*, *>} Client
+ * @typedef {import("./Timestamp.js").default} Timestamp
+ * @typedef {import("./transaction/TransactionId.js").default} TransactionId
+ * @typedef {import("./transaction/TransactionResponse.js").default} TransactionResponse
+ * @typedef {import("long")} Long
+ */
+/**
+ * Create a new Hedera™ transaction wrapped ethereum transaction.
+ * @deprecated - use EthereumTransaction instead. With the introduction of jumbo transactions, it should always be less cost and more efficient to use EthereumTransaction instead.
+ */
+export default class EthereumFlow {
+    /**
+     * @param {object} [props]
+     * @param {Uint8Array} [props.ethereumData]
+     * @param {FileId} [props.callData]
+     * @param {number | string | Long | BigNumber | Hbar} [props.maxGasAllowance]
+     */
+    constructor(props?: {
+        ethereumData?: Uint8Array<ArrayBufferLike> | undefined;
+        callData?: import("./file/FileId.js").default | undefined;
+        maxGasAllowance?: string | number | import("long") | import("bignumber.js").BigNumber | Hbar | undefined;
+    });
+    /**
+     * @private
+     * @type {?EthereumTransactionData}
+     */
+    private _ethereumData;
+    /**
+     * @private
+     * @type {?FileId}
+     */
+    private _callDataFileId;
+    /**
+     * @private
+     * @type {?Hbar}
+     */
+    private _maxGasAllowance;
+    _maxChunks: number | null;
+    /**
+     * @returns {number | null}
+     */
+    get maxChunks(): number | null;
+    /**
+     * @param {number} maxChunks
+     * @returns {this}
+     */
+    setMaxChunks(maxChunks: number): this;
+    /**
+     * @returns {?EthereumTransactionData}
+     */
+    get ethereumData(): EthereumTransactionData | null;
+    /**
+     * The raw Ethereum transaction (RLP encoded type 0, 1, and 2). Complete
+     * unless the callData field is set.
+     *
+     * @param {EthereumTransactionData | Uint8Array} ethereumData
+     * @returns {this}
+     */
+    setEthereumData(ethereumData: EthereumTransactionData | Uint8Array): this;
+    /**
+     * @returns {?Hbar}
+     */
+    get maxGasAllowance(): Hbar | null;
+    /**
+     * @deprecated - use masGasAllowanceHbar instead.
+     * @param {number | string | Long | BigNumber | Hbar} maxGasAllowance
+     * @returns {this}
+     */
+    setMaxGasAllowance(maxGasAllowance: number | string | Long | BigNumber | Hbar): this;
+    /**
+     * The maximum amount, in hbars, that the payer of the hedera transaction
+     * is willing to pay to complete the transaction.
+     *
+     * Ordinarily the account with the ECDSA alias corresponding to the public
+     * key that is extracted from the ethereum_data signature is responsible for
+     * fees that result from the execution of the transaction. If that amount of
+     * authorized fees is not sufficient then the payer of the transaction can be
+     * charged, up to but not exceeding this amount. If the ethereum_data
+     * transaction authorized an amount that was insufficient then the payer will
+     * only be charged the amount needed to make up the difference. If the gas
+     * price in the transaction was set to zero then the payer will be assessed
+     * the entire fee.
+     *
+     * @param {number | string | Long | BigNumber | Hbar} maxGasAllowance
+     * @returns {this}
+     */
+    setMaxGasAllowanceHbar(maxGasAllowance: number | string | Long | BigNumber | Hbar): this;
+    /**
+     * @template {Channel} ChannelT
+     * @template {MirrorChannel} MirrorChannelT
+     * @param {import("./client/Client.js").default<ChannelT, MirrorChannelT>} client
+     * @returns {Promise<TransactionResponse>}
+     */
+    execute<ChannelT extends Channel, MirrorChannelT extends MirrorChannel>(client: import("./client/Client.js").default<ChannelT, MirrorChannelT>): Promise<TransactionResponse>;
+}
+export namespace HieroProto {
+    namespace proto {
+        type ITransaction = import("@hashgraph/proto").proto.ITransaction;
+        type ISignedTransaction = import("@hashgraph/proto").proto.ISignedTransaction;
+        type TransactionBody = import("@hashgraph/proto").proto.TransactionBody;
+        type ITransactionBody = import("@hashgraph/proto").proto.ITransactionBody;
+        type ITransactionResponse = import("@hashgraph/proto").proto.ITransactionResponse;
+        type IEthereumTransactionBody = import("@hashgraph/proto").proto.IEthereumTransactionBody;
+        type IAccountID = import("@hashgraph/proto").proto.IAccountID;
+    }
+}
+export type BigNumber = import("bignumber.js").default;
+export type AccountId = import("./account/AccountId.js").default;
+export type FileId = import("./file/FileId.js").default;
+export type Channel = import("./channel/Channel.js").default;
+export type MirrorChannel = import("./channel/MirrorChannel.js").default;
+export type Client = import("./client/Client.js").default<any, any>;
+export type Timestamp = import("./Timestamp.js").default;
+export type TransactionId = import("./transaction/TransactionId.js").default;
+export type TransactionResponse = import("./transaction/TransactionResponse.js").default;
+export type Long = import("long");
+import EthereumTransactionData from "./EthereumTransactionData.js";
+import Hbar from "./Hbar.js";

package/lib/EthereumFlow.js

@@ -0,0 +1,2 @@
+import t from"./Hbar.js";import e from"./EthereumTransaction.js";import a from"./EthereumTransactionData.js";import s from"./file/FileCreateTransaction.js";import l from"./file/FileAppendTransaction.js";import{encode as n}from"./encoding/hex.js";class r{constructor(t={}){this._ethereumData=null,this._callDataFileId=null,this._maxGasAllowance=null,null!=t.ethereumData&&this.setEthereumData(t.ethereumData),null!=t.maxGasAllowance&&this.setMaxGasAllowanceHbar(t.maxGasAllowance),this._maxChunks=null}get maxChunks(){return this._maxChunks}setMaxChunks(t){return this._maxChunks=t,this}get ethereumData(){return this._ethereumData}setEthereumData(t){return this._ethereumData=t instanceof Uint8Array?a.fromBytes(t):t,this}get maxGasAllowance(){return this._maxGasAllowance}setMaxGasAllowance(t){return this.setMaxGasAllowanceHbar(t)}setMaxGasAllowanceHbar(e){return this._maxGasAllowance=e instanceof t?e:new t(e),this}async execute(t){if(null==this._ethereumData)throw new Error("cannot submit ethereum transaction with no ethereum data");const a=new e,r=this._ethereumData.toBytes();if(null!=this._maxGasAllowance&&a.setMaxGasAllowanceHbar(this._maxGasAllowance),null!=this._callDataFileId){if(0===this._ethereumData.callData.length)throw new Error("call data file ID provided, but ethereum data already contains call data");a.setEthereumData(r).setCallDataFileId(this._callDataFileId)}else if(r.length<=128e3)a.setEthereumData(r);else{const e=await async function(t,e,a){const r=n(t),i=(await(await(new s).setContents(r.substring(0,4096)).setKeys(e.operatorPublicKey?[e.operatorPublicKey]:[]).execute(e)).getReceipt(e)).fileId;if(t.length>4096){let t=(new l).setFileId(i).setContents(r.substring(4096,r.length));null!=a&&t.setMaxChunks(a),await(await t.execute(e)).getReceipt(e)}return i}(this._ethereumData.callData,t,this._maxChunks);this._ethereumData.callData=new Uint8Array,a.setEthereumData(this._ethereumData.toBytes()).setCallDataFileId(e)}return a.execute(t)}}export{r as default};
+//# sourceMappingURL=EthereumFlow.js.map

package/lib/EthereumFlow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EthereumFlow.js","sources":["../src/EthereumFlow.js"],"sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\nimport Hbar from \"./Hbar.js\";\nimport EthereumTransaction from \"./EthereumTransaction.js\";\nimport EthereumTransactionData from \"./EthereumTransactionData.js\";\nimport FileCreateTransaction from \"./file/FileCreateTransaction.js\";\nimport FileAppendTransaction from \"./file/FileAppendTransaction.js\";\nimport * as hex from \"./encoding/hex.js\";\n\n/**\n * @namespace proto\n * @typedef {import(\"@hashgraph/proto\").proto.ITransaction} HieroProto.proto.ITransaction\n * @typedef {import(\"@hashgraph/proto\").proto.ISignedTransaction} HieroProto.proto.ISignedTransaction\n * @typedef {import(\"@hashgraph/proto\").proto.TransactionBody} HieroProto.proto.TransactionBody\n * @typedef {import(\"@hashgraph/proto\").proto.ITransactionBody} HieroProto.proto.ITransactionBody\n * @typedef {import(\"@hashgraph/proto\").proto.ITransactionResponse} HieroProto.proto.ITransactionResponse\n * @typedef {import(\"@hashgraph/proto\").proto.IEthereumTransactionBody} HieroProto.proto.IEthereumTransactionBody\n * @typedef {import(\"@hashgraph/proto\").proto.IAccountID} HieroProto.proto.IAccountID\n */\n\n/**\n * @typedef {import(\"bignumber.js\").default} BigNumber\n * @typedef {import(\"./account/AccountId.js\").default} AccountId\n * @typedef {import(\"./file/FileId.js\").default} FileId\n * @typedef {import(\"./channel/Channel.js\").default} Channel\n * @typedef {import(\"./channel/MirrorChannel.js\").default} MirrorChannel\n * @typedef {import(\"./client/Client.js\").default<*, *>} Client\n * @typedef {import(\"./Timestamp.js\").default} Timestamp\n * @typedef {import(\"./transaction/TransactionId.js\").default} TransactionId\n * @typedef {import(\"./transaction/TransactionResponse.js\").default} TransactionResponse\n * @typedef {import(\"long\")} Long\n */\n\n/**\n * Create a new Hedera™ transaction wrapped ethereum transaction.\n * @deprecated - use EthereumTransaction instead. With the introduction of jumbo transactions, it should always be less cost and more efficient to use EthereumTransaction instead.\n */\nexport default class EthereumFlow {\n    /**\n     * @param {object} [props]\n     * @param {Uint8Array} [props.ethereumData]\n     * @param {FileId} [props.callData]\n     * @param {number | string | Long | BigNumber | Hbar} [props.maxGasAllowance]\n     */\n    constructor(props = {}) {\n        /**\n         * @private\n         * @type {?EthereumTransactionData}\n         */\n        this._ethereumData = null;\n\n        /**\n         * @private\n         * @type {?FileId}\n         */\n        this._callDataFileId = null;\n\n        /**\n         * @private\n         * @type {?Hbar}\n         */\n        this._maxGasAllowance = null;\n\n        if (props.ethereumData != null) {\n            this.setEthereumData(props.ethereumData);\n        }\n\n        if (props.maxGasAllowance != null) {\n            this.setMaxGasAllowanceHbar(props.maxGasAllowance);\n        }\n\n        this._maxChunks = null;\n    }\n\n    /**\n     * @returns {number | null}\n     */\n    get maxChunks() {\n        return this._maxChunks;\n    }\n\n    /**\n     * @param {number} maxChunks\n     * @returns {this}\n     */\n    setMaxChunks(maxChunks) {\n        this._maxChunks = maxChunks;\n        return this;\n    }\n\n    /**\n     * @returns {?EthereumTransactionData}\n     */\n    get ethereumData() {\n        return this._ethereumData;\n    }\n\n    /**\n     * The raw Ethereum transaction (RLP encoded type 0, 1, and 2). Complete\n     * unless the callData field is set.\n     *\n     * @param {EthereumTransactionData | Uint8Array} ethereumData\n     * @returns {this}\n     */\n    setEthereumData(ethereumData) {\n        this._ethereumData =\n            ethereumData instanceof Uint8Array\n                ? EthereumTransactionData.fromBytes(ethereumData)\n                : ethereumData;\n        return this;\n    }\n\n    /**\n     * @returns {?Hbar}\n     */\n    get maxGasAllowance() {\n        return this._maxGasAllowance;\n    }\n\n    /**\n     * @deprecated - use masGasAllowanceHbar instead.\n     * @param {number | string | Long | BigNumber | Hbar} maxGasAllowance\n     * @returns {this}\n     */\n    setMaxGasAllowance(maxGasAllowance) {\n        return this.setMaxGasAllowanceHbar(maxGasAllowance);\n    }\n\n    /**\n     * The maximum amount, in hbars, that the payer of the hedera transaction\n     * is willing to pay to complete the transaction.\n     *\n     * Ordinarily the account with the ECDSA alias corresponding to the public\n     * key that is extracted from the ethereum_data signature is responsible for\n     * fees that result from the execution of the transaction. If that amount of\n     * authorized fees is not sufficient then the payer of the transaction can be\n     * charged, up to but not exceeding this amount. If the ethereum_data\n     * transaction authorized an amount that was insufficient then the payer will\n     * only be charged the amount needed to make up the difference. If the gas\n     * price in the transaction was set to zero then the payer will be assessed\n     * the entire fee.\n     *\n     * @param {number | string | Long | BigNumber | Hbar} maxGasAllowance\n     * @returns {this}\n     */\n    setMaxGasAllowanceHbar(maxGasAllowance) {\n        this._maxGasAllowance =\n            maxGasAllowance instanceof Hbar\n                ? maxGasAllowance\n                : new Hbar(maxGasAllowance);\n        return this;\n    }\n\n    /**\n     * @template {Channel} ChannelT\n     * @template {MirrorChannel} MirrorChannelT\n     * @param {import(\"./client/Client.js\").default<ChannelT, MirrorChannelT>} client\n     * @returns {Promise<TransactionResponse>}\n     */\n    async execute(client) {\n        if (this._ethereumData == null) {\n            throw new Error(\n                \"cannot submit ethereum transaction with no ethereum data\",\n            );\n        }\n\n        const ethereumTransaction = new EthereumTransaction();\n        const ethereumTransactionDataBytes = this._ethereumData.toBytes();\n\n        if (this._maxGasAllowance != null) {\n            ethereumTransaction.setMaxGasAllowanceHbar(this._maxGasAllowance);\n        }\n\n        if (this._callDataFileId != null) {\n            if (this._ethereumData.callData.length === 0) {\n                throw new Error(\n                    \"call data file ID provided, but ethereum data already contains call data\",\n                );\n            }\n\n            ethereumTransaction\n                .setEthereumData(ethereumTransactionDataBytes)\n                .setCallDataFileId(this._callDataFileId);\n            // in the consensus node config file, the maximum size of the call data file is 128000 bytes\n            // so we need to check if the call data is less than or equal to 128000 bytes\n        } else if (ethereumTransactionDataBytes.length <= 128000) {\n            ethereumTransaction.setEthereumData(ethereumTransactionDataBytes);\n        } else {\n            const fileId = await createFile(\n                this._ethereumData.callData,\n                client,\n                this._maxChunks,\n            );\n\n            this._ethereumData.callData = new Uint8Array();\n\n            ethereumTransaction\n                .setEthereumData(this._ethereumData.toBytes())\n                .setCallDataFileId(fileId);\n        }\n\n        return ethereumTransaction.execute(client);\n    }\n}\n\n/**\n * @template {Channel} ChannelT\n * @template {MirrorChannel} MirrorChannelT\n * @param {Uint8Array} callData\n * @param {import(\"./client/Client.js\").default<ChannelT, MirrorChannelT>} client\n * @param {?number} maxChunks\n * @returns {Promise<FileId>}\n */\nasync function createFile(callData, client, maxChunks) {\n    const hexedCallData = hex.encode(callData);\n\n    const fileId = /** @type {FileId} */ (\n        (\n            await (\n                await new FileCreateTransaction()\n                    .setContents(hexedCallData.substring(0, 4096))\n                    .setKeys(\n                        client.operatorPublicKey\n                            ? [client.operatorPublicKey]\n                            : [],\n                    )\n                    .execute(client)\n            ).getReceipt(client)\n        ).fileId\n    );\n\n    if (callData.length > 4096) {\n        let fileAppendTransaction = new FileAppendTransaction()\n            .setFileId(fileId)\n            .setContents(hexedCallData.substring(4096, hexedCallData.length));\n        if (maxChunks != null) {\n            fileAppendTransaction.setMaxChunks(maxChunks);\n        }\n\n        await (await fileAppendTransaction.execute(client)).getReceipt(client);\n    }\n\n    return fileId;\n}\n"],"names":["EthereumFlow","constructor","props","this","_ethereumData","_callDataFileId","_maxGasAllowance","ethereumData","setEthereumData","maxGasAllowance","setMaxGasAllowanceHbar","_maxChunks","maxChunks","setMaxChunks","Uint8Array","EthereumTransactionData","fromBytes","setMaxGasAllowance","Hbar","execute","client","Error","ethereumTransaction","EthereumTransaction","ethereumTransactionDataBytes","toBytes","callData","length","setCallDataFileId","fileId","async","hexedCallData","hex.encode","FileCreateTransaction","setContents","substring","setKeys","operatorPublicKey","getReceipt","fileAppendTransaction","FileAppendTransaction","setFileId","createFile"],"mappings":"sPAqCe,MAAMA,EAOjB,WAAAC,CAAYC,EAAQ,IAKhBC,KAAKC,cAAgB,KAMrBD,KAAKE,gBAAkB,KAMvBF,KAAKG,iBAAmB,KAEE,MAAtBJ,EAAMK,cACNJ,KAAKK,gBAAgBN,EAAMK,cAGF,MAAzBL,EAAMO,iBACNN,KAAKO,uBAAuBR,EAAMO,iBAGtCN,KAAKQ,WAAa,IAC1B,CAKI,aAAIC,GACA,OAAOT,KAAKQ,UACpB,CAMI,YAAAE,CAAaD,GAET,OADAT,KAAKQ,WAAaC,EACXT,IACf,CAKI,gBAAII,GACA,OAAOJ,KAAKC,aACpB,CASI,eAAAI,CAAgBD,GAKZ,OAJAJ,KAAKC,cACDG,aAAwBO,WAClBC,EAAwBC,UAAUT,GAClCA,EACHJ,IACf,CAKI,mBAAIM,GACA,OAAON,KAAKG,gBACpB,CAOI,kBAAAW,CAAmBR,GACf,OAAON,KAAKO,uBAAuBD,EAC3C,CAmBI,sBAAAC,CAAuBD,GAKnB,OAJAN,KAAKG,iBACDG,aAA2BS,EACrBT,EACA,IAAIS,EAAKT,GACZN,IACf,CAQI,aAAMgB,CAAQC,GACV,GAA0B,MAAtBjB,KAAKC,cACL,MAAM,IAAIiB,MACN,4DAIR,MAAMC,EAAsB,IAAIC,EAC1BC,EAA+BrB,KAAKC,cAAcqB,UAMxD,GAJ6B,MAAzBtB,KAAKG,kBACLgB,EAAoBZ,uBAAuBP,KAAKG,kBAGxB,MAAxBH,KAAKE,gBAAyB,CAC9B,GAA2C,IAAvCF,KAAKC,cAAcsB,SAASC,OAC5B,MAAM,IAAIN,MACN,4EAIRC,EACKd,gBAAgBgB,GAChBI,kBAAkBzB,KAAKE,gBAGxC,MAAe,GAAImB,EAA6BG,QAAU,MAC9CL,EAAoBd,gBAAgBgB,OACjC,CACH,MAAMK,QAyBlBC,eAA0BJ,EAAUN,EAAQR,GACxC,MAAMmB,EAAgBC,EAAWN,GAE3BG,eAGY,IAAII,GACLC,YAAYH,EAAcI,UAAU,EAAG,OACvCC,QACGhB,EAAOiB,kBACD,CAACjB,EAAOiB,mBACR,IAETlB,QAAQC,IACfkB,WAAWlB,IAEpB,OAED,GAAIM,EAASC,OAAS,KAAM,CACxB,IAAIY,GAAwB,IAAIC,GAC3BC,UAAUZ,GACVK,YAAYH,EAAcI,UAAU,KAAMJ,EAAcJ,SAC5C,MAAbf,GACA2B,EAAsB1B,aAAaD,eAG1B2B,EAAsBpB,QAAQC,IAASkB,WAAWlB,EACvE,CAEI,OAAOS,CACX,CAvDiCa,CACjBvC,KAAKC,cAAcsB,SACnBN,EACAjB,KAAKQ,YAGTR,KAAKC,cAAcsB,SAAW,IAAIZ,WAElCQ,EACKd,gBAAgBL,KAAKC,cAAcqB,WACnCG,kBAAkBC,EACnC,CAEQ,OAAOP,EAAoBH,QAAQC,EAC3C"}