@hiero-ledger/sdk 2.70.0

package/lib/PrivateKey.d.ts

@@ -0,0 +1,312 @@
+/**
+ * @typedef {import("./transaction/Transaction.js").default} Transaction
+ */
+/**
+ * @namespace proto
+ * @typedef {import("@hashgraph/proto").proto.IKey} HieroProto.proto.IKey
+ * @typedef {import("@hashgraph/proto").proto.ITransaction} HieroProto.proto.ITransaction
+ * @typedef {import("@hashgraph/proto").proto.ISignaturePair} HieroProto.proto.ISignaturePair
+ * @typedef {import("@hashgraph/proto").proto.ISignedTransaction} HieroProto.proto.ISignedTransaction
+ * @typedef {import("@hashgraph/proto").proto.TransactionBody} HieroProto.proto.TransactionBody
+ */
+export default class PrivateKey extends Key {
+    /**
+     * Generate a random Ed25519 private key.
+     *
+     * @returns {PrivateKey}
+     */
+    static generateED25519(): PrivateKey;
+    /**
+     * Generate a random EDSA private key.
+     *
+     * @returns {PrivateKey}
+     */
+    static generateECDSA(): PrivateKey;
+    /**
+     * Depredated - Use `generateED25519()` instead
+     * Generate a random Ed25519 private key.
+     *
+     * @returns {PrivateKey}
+     */
+    static generate(): PrivateKey;
+    /**
+     * Depredated - Use `generateED25519Async()` instead
+     * Generate a random Ed25519 private key.
+     *
+     * @returns {Promise<PrivateKey>}
+     */
+    static generateAsync(): Promise<PrivateKey>;
+    /**
+     * Generate a random Ed25519 private key.
+     *
+     * @returns {Promise<PrivateKey>}
+     */
+    static generateED25519Async(): Promise<PrivateKey>;
+    /**
+     * Generate a random ECDSA private key.
+     *
+     * @returns {Promise<PrivateKey>}
+     */
+    static generateECDSAAsync(): Promise<PrivateKey>;
+    /**
+     * Construct a private key from bytes. Requires DER header.
+     *
+     * @param {Uint8Array} data
+     * @returns {PrivateKey}
+     */
+    static fromBytes(data: Uint8Array): PrivateKey;
+    /**
+     * Construct a ECDSA private key from bytes.
+     *
+     * @param {Uint8Array} data
+     * @returns {PrivateKey}
+     */
+    static fromBytesECDSA(data: Uint8Array): PrivateKey;
+    /**
+     * Construct a ED25519 private key from bytes.
+     *
+     * @param {Uint8Array} data
+     * @returns {PrivateKey}
+     */
+    static fromBytesED25519(data: Uint8Array): PrivateKey;
+    /**
+     * @deprecated - Use fromStringECDSA() or fromStringED2551() on a HEX-encoded string
+     * and fromStringDer() on a HEX-encoded string with DER prefix instead.
+     * Construct a private key from a hex-encoded string. Requires DER header.
+     * @param {string} text
+     * @returns {PrivateKey}
+     */
+    static fromString(text: string): PrivateKey;
+    /**
+     * Construct a private key from a HEX-encoded string with a der prefix
+     *
+     * @param {string} text
+     * @returns {PrivateKey}
+     */
+    static fromStringDer(text: string): PrivateKey;
+    /**
+     * Construct a ECDSA private key from a hex-encoded string.
+     *
+     * @param {string} text
+     * @returns {PrivateKey}
+     */
+    static fromStringECDSA(text: string): PrivateKey;
+    /**
+     * Construct a Ed25519 private key from a hex-encoded string.
+     *
+     * @param {string} text
+     * @returns {PrivateKey}
+     */
+    static fromStringED25519(text: string): PrivateKey;
+    /**
+     * Construct a Ed25519 private key from a Uint8Array seed.
+     *
+     * @param {Uint8Array} seed
+     * @returns {Promise<PrivateKey>}
+     */
+    static fromSeedED25519(seed: Uint8Array): Promise<PrivateKey>;
+    /**
+     * Construct a Ed25519 private key from a Uint8Array seed.
+     *
+     * @param {Uint8Array} seed
+     * @returns {Promise<PrivateKey>}
+     */
+    static fromSeedECDSAsecp256k1(seed: Uint8Array): Promise<PrivateKey>;
+    /**
+     * @deprecated - Use `Mnemonic.from[Words|String]().to[Ed25519|Ecdsa]PrivateKey()` instead
+     *
+     * Recover a private key from a mnemonic phrase (and optionally a password).
+     * @param {Mnemonic  | string} mnemonic
+     * @param {string} [passphrase]
+     * @returns {Promise<PrivateKey>}
+     */
+    static fromMnemonic(mnemonic: Mnemonic | string, passphrase?: string): Promise<PrivateKey>;
+    /**
+     * Recover a private key from a keystore, previously created by `.toKeystore()`.
+     *
+     * This key will _not_ support child key derivation.
+     *
+     * @param {Uint8Array} data
+     * @param {string} [passphrase]
+     * @returns {Promise<PrivateKey>}
+     * @throws {cryptography.BadKeyError} If the passphrase is incorrect or the hash fails to validate.
+     */
+    static fromKeystore(data: Uint8Array, passphrase?: string): Promise<PrivateKey>;
+    /**
+     * Recover a private key from a pem string; the private key may be encrypted.
+     *
+     * This method assumes the .pem file has been converted to a string already.
+     *
+     * If `passphrase` is not null or empty, this looks for the first `ENCRYPTED PRIVATE KEY`
+     * section and uses `passphrase` to decrypt it; otherwise, it looks for the first `PRIVATE KEY`
+     * section and decodes that as a DER-encoded  private key.
+     *
+     * @param {string} data
+     * @param {string} [passphrase]
+     * @returns {Promise<PrivateKey>}
+     */
+    static fromPem(data: string, passphrase?: string): Promise<PrivateKey>;
+    /**
+     * @param {string} privateKey
+     * @returns { "ecdsa" | "ed25519"}
+     */
+    static getAlgorithm(privateKey: string): "ecdsa" | "ed25519";
+    /**
+     * @internal
+     * @param {string} key
+     * @returns {boolean}
+     */
+    static isDerKey(key: string): boolean;
+    /**
+     * @internal
+     * @hideconstructor
+     * @param {PrivateKeyCrypto} key
+     */
+    constructor(key: PrivateKeyCrypto);
+    _key: PrivateKeyCrypto;
+    /**
+     * Derive a new private key at the given wallet index.
+     *
+     * Only currently supported for keys created with `fromMnemonic()`; other keys will throw
+     * an error.
+     *
+     * You can check if a key supports derivation with `.supportsDerivation()`
+     *
+     * @param {number} index
+     * @returns {Promise<PrivateKey>}
+     * @throws If this key does not support derivation.
+     */
+    derive(index: number): Promise<PrivateKey>;
+    /**
+     * @param {number} index
+     * @returns {Promise<PrivateKey>}
+     * @throws If this key does not support derivation.
+     */
+    legacyDerive(index: number): Promise<PrivateKey>;
+    /**
+     * Get the public key associated with this private key.
+     *
+     * The public key can be freely given and used by other parties to verify
+     * the signatures generated by this private key.
+     *
+     * @returns {PublicKey}
+     */
+    get publicKey(): PublicKey;
+    /**
+     * Get the public key associated with this private key.
+     *
+     * The public key can be freely given and used by other parties to verify
+     * the signatures generated by this private key.
+     *
+     * @returns {?Uint8Array}
+     */
+    get chainCode(): Uint8Array | null;
+    /**
+     * Sign a message with this private key.
+     *
+     * @param {Uint8Array} bytes
+     * @returns {Uint8Array} - The signature bytes without the message
+     */
+    sign(bytes: Uint8Array): Uint8Array;
+    /**
+     * @deprecated - Use legacy=false flag to use the modern approach
+     * or don't pass it at all.
+     * @overload
+     * @param {Transaction} transaction
+     * @param {true} legacy
+     * @returns {Uint8Array | Uint8Array[] }
+     */
+    signTransaction(transaction: Transaction, legacy: true): Uint8Array | Uint8Array[];
+    /**
+     * @overload
+     * @param {Transaction} transaction
+     * @param {false} [legacy]
+     * @returns {SignatureMap}
+     */
+    signTransaction(transaction: Transaction, legacy?: false | undefined): SignatureMap;
+    /**
+     * deprecated - This method is deprecated and will be removed in future versions.
+     * Use the `signTransaction` method with the `legacy=false` flag or don't
+     * pass it all for the modern approach.
+     * @param {Transaction} transaction
+     * @returns {Uint8Array | Uint8Array[]}
+     */
+    _signTransactionLegacy(transaction: Transaction): Uint8Array | Uint8Array[];
+    /**
+     * Check if `derive` can be called on this private key.
+     *
+     * This is only the case if the key was created from a mnemonic.
+     *
+     * @returns {boolean}
+     */
+    isDerivable(): boolean;
+    /**
+     * @returns {Uint8Array}
+     */
+    toBytes(): Uint8Array;
+    /**
+     * @returns {Uint8Array}
+     */
+    toBytesDer(): Uint8Array;
+    /**
+     * @returns {Uint8Array}
+     */
+    toBytesRaw(): Uint8Array;
+    /**
+     * @returns {string}
+     */
+    toStringDer(): string;
+    /**
+     * @returns {string}
+     */
+    toStringRaw(): string;
+    /**
+     * Create a keystore with a given passphrase.
+     *
+     * The key can be recovered later with `fromKeystore()`.
+     *
+     * Note that this will not retain the ancillary data used for
+     * deriving child keys, thus `.derive()` on the restored key will
+     * throw even if this instance supports derivation.
+     *
+     * @param {string} [passphrase]
+     * @returns {Promise<Uint8Array>}
+     */
+    toKeystore(passphrase?: string): Promise<Uint8Array>;
+    /**
+     * @param {Long | number} shard
+     * @param {Long | number} realm
+     * @returns {AccountId}
+     */
+    toAccountId(shard: Long | number, realm: Long | number): AccountId;
+    /**
+     * @returns {string}
+     */
+    get type(): string;
+    /**
+     * Recover the recovery ID used in the signature for the given message.
+     *
+     * **Note:** This method only works for ECDSA secp256k1 keys.
+     * @param {Uint8Array} r - 32-byte `r` component of the signature
+     * @param {Uint8Array} s - 32-byte `s` component of the signature
+     * @param {Uint8Array} message - The original (unhashed) message
+     * @returns {number} Recovery ID (0–3), or -1 if not found or not applicable
+     */
+    getRecoveryId(r: Uint8Array, s: Uint8Array, message: Uint8Array): number;
+}
+export type Transaction = import("./transaction/Transaction.js").default;
+export namespace HieroProto {
+    namespace proto {
+        type IKey = import("@hashgraph/proto").proto.IKey;
+        type ITransaction = import("@hashgraph/proto").proto.ITransaction;
+        type ISignaturePair = import("@hashgraph/proto").proto.ISignaturePair;
+        type ISignedTransaction = import("@hashgraph/proto").proto.ISignedTransaction;
+        type TransactionBody = import("@hashgraph/proto").proto.TransactionBody;
+    }
+}
+import Key from "./Key.js";
+import { PrivateKey as PrivateKeyCrypto } from "@hashgraph/cryptography";
+import PublicKey from "./PublicKey.js";
+import SignatureMap from "./transaction/SignatureMap.js";
+import AccountId from "./account/AccountId.js";
+import Mnemonic from "./Mnemonic.js";

package/lib/PrivateKey.js

@@ -0,0 +1,2 @@
+import{hexlify as t}from"@ethersproject/bytes";import{PrivateKey as e}from"@hashgraph/cryptography";import{proto as r}from"@hashgraph/proto";import n from"./Mnemonic.js";import i from"./PublicKey.js";import o from"./Key.js";import s from"./Cache.js";import a from"./transaction/SignatureMap.js";import c from"./account/AccountId.js";import y from"./transaction/TransactionId.js";import{decode as u}from"./encoding/hex.js";import{ASN1Decoder as m}from"./util/ASN1-Decoder.js";class g extends o{constructor(t){super(),this._key=t}static generateED25519(){return new g(e.generateED25519())}static generateECDSA(){return new g(e.generateECDSA())}static generate(){return g.generateED25519()}static async generateAsync(){return new g(await e.generateAsync())}static async generateED25519Async(){return new g(await e.generateED25519Async())}static async generateECDSAAsync(){return new g(await e.generateECDSAAsync())}static fromBytes(r){const n=t(r);return g.isDerKey(n)?"ecdsa"===g.getAlgorithm(n)?new g(e.fromBytesECDSA(r)):new g(e.fromBytesED25519(r)):new g(e.fromBytes(r))}static fromBytesECDSA(t){return new g(e.fromBytesECDSA(t))}static fromBytesED25519(t){return new g(e.fromBytesED25519(t))}static fromString(t){return g.isDerKey(t)?this.fromStringDer(t):new g(e.fromString(t))}static fromStringDer(t){return g.isDerKey(t)?"ecdsa"===g.getAlgorithm(t)?this.fromStringECDSA(t):this.fromStringED25519(t):g.fromString(t)}static fromStringECDSA(t){return new g(e.fromStringECDSA(t))}static fromStringED25519(t){return new g(e.fromStringED25519(t))}static async fromSeedED25519(t){return new g(await e.fromSeedED25519(t))}static async fromSeedECDSAsecp256k1(t){return new g(await e.fromSeedECDSAsecp256k1(t))}static async fromMnemonic(t,r=""){return new g(t instanceof n?await e.fromMnemonic(t._mnemonic,r):await e.fromMnemonic(t,r))}static async fromKeystore(t,r=""){return new g(await e.fromKeystore(t,r))}static async fromPem(t,r=""){return new g(await e.fromPem(t,r))}async derive(t){return new g(await this._key.derive(t))}async legacyDerive(t){return new g(await this._key.legacyDerive(t))}get publicKey(){return new i(this._key.publicKey)}get chainCode(){return this._key._chainCode}sign(t){return this._key.sign(t)}signTransaction(t,e=!1){if(e)return this._signTransactionLegacy(t);const n=new a;for(const e of t._signedTransactions.list){const t=e.bodyBytes;if(!t)throw new Error("Body bytes are missing");const i=r.TransactionBody.decode(t);if(!i.transactionID||!i.nodeAccountID)throw new Error("Transaction ID or Node Account ID not found in the signed transaction");const o=c._fromProtobuf(i.nodeAccountID),s=y._fromProtobuf(i.transactionID),a=this._key.sign(t);n.addSignature(o,s,this.publicKey,a)}return t.addSignature(this.publicKey,n),n}_signTransactionLegacy(t){const e=t._signedTransactions.list.map((t=>{const e=t.bodyBytes;return e?this._key.sign(e):new Uint8Array}));return t.addSignature(this.publicKey,e),1===e.length?e[0]:e}isDerivable(){return this._key.isDerivable()}toBytes(){return this._key.toBytes()}toBytesDer(){return this._key.toBytesDer()}toBytesRaw(){return this._key.toBytesRaw()}toString(){return this._key.toStringDer()}toStringDer(){return this._key.toStringDer()}toStringRaw(){return this._key.toStringRaw()}toKeystore(t=""){return this._key.toKeystore(t)}_toProtobufKey(){return this.publicKey._toProtobufKey()}toAccountId(t,e){return this.publicKey.toAccountId(t,e)}get type(){return this._key._type}getRecoveryId(t,e,r){return this._key.getRecoveryId(t,e,r)}static getAlgorithm(t){if(!g.isDerKey(t))throw new Error("Only der keys are supported");const e=new m(Uint8Array.from(u(t)));e.read();return e.getOidKeyTypes()[0]}static isDerKey(t){try{const e=Uint8Array.from(u(t));return new m(e).read(),!0}catch(t){return!1}}}s.setPrivateKeyConstructor((t=>new g(t)));export{g as default};
+//# sourceMappingURL=PrivateKey.js.map

package/lib/PrivateKey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrivateKey.js","sources":["../src/PrivateKey.js"],"sourcesContent":["// SPDX-License-Identifier: Apache-2.0\nimport { hexlify } from \"@ethersproject/bytes\";\nimport { PrivateKey as PrivateKeyCrypto } from \"@hashgraph/cryptography\";\nimport { proto } from \"@hashgraph/proto\";\nimport Mnemonic from \"./Mnemonic.js\";\nimport PublicKey from \"./PublicKey.js\";\nimport Key from \"./Key.js\";\nimport CACHE from \"./Cache.js\";\nimport SignatureMap from \"./transaction/SignatureMap.js\";\nimport AccountId from \"./account/AccountId.js\";\nimport TransactionId from \"./transaction/TransactionId.js\";\nimport { decode } from \"./encoding/hex.js\";\nimport { ASN1Decoder } from \"./util/ASN1-Decoder.js\";\n\n/**\n * @typedef {import(\"./transaction/Transaction.js\").default} Transaction\n */\n\n/**\n * @namespace proto\n * @typedef {import(\"@hashgraph/proto\").proto.IKey} HieroProto.proto.IKey\n * @typedef {import(\"@hashgraph/proto\").proto.ITransaction} HieroProto.proto.ITransaction\n * @typedef {import(\"@hashgraph/proto\").proto.ISignaturePair} HieroProto.proto.ISignaturePair\n * @typedef {import(\"@hashgraph/proto\").proto.ISignedTransaction} HieroProto.proto.ISignedTransaction\n * @typedef {import(\"@hashgraph/proto\").proto.TransactionBody} HieroProto.proto.TransactionBody\n */\n\nexport default class PrivateKey extends Key {\n    /**\n     * @internal\n     * @hideconstructor\n     * @param {PrivateKeyCrypto} key\n     */\n    constructor(key) {\n        super();\n\n        this._key = key;\n    }\n\n    /**\n     * Generate a random Ed25519 private key.\n     *\n     * @returns {PrivateKey}\n     */\n    static generateED25519() {\n        return new PrivateKey(PrivateKeyCrypto.generateED25519());\n    }\n\n    /**\n     * Generate a random EDSA private key.\n     *\n     * @returns {PrivateKey}\n     */\n    static generateECDSA() {\n        return new PrivateKey(PrivateKeyCrypto.generateECDSA());\n    }\n\n    /**\n     * Depredated - Use `generateED25519()` instead\n     * Generate a random Ed25519 private key.\n     *\n     * @returns {PrivateKey}\n     */\n    static generate() {\n        return PrivateKey.generateED25519();\n    }\n\n    /**\n     * Depredated - Use `generateED25519Async()` instead\n     * Generate a random Ed25519 private key.\n     *\n     * @returns {Promise<PrivateKey>}\n     */\n    static async generateAsync() {\n        return new PrivateKey(await PrivateKeyCrypto.generateAsync());\n    }\n\n    /**\n     * Generate a random Ed25519 private key.\n     *\n     * @returns {Promise<PrivateKey>}\n     */\n    static async generateED25519Async() {\n        return new PrivateKey(await PrivateKeyCrypto.generateED25519Async());\n    }\n\n    /**\n     * Generate a random ECDSA private key.\n     *\n     * @returns {Promise<PrivateKey>}\n     */\n    static async generateECDSAAsync() {\n        return new PrivateKey(await PrivateKeyCrypto.generateECDSAAsync());\n    }\n\n    /**\n     * Construct a private key from bytes. Requires DER header.\n     *\n     * @param {Uint8Array} data\n     * @returns {PrivateKey}\n     */\n    static fromBytes(data) {\n        const keyString = hexlify(data);\n        if (PrivateKey.isDerKey(keyString)) {\n            if (PrivateKey.getAlgorithm(keyString) === \"ecdsa\") {\n                return new PrivateKey(PrivateKeyCrypto.fromBytesECDSA(data));\n            } else {\n                return new PrivateKey(PrivateKeyCrypto.fromBytesED25519(data));\n            }\n        }\n\n        // If the key is not DER, we assume it's a raw private key\n        // this will default to ED25519 as we dont have a way\n        // to determine the type of the key based on the raw bytes\n        return new PrivateKey(PrivateKeyCrypto.fromBytes(data));\n    }\n\n    /**\n     * Construct a ECDSA private key from bytes.\n     *\n     * @param {Uint8Array} data\n     * @returns {PrivateKey}\n     */\n    static fromBytesECDSA(data) {\n        return new PrivateKey(PrivateKeyCrypto.fromBytesECDSA(data));\n    }\n\n    /**\n     * Construct a ED25519 private key from bytes.\n     *\n     * @param {Uint8Array} data\n     * @returns {PrivateKey}\n     */\n    static fromBytesED25519(data) {\n        return new PrivateKey(PrivateKeyCrypto.fromBytesED25519(data));\n    }\n\n    /**\n     * @deprecated - Use fromStringECDSA() or fromStringED2551() on a HEX-encoded string\n     * and fromStringDer() on a HEX-encoded string with DER prefix instead.\n     * Construct a private key from a hex-encoded string. Requires DER header.\n     * @param {string} text\n     * @returns {PrivateKey}\n     */\n    static fromString(text) {\n        if (PrivateKey.isDerKey(text)) {\n            return this.fromStringDer(text);\n        }\n        // If the key is not DER, we assume it's a raw private key\n        // this will default to ED25519 as we dont have a way\n        // to determine the type of the key based on the raw bytes\n        return new PrivateKey(PrivateKeyCrypto.fromString(text));\n    }\n\n    /**\n     * Construct a private key from a HEX-encoded string with a der prefix\n     *\n     * @param {string} text\n     * @returns {PrivateKey}\n     */\n    static fromStringDer(text) {\n        // previous versions of the library used to accept non-der encoded private keys here\n        // and it fallbacked to PrivateKey.fromString() so we need to keep this behavior\n        if (!PrivateKey.isDerKey(text)) {\n            // eslint-disable-next-line deprecation/deprecation\n            return PrivateKey.fromString(text);\n        }\n\n        if (PrivateKey.getAlgorithm(text) === \"ecdsa\") {\n            return this.fromStringECDSA(text);\n        } else {\n            return this.fromStringED25519(text);\n        }\n    }\n\n    /**\n     * Construct a ECDSA private key from a hex-encoded string.\n     *\n     * @param {string} text\n     * @returns {PrivateKey}\n     */\n    static fromStringECDSA(text) {\n        return new PrivateKey(PrivateKeyCrypto.fromStringECDSA(text));\n    }\n\n    /**\n     * Construct a Ed25519 private key from a hex-encoded string.\n     *\n     * @param {string} text\n     * @returns {PrivateKey}\n     */\n    static fromStringED25519(text) {\n        return new PrivateKey(PrivateKeyCrypto.fromStringED25519(text));\n    }\n\n    /**\n     * Construct a Ed25519 private key from a Uint8Array seed.\n     *\n     * @param {Uint8Array} seed\n     * @returns {Promise<PrivateKey>}\n     */\n    static async fromSeedED25519(seed) {\n        return new PrivateKey(await PrivateKeyCrypto.fromSeedED25519(seed));\n    }\n\n    /**\n     * Construct a Ed25519 private key from a Uint8Array seed.\n     *\n     * @param {Uint8Array} seed\n     * @returns {Promise<PrivateKey>}\n     */\n    static async fromSeedECDSAsecp256k1(seed) {\n        return new PrivateKey(\n            await PrivateKeyCrypto.fromSeedECDSAsecp256k1(seed),\n        );\n    }\n\n    /**\n     * @deprecated - Use `Mnemonic.from[Words|String]().to[Ed25519|Ecdsa]PrivateKey()` instead\n     *\n     * Recover a private key from a mnemonic phrase (and optionally a password).\n     * @param {Mnemonic  | string} mnemonic\n     * @param {string} [passphrase]\n     * @returns {Promise<PrivateKey>}\n     */\n    static async fromMnemonic(mnemonic, passphrase = \"\") {\n        if (mnemonic instanceof Mnemonic) {\n            return new PrivateKey(\n                // eslint-disable-next-line deprecation/deprecation\n                await PrivateKeyCrypto.fromMnemonic(\n                    mnemonic._mnemonic,\n                    passphrase,\n                ),\n            );\n        }\n\n        return new PrivateKey(\n            // eslint-disable-next-line deprecation/deprecation\n            await PrivateKeyCrypto.fromMnemonic(mnemonic, passphrase),\n        );\n    }\n\n    /**\n     * Recover a private key from a keystore, previously created by `.toKeystore()`.\n     *\n     * This key will _not_ support child key derivation.\n     *\n     * @param {Uint8Array} data\n     * @param {string} [passphrase]\n     * @returns {Promise<PrivateKey>}\n     * @throws {cryptography.BadKeyError} If the passphrase is incorrect or the hash fails to validate.\n     */\n    static async fromKeystore(data, passphrase = \"\") {\n        return new PrivateKey(\n            await PrivateKeyCrypto.fromKeystore(data, passphrase),\n        );\n    }\n\n    /**\n     * Recover a private key from a pem string; the private key may be encrypted.\n     *\n     * This method assumes the .pem file has been converted to a string already.\n     *\n     * If `passphrase` is not null or empty, this looks for the first `ENCRYPTED PRIVATE KEY`\n     * section and uses `passphrase` to decrypt it; otherwise, it looks for the first `PRIVATE KEY`\n     * section and decodes that as a DER-encoded  private key.\n     *\n     * @param {string} data\n     * @param {string} [passphrase]\n     * @returns {Promise<PrivateKey>}\n     */\n    static async fromPem(data, passphrase = \"\") {\n        return new PrivateKey(await PrivateKeyCrypto.fromPem(data, passphrase));\n    }\n\n    /**\n     * Derive a new private key at the given wallet index.\n     *\n     * Only currently supported for keys created with `fromMnemonic()`; other keys will throw\n     * an error.\n     *\n     * You can check if a key supports derivation with `.supportsDerivation()`\n     *\n     * @param {number} index\n     * @returns {Promise<PrivateKey>}\n     * @throws If this key does not support derivation.\n     */\n    async derive(index) {\n        return new PrivateKey(await this._key.derive(index));\n    }\n\n    /**\n     * @param {number} index\n     * @returns {Promise<PrivateKey>}\n     * @throws If this key does not support derivation.\n     */\n    async legacyDerive(index) {\n        return new PrivateKey(await this._key.legacyDerive(index));\n    }\n\n    /**\n     * Get the public key associated with this private key.\n     *\n     * The public key can be freely given and used by other parties to verify\n     * the signatures generated by this private key.\n     *\n     * @returns {PublicKey}\n     */\n    get publicKey() {\n        return new PublicKey(this._key.publicKey);\n    }\n\n    /**\n     * Get the public key associated with this private key.\n     *\n     * The public key can be freely given and used by other parties to verify\n     * the signatures generated by this private key.\n     *\n     * @returns {?Uint8Array}\n     */\n    get chainCode() {\n        return this._key._chainCode;\n    }\n\n    /**\n     * Sign a message with this private key.\n     *\n     * @param {Uint8Array} bytes\n     * @returns {Uint8Array} - The signature bytes without the message\n     */\n    sign(bytes) {\n        return this._key.sign(bytes);\n    }\n\n    /**\n     * @deprecated - Use legacy=false flag to use the modern approach\n     * or don't pass it at all.\n     * @overload\n     * @param {Transaction} transaction\n     * @param {true} legacy\n     * @returns {Uint8Array | Uint8Array[] }\n     */\n\n    /**\n     * @overload\n     * @param {Transaction} transaction\n     * @param {false} [legacy]\n     * @returns {SignatureMap}\n     */\n\n    /**\n     * @param {Transaction} transaction\n     * @param {boolean} [legacy]\n     * @returns {Uint8Array | Uint8Array[] | SignatureMap}\n     */\n    signTransaction(transaction, legacy = false) {\n        if (legacy) {\n            return this._signTransactionLegacy(transaction);\n        }\n\n        const sigMap = new SignatureMap();\n\n        for (const signedTx of transaction._signedTransactions.list) {\n            const bodyBytes = signedTx.bodyBytes;\n            if (!bodyBytes) throw new Error(\"Body bytes are missing\");\n\n            const body = proto.TransactionBody.decode(bodyBytes);\n            if (!body.transactionID || !body.nodeAccountID) {\n                throw new Error(\n                    \"Transaction ID or Node Account ID not found in the signed transaction\",\n                );\n            }\n\n            const nodeId = AccountId._fromProtobuf(body.nodeAccountID);\n            const transactionId = TransactionId._fromProtobuf(\n                body.transactionID,\n            );\n            const sig = this._key.sign(bodyBytes);\n            sigMap.addSignature(nodeId, transactionId, this.publicKey, sig);\n        }\n\n        transaction.addSignature(this.publicKey, sigMap);\n        return sigMap;\n    }\n\n    /**\n     * deprecated - This method is deprecated and will be removed in future versions.\n     * Use the `signTransaction` method with the `legacy=false` flag or don't\n     * pass it all for the modern approach.\n     * @param {Transaction} transaction\n     * @returns {Uint8Array | Uint8Array[]}\n     */\n    _signTransactionLegacy(transaction) {\n        const signatures = transaction._signedTransactions.list.map(\n            (signedTransaction) => {\n                const bodyBytes = signedTransaction.bodyBytes;\n                if (!bodyBytes) {\n                    return new Uint8Array();\n                }\n\n                return this._key.sign(bodyBytes);\n            },\n        );\n        transaction.addSignature(this.publicKey, signatures);\n        // Return directly Uint8Array if there is only one signature\n        return signatures.length === 1 ? signatures[0] : signatures;\n    }\n\n    /**\n     * Check if `derive` can be called on this private key.\n     *\n     * This is only the case if the key was created from a mnemonic.\n     *\n     * @returns {boolean}\n     */\n    isDerivable() {\n        return this._key.isDerivable();\n    }\n\n    /**\n     * @returns {Uint8Array}\n     */\n    toBytes() {\n        return this._key.toBytes();\n    }\n\n    /**\n     * @returns {Uint8Array}\n     */\n    toBytesDer() {\n        return this._key.toBytesDer();\n    }\n\n    /**\n     * @returns {Uint8Array}\n     */\n    toBytesRaw() {\n        return this._key.toBytesRaw();\n    }\n\n    /**\n     * @returns {string}\n     */\n    toString() {\n        return this._key.toStringDer();\n    }\n\n    /**\n     * @returns {string}\n     */\n    toStringDer() {\n        return this._key.toStringDer();\n    }\n\n    /**\n     * @returns {string}\n     */\n    toStringRaw() {\n        return this._key.toStringRaw();\n    }\n\n    /**\n     * Create a keystore with a given passphrase.\n     *\n     * The key can be recovered later with `fromKeystore()`.\n     *\n     * Note that this will not retain the ancillary data used for\n     * deriving child keys, thus `.derive()` on the restored key will\n     * throw even if this instance supports derivation.\n     *\n     * @param {string} [passphrase]\n     * @returns {Promise<Uint8Array>}\n     */\n    toKeystore(passphrase = \"\") {\n        return this._key.toKeystore(passphrase);\n    }\n\n    /**\n     * @returns {HieroProto.proto.IKey}\n     */\n    _toProtobufKey() {\n        return this.publicKey._toProtobufKey();\n    }\n\n    /**\n     * @param {Long | number} shard\n     * @param {Long | number} realm\n     * @returns {AccountId}\n     */\n    toAccountId(shard, realm) {\n        return this.publicKey.toAccountId(shard, realm);\n    }\n\n    /**\n     * @returns {string}\n     */\n    get type() {\n        return this._key._type;\n    }\n\n    /**\n     * Recover the recovery ID used in the signature for the given message.\n     *\n     * **Note:** This method only works for ECDSA secp256k1 keys.\n     * @param {Uint8Array} r - 32-byte `r` component of the signature\n     * @param {Uint8Array} s - 32-byte `s` component of the signature\n     * @param {Uint8Array} message - The original (unhashed) message\n     * @returns {number} Recovery ID (0–3), or -1 if not found or not applicable\n     */\n    getRecoveryId(r, s, message) {\n        return this._key.getRecoveryId(r, s, message);\n    }\n\n    /**\n     * @param {string} privateKey\n     * @returns { \"ecdsa\" | \"ed25519\"}\n     */\n    static getAlgorithm(privateKey) {\n        if (!PrivateKey.isDerKey(privateKey)) {\n            throw new Error(\"Only der keys are supported\");\n        }\n\n        const decoder = new ASN1Decoder(Uint8Array.from(decode(privateKey)));\n        decoder.read();\n        const decodedKeyType = decoder.getOidKeyTypes()[0];\n        // @ts-ignored\n        return decodedKeyType;\n    }\n\n    /**\n     * @internal\n     * @param {string} key\n     * @returns {boolean}\n     */\n    static isDerKey(key) {\n        try {\n            const data = Uint8Array.from(decode(key));\n            const decoder = new ASN1Decoder(data);\n            decoder.read(); // Attempt to read the ASN.1 structure\n            return true;\n        } catch (error) {\n            return false;\n        }\n    }\n}\n\nCACHE.setPrivateKeyConstructor((key) => new PrivateKey(key));\n"],"names":["PrivateKey","Key","constructor","key","super","this","_key","generateED25519","PrivateKeyCrypto","generateECDSA","generate","generateAsync","generateED25519Async","generateECDSAAsync","fromBytes","data","keyString","hexlify","isDerKey","getAlgorithm","fromBytesECDSA","fromBytesED25519","fromString","text","fromStringDer","fromStringECDSA","fromStringED25519","fromSeedED25519","seed","fromSeedECDSAsecp256k1","fromMnemonic","mnemonic","passphrase","Mnemonic","_mnemonic","fromKeystore","fromPem","derive","index","legacyDerive","publicKey","PublicKey","chainCode","_chainCode","sign","bytes","signTransaction","transaction","legacy","_signTransactionLegacy","sigMap","SignatureMap","signedTx","_signedTransactions","list","bodyBytes","Error","body","proto","TransactionBody","decode","transactionID","nodeAccountID","nodeId","AccountId","_fromProtobuf","transactionId","TransactionId","sig","addSignature","signatures","map","signedTransaction","Uint8Array","length","isDerivable","toBytes","toBytesDer","toBytesRaw","toString","toStringDer","toStringRaw","toKeystore","_toProtobufKey","toAccountId","shard","realm","type","_type","getRecoveryId","r","s","message","privateKey","decoder","ASN1Decoder","from","read","getOidKeyTypes","error","CACHE","setPrivateKeyConstructor"],"mappings":"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"}

package/lib/PrngTransaction.cjs

@@ -0,0 +1,136 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Transaction = _interopRequireWildcard(require("./transaction/Transaction.cjs"));
+var _util = require("./util.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; }
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @typedef {import("@hashgraph/proto").proto.ITransaction} HieroProto.proto.ITransaction
+ * @typedef {import("@hashgraph/proto").proto.Transaction} HieroProto.proto.Transaction
+ * @typedef {import("@hashgraph/proto").proto.ISignedTransaction} HieroProto.proto.ISignedTransaction
+ * @typedef {import("@hashgraph/proto").proto.SignedTransaction} HieroProto.proto.SignedTransaction
+ * @typedef {import("@hashgraph/proto").proto.IUtilPrngTransactionBody } HieroProto.proto.IUtilPrngTransactionBody
+ * @typedef {import("@hashgraph/proto").proto.UtilPrngTransactionBody} HieroProto.proto.UtilPrngTransactionBody
+ * @typedef {import("@hashgraph/proto").proto.ITransactionResponse} HieroProto.proto.TransactionResponse
+ * @typedef {import("@hashgraph/proto").proto.TransactionBody} HieroProto.proto.TransactionBody
+ * @typedef {import("@hashgraph/proto").proto.ITransactionBody} HieroProto.proto.ITransactionBody
+ * @typedef {import("./account/AccountId.js").default} AccountId
+ * @typedef {import("./transaction/TransactionId.js").default} TransactionId
+ */
+
+/**
+ * @typedef {import("./client/Client.js").default<*, *>} Client
+ *  @typedef {import("./channel/Channel.js").default} Channel
+ */
+
+/**
+ * Gets a pseudorandom 32-bit number. Not cryptographically secure. See HIP-351 https://hips.hedera.com/hip/hip-351
+ */
+class PrngTransaction extends _Transaction.default {
+  /**
+   * @param {object} props
+   * @param {?number } [props.range]
+   */
+  constructor(props = {}) {
+    super();
+
+    /**
+     * @private
+     * @type {?number}
+     */
+    this._range = null;
+    if (props.range != null) {
+      this.setRange(props.range);
+    }
+  }
+
+  /**
+   * @param {number} newRange
+   * @returns {this}
+   */
+  setRange(newRange) {
+    this._range = newRange;
+    return this;
+  }
+  get range() {
+    return this._range;
+  }
+
+  /**
+   * @param {Client} client
+   */
+  _validateChecksums(client) {
+    if (this._range != null && (0, _util.isNumber)(this._range)) {
+      this._validateChecksums(client);
+    }
+  }
+
+  /**
+   * @override
+   * @internal
+   * @param {Channel} channel
+   * @param {HieroProto.proto.ITransaction} request
+   * @returns {Promise<HieroProto.proto.TransactionResponse>}
+   */
+  _execute(channel, request) {
+    return channel.util.prng(request);
+  }
+
+  /**
+   * @internal
+   * @param {HieroProto.proto.ITransaction[]} transactions
+   * @param {HieroProto.proto.ISignedTransaction[]} signedTransactions
+   * @param {TransactionId[]} transactionIds
+   * @param {AccountId[]} nodeIds
+   * @param {HieroProto.proto.ITransactionBody[]} bodies
+   * @returns {PrngTransaction}
+   */
+  static _fromProtobuf(transactions, signedTransactions, transactionIds, nodeIds, bodies) {
+    const body = /** @type {HieroProto.proto.ITransactionBody} */
+    bodies[0];
+    const transactionRange = /** @type {HieroProto.proto.IUtilPrngTransactionBody} */
+    body.utilPrng;
+    return _Transaction.default._fromProtobufTransactions(new PrngTransaction({
+      range: transactionRange.range
+    }), transactions, signedTransactions, transactionIds, nodeIds, bodies);
+  }
+
+  /**
+   * @override
+   * @protected
+   * @returns {NonNullable<HieroProto.proto.TransactionBody["data"]>}
+   */
+  _getTransactionDataCase() {
+    return "utilPrng";
+  }
+
+  /**
+   * @override
+   * @protected
+   * @returns {HieroProto.proto.IUtilPrngTransactionBody}
+   */
+  _makeTransactionData() {
+    return {
+      range: this.range
+    };
+  }
+
+  /**
+   * @returns {string}
+   */
+  _getLogId() {
+    const timestamp = /** @type {import("./Timestamp.js").default} */
+    this._transactionIds.current.validStart;
+    return `RandomGenerate:${timestamp.toString()}`;
+  }
+}
+exports.default = PrngTransaction;
+_Transaction.TRANSACTION_REGISTRY.set("utilPrng",
+// eslint-disable-next-line @typescript-eslint/unbound-method
+PrngTransaction._fromProtobuf);

package/lib/PrngTransaction.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @typedef {import("@hashgraph/proto").proto.ITransaction} HieroProto.proto.ITransaction
+ * @typedef {import("@hashgraph/proto").proto.Transaction} HieroProto.proto.Transaction
+ * @typedef {import("@hashgraph/proto").proto.ISignedTransaction} HieroProto.proto.ISignedTransaction
+ * @typedef {import("@hashgraph/proto").proto.SignedTransaction} HieroProto.proto.SignedTransaction
+ * @typedef {import("@hashgraph/proto").proto.IUtilPrngTransactionBody } HieroProto.proto.IUtilPrngTransactionBody
+ * @typedef {import("@hashgraph/proto").proto.UtilPrngTransactionBody} HieroProto.proto.UtilPrngTransactionBody
+ * @typedef {import("@hashgraph/proto").proto.ITransactionResponse} HieroProto.proto.TransactionResponse
+ * @typedef {import("@hashgraph/proto").proto.TransactionBody} HieroProto.proto.TransactionBody
+ * @typedef {import("@hashgraph/proto").proto.ITransactionBody} HieroProto.proto.ITransactionBody
+ * @typedef {import("./account/AccountId.js").default} AccountId
+ * @typedef {import("./transaction/TransactionId.js").default} TransactionId
+ */
+/**
+ * @typedef {import("./client/Client.js").default<*, *>} Client
+ *  @typedef {import("./channel/Channel.js").default} Channel
+ */
+/**
+ * Gets a pseudorandom 32-bit number. Not cryptographically secure. See HIP-351 https://hips.hedera.com/hip/hip-351
+ */
+export default class PrngTransaction extends Transaction {
+    /**
+     * @internal
+     * @param {HieroProto.proto.ITransaction[]} transactions
+     * @param {HieroProto.proto.ISignedTransaction[]} signedTransactions
+     * @param {TransactionId[]} transactionIds
+     * @param {AccountId[]} nodeIds
+     * @param {HieroProto.proto.ITransactionBody[]} bodies
+     * @returns {PrngTransaction}
+     */
+    static _fromProtobuf(transactions: HieroProto.proto.ITransaction[], signedTransactions: HieroProto.proto.ISignedTransaction[], transactionIds: TransactionId[], nodeIds: AccountId[], bodies: HieroProto.proto.ITransactionBody[]): PrngTransaction;
+    /**
+     * @param {object} props
+     * @param {?number } [props.range]
+     */
+    constructor(props?: {
+        range?: number | null | undefined;
+    });
+    /**
+     * @private
+     * @type {?number}
+     */
+    private _range;
+    /**
+     * @param {number} newRange
+     * @returns {this}
+     */
+    setRange(newRange: number): this;
+    get range(): number | null;
+    /**
+     * @override
+     * @protected
+     * @returns {HieroProto.proto.IUtilPrngTransactionBody}
+     */
+    protected override _makeTransactionData(): HieroProto.proto.IUtilPrngTransactionBody;
+}
+export namespace HieroProto {
+    namespace proto {
+        type ITransaction = import("@hashgraph/proto").proto.ITransaction;
+        type Transaction = import("@hashgraph/proto").proto.Transaction;
+        type ISignedTransaction = import("@hashgraph/proto").proto.ISignedTransaction;
+        type SignedTransaction = import("@hashgraph/proto").proto.SignedTransaction;
+        type IUtilPrngTransactionBody = import("@hashgraph/proto").proto.IUtilPrngTransactionBody;
+        type UtilPrngTransactionBody = import("@hashgraph/proto").proto.UtilPrngTransactionBody;
+        type TransactionResponse = import("@hashgraph/proto").proto.ITransactionResponse;
+        type TransactionBody = import("@hashgraph/proto").proto.TransactionBody;
+        type ITransactionBody = import("@hashgraph/proto").proto.ITransactionBody;
+    }
+}
+export type AccountId = import("./account/AccountId.js").default;
+export type TransactionId = import("./transaction/TransactionId.js").default;
+export type Client = import("./client/Client.js").default<any, any>;
+export type Channel = import("./channel/Channel.js").default;
+import Transaction from "./transaction/Transaction.js";

package/lib/PrngTransaction.js

@@ -0,0 +1,2 @@
+import t,{TRANSACTION_REGISTRY as r}from"./transaction/Transaction.js";import{isNumber as n}from"./util.js";class e extends t{constructor(t={}){super(),this._range=null,null!=t.range&&this.setRange(t.range)}setRange(t){return this._range=t,this}get range(){return this._range}_validateChecksums(t){null!=this._range&&n(this._range)&&this._validateChecksums(t)}_execute(t,r){return t.util.prng(r)}static _fromProtobuf(r,n,a,s,i){const o=i[0].utilPrng;return t._fromProtobufTransactions(new e({range:o.range}),r,n,a,s,i)}_getTransactionDataCase(){return"utilPrng"}_makeTransactionData(){return{range:this.range}}_getLogId(){return`RandomGenerate:${this._transactionIds.current.validStart.toString()}`}}r.set("utilPrng",e._fromProtobuf);export{e as default};
+//# sourceMappingURL=PrngTransaction.js.map

package/lib/PrngTransaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrngTransaction.js","sources":["../src/PrngTransaction.js"],"sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\nimport Transaction, {\n    TRANSACTION_REGISTRY,\n} from \"./transaction/Transaction.js\";\nimport { isNumber } from \"./util.js\";\n\n/**\n * @typedef {import(\"@hashgraph/proto\").proto.ITransaction} HieroProto.proto.ITransaction\n * @typedef {import(\"@hashgraph/proto\").proto.Transaction} HieroProto.proto.Transaction\n * @typedef {import(\"@hashgraph/proto\").proto.ISignedTransaction} HieroProto.proto.ISignedTransaction\n * @typedef {import(\"@hashgraph/proto\").proto.SignedTransaction} HieroProto.proto.SignedTransaction\n * @typedef {import(\"@hashgraph/proto\").proto.IUtilPrngTransactionBody } HieroProto.proto.IUtilPrngTransactionBody\n * @typedef {import(\"@hashgraph/proto\").proto.UtilPrngTransactionBody} HieroProto.proto.UtilPrngTransactionBody\n * @typedef {import(\"@hashgraph/proto\").proto.ITransactionResponse} HieroProto.proto.TransactionResponse\n * @typedef {import(\"@hashgraph/proto\").proto.TransactionBody} HieroProto.proto.TransactionBody\n * @typedef {import(\"@hashgraph/proto\").proto.ITransactionBody} HieroProto.proto.ITransactionBody\n * @typedef {import(\"./account/AccountId.js\").default} AccountId\n * @typedef {import(\"./transaction/TransactionId.js\").default} TransactionId\n */\n\n/**\n * @typedef {import(\"./client/Client.js\").default<*, *>} Client\n *  @typedef {import(\"./channel/Channel.js\").default} Channel\n */\n\n/**\n * Gets a pseudorandom 32-bit number. Not cryptographically secure. See HIP-351 https://hips.hedera.com/hip/hip-351\n */\nexport default class PrngTransaction extends Transaction {\n    /**\n     * @param {object} props\n     * @param {?number } [props.range]\n     */\n    constructor(props = {}) {\n        super();\n\n        /**\n         * @private\n         * @type {?number}\n         */\n        this._range = null;\n\n        if (props.range != null) {\n            this.setRange(props.range);\n        }\n    }\n\n    /**\n     * @param {number} newRange\n     * @returns {this}\n     */\n    setRange(newRange) {\n        this._range = newRange;\n        return this;\n    }\n\n    get range() {\n        return this._range;\n    }\n\n    /**\n     * @param {Client} client\n     */\n    _validateChecksums(client) {\n        if (this._range != null && isNumber(this._range)) {\n            this._validateChecksums(client);\n        }\n    }\n\n    /**\n     * @override\n     * @internal\n     * @param {Channel} channel\n     * @param {HieroProto.proto.ITransaction} request\n     * @returns {Promise<HieroProto.proto.TransactionResponse>}\n     */\n    _execute(channel, request) {\n        return channel.util.prng(request);\n    }\n\n    /**\n     * @internal\n     * @param {HieroProto.proto.ITransaction[]} transactions\n     * @param {HieroProto.proto.ISignedTransaction[]} signedTransactions\n     * @param {TransactionId[]} transactionIds\n     * @param {AccountId[]} nodeIds\n     * @param {HieroProto.proto.ITransactionBody[]} bodies\n     * @returns {PrngTransaction}\n     */\n    static _fromProtobuf(\n        transactions,\n        signedTransactions,\n        transactionIds,\n        nodeIds,\n        bodies,\n    ) {\n        const body = /** @type {HieroProto.proto.ITransactionBody} */ (\n            bodies[0]\n        );\n        const transactionRange =\n            /** @type {HieroProto.proto.IUtilPrngTransactionBody} */ (\n                body.utilPrng\n            );\n        return Transaction._fromProtobufTransactions(\n            new PrngTransaction({\n                range: transactionRange.range,\n            }),\n            transactions,\n            signedTransactions,\n            transactionIds,\n            nodeIds,\n            bodies,\n        );\n    }\n\n    /**\n     * @override\n     * @protected\n     * @returns {NonNullable<HieroProto.proto.TransactionBody[\"data\"]>}\n     */\n    _getTransactionDataCase() {\n        return \"utilPrng\";\n    }\n\n    /**\n     * @override\n     * @protected\n     * @returns {HieroProto.proto.IUtilPrngTransactionBody}\n     */\n    _makeTransactionData() {\n        return {\n            range: this.range,\n        };\n    }\n\n    /**\n     * @returns {string}\n     */\n    _getLogId() {\n        const timestamp = /** @type {import(\"./Timestamp.js\").default} */ (\n            this._transactionIds.current.validStart\n        );\n        return `RandomGenerate:${timestamp.toString()}`;\n    }\n}\n\nTRANSACTION_REGISTRY.set(\n    \"utilPrng\",\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    PrngTransaction._fromProtobuf,\n);\n"],"names":["PrngTransaction","Transaction","constructor","props","super","this","_range","range","setRange","newRange","_validateChecksums","client","isNumber","_execute","channel","request","util","prng","_fromProtobuf","transactions","signedTransactions","transactionIds","nodeIds","bodies","transactionRange","_fromProtobufTransactions","_getTransactionDataCase","_makeTransactionData","_getLogId","_transactionIds","current","toString","TRANSACTION_REGISTRY","set"],"mappings":"4GA6Be,MAAMA,UAAwBC,EAKzC,WAAAC,CAAYC,EAAQ,IAChBC,QAMAC,KAAKC,OAAS,KAEK,MAAfH,EAAMI,OACNF,KAAKG,SAASL,EAAMI,MAEhC,CAMI,QAAAC,CAASC,GAEL,OADAJ,KAAKC,OAASG,EACPJ,IACf,CAEI,SAAIE,GACA,OAAOF,KAAKC,MACpB,CAKI,kBAAAI,CAAmBC,GACI,MAAfN,KAAKC,QAAkBM,EAASP,KAAKC,SACrCD,KAAKK,mBAAmBC,EAEpC,CASI,QAAAE,CAASC,EAASC,GACd,OAAOD,EAAQE,KAAKC,KAAKF,EACjC,CAWI,oBAAOG,CACHC,EACAC,EACAC,EACAC,EACAC,GAEA,MAGMC,EAFFD,EAAO,GAKN,SACL,OAAOtB,EAAYwB,0BACf,IAAIzB,EAAgB,CAChBO,MAAOiB,EAAiBjB,QAE5BY,EACAC,EACAC,EACAC,EACAC,EAEZ,CAOI,uBAAAG,GACI,MAAO,UACf,CAOI,oBAAAC,GACI,MAAO,CACHpB,MAAOF,KAAKE,MAExB,CAKI,SAAAqB,GAII,MAAO,kBAFHvB,KAAKwB,gBAAgBC,QACxB,WACkCC,YAC3C,EAGAC,EAAqBC,IACjB,WAEAjC,EAAgBkB"}

package/lib/Provider.cjs

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * @typedef {import("./LedgerId.js").default} LedgerId
+ * @typedef {import("./transaction/TransactionId.js").default} TransactionId
+ * @typedef {import("./transaction/Transaction.js").default} Transaction
+ * @typedef {import("./transaction/TransactionResponse.js").default} TransactionResponse
+ * @typedef {import("./transaction/TransactionReceipt.js").default} TransactionReceipt
+ * @typedef {import("./transaction/TransactionRecord.js").default} TransactionRecord
+ * @typedef {import("./account/AccountId.js").default} AccountId
+ * @typedef {import("./account/AccountBalance.js").default} AccountBalance
+ * @typedef {import("./account/AccountInfo.js").default} AccountInfo
+ */
+/**
+ * @template O
+ * @typedef {import("./query/Query.js").default<O>} Query<O>
+ */
+/**
+ * @template RequestT
+ * @template ResponseT
+ * @template OutputT
+ * @typedef {import("./Executable.js").default<RequestT, ResponseT, OutputT>} Executable<RequestT, ResponseT, OutputT>
+ */
+/**
+ * @typedef {object} Provider
+ * @property {() => LedgerId?} getLedgerId
+ * @property {() => {[key: string]: (string | AccountId)}} getNetwork
+ * @property {() => string[]} getMirrorNetwork
+ * @property {(accountId: AccountId | string) => Promise<AccountBalance>} getAccountBalance
+ * @property {(accountId: AccountId | string) => Promise<AccountInfo>} getAccountInfo
+ * @property {(accountId: AccountId | string) => Promise<TransactionRecord[]>} getAccountRecords
+ * @property {(transactionId: TransactionId | string) => Promise<TransactionReceipt>} getTransactionReceipt
+ * @property {(response: TransactionResponse) => Promise<TransactionReceipt>} waitForReceipt
+ * @property {<RequestT, ResponseT, OutputT>(request: Executable<RequestT, ResponseT, OutputT>) => Promise<OutputT>} call
+ */
+var _default = exports.default = {};