quantumcoin 7.0.15 → 8.0.1

package/src/index.d.ts

@@ -1,123 +1,128 @@
-declare const _exports: {
-    isError(error: any, code: string): boolean;
-    isCallException(error: any): boolean;
-    makeError(message: string, code: errors.ErrorCode, info?: Record<string, any> | undefined): Error & {
-        code: errors.ErrorCode;
-        shortMessage: string;
-    };
-    assert(check: any, message: string, code: errors.ErrorCode, info?: Record<string, any> | undefined): void;
-    assertArgument(check: any, message: string, name: string, value: any): void;
-    ProviderError: typeof errors.ProviderError;
-    TransactionError: typeof errors.TransactionError;
-    ContractError: typeof errors.ContractError;
-    formatUnits(value: import("./utils/units").BigNumberish, decimals?: number | undefined): string;
-    parseUnits(value: string, decimals?: number | undefined): bigint;
-    formatEther(value: import("./utils/units").BigNumberish): string;
-    parseEther(value: string): bigint;
-    WeiPerEther: bigint;
-    checkResultErrors(result: any): Array<{
-        error: Error;
-        path: Array<string | number>;
-    }>;
-    Result: typeof import("./utils/result").Result;
-    encodeRlp(value: any): string;
-    decodeRlp(data: string): any;
-    keccak256(data: string | Uint8Array): string;
-    sha256(data: string | Uint8Array): string;
-    sha512(data: string | Uint8Array): string;
-    ripemd160(data: string | Uint8Array): string;
-    id(text: string): string;
-    randomBytes(length: number): Uint8Array;
-    computeHmac(algorithm: string, key: string | Uint8Array, data: string | Uint8Array): string;
-    pbkdf2(password: string | Uint8Array, salt: string | Uint8Array, iterations: number, keylen: number, algorithm?: string | undefined): string;
-    scrypt(password: string | Uint8Array, salt: string | Uint8Array, N: number, r: number, p: number, dkLen: number): Promise<string>;
-    scryptSync(password: string | Uint8Array, salt: string | Uint8Array, N: number, r: number, p: number, dkLen: number): string;
-    toUtf8String(data: import("./utils/encoding").BytesLike): string;
-    toUtf8Bytes(str: string): Uint8Array;
-    toHex(data: import("./utils/encoding").BytesLike): string;
-    hexlify(data: import("./utils/encoding").BytesLike): string;
-    arrayify(data: import("./utils/encoding").BytesLike): Uint8Array;
-    concat(items: import("./utils/encoding").BytesLike[]): string;
-    stripZerosLeft(data: import("./utils/encoding").BytesLike): string;
-    encodeBytes32String(text: string): string;
-    decodeBytes32String(bytes: import("./utils/encoding").BytesLike): string;
-    decodeBase58(data: string): Uint8Array;
-    decodeBase64(data: string): Uint8Array;
-    encodeBase58(data: import("./utils/encoding").BytesLike): string;
-    encodeBase64(data: import("./utils/encoding").BytesLike): string;
-    toUtf8CodePoints(str: string): number[];
-    isBytesLike(value: any): boolean;
-    zeroPad(value: import("./utils/encoding").BytesLike, length: number): string;
-    zeroPadValue(value: import("./utils/encoding").BytesLike, length: number): string;
-    solidityPacked(): void;
-    solidityPackedKeccak256(): void;
-    solidityPackedSha256(): void;
-    isHexString: typeof import("./internal/hex").isHexString;
-    bytesToHex: typeof import("./internal/hex").bytesToHex;
-    hexToBytes: typeof import("./internal/hex").hexToBytes;
-    isAddress(address: string): boolean;
-    getAddress(address: string): string;
-    isAddressable(value: any): boolean;
-    resolveAddress(target: any): string | Promise<string>;
-    getContractAddress(tx: {
-        from: string;
-        nonce: number;
-    }): string;
-    getCreateAddress(tx: {
-        from: string;
-        nonce: number;
-    }): string;
-    getCreate2Address(from: string, salt: string, initCodeHash: string): string;
-    computeAddress(key: string | Uint8Array): string;
-    Interface: typeof import("./abi/interface").Interface;
-    AbiCoder: typeof import("./abi/interface").AbiCoder;
-    Fragment: typeof import("./abi/fragments").Fragment;
-    NamedFragment: typeof import("./abi/fragments").NamedFragment;
-    FunctionFragment: typeof import("./abi/fragments").FunctionFragment;
-    EventFragment: typeof import("./abi/fragments").EventFragment;
-    ErrorFragment: typeof import("./abi/fragments").ErrorFragment;
-    ConstructorFragment: typeof import("./abi/fragments").ConstructorFragment;
-    StructFragment: typeof import("./abi/fragments").StructFragment;
-    FallbackFragment: typeof import("./abi/fragments").FallbackFragment;
-    ContractFactory: typeof import("./contract/contract-factory").ContractFactory;
-    BaseContract: typeof import("./contract/contract").BaseContract;
-    Contract: typeof import("./contract/contract").Contract;
-    ContractTransactionResponse: typeof import("./contract/contract").ContractTransactionResponse;
-    ContractTransactionReceipt: typeof import("./contract/contract").ContractTransactionReceipt;
-    EventLog: typeof import("./contract/contract").EventLog;
-    SigningKey: typeof import("./wallet/wallet").SigningKey;
-    AbstractSigner: typeof import("./wallet/wallet").AbstractSigner;
-    BaseWallet: typeof import("./wallet/wallet").BaseWallet;
-    Wallet: typeof import("./wallet/wallet").Wallet;
-    NonceManager: typeof import("./wallet/wallet").NonceManager;
-    JsonRpcSigner: typeof import("./wallet/wallet").JsonRpcSigner;
-    VoidSigner: typeof import("./wallet/wallet").VoidSigner;
-    getProvider(endpoint?: string | undefined, chainId?: number | undefined): import("./providers/provider").AbstractProvider;
-    WebSocketProvider: typeof import("./providers/extra-providers").WebSocketProvider;
-    IpcSocketProvider: typeof import("./providers/extra-providers").IpcSocketProvider;
-    BrowserProvider: typeof import("./providers/extra-providers").BrowserProvider;
-    FallbackProvider: typeof import("./providers/extra-providers").FallbackProvider;
-    FilterByBlockHash: typeof import("./providers/extra-providers").FilterByBlockHash;
-    JsonRpcProvider: typeof import("./providers/json-rpc-provider").JsonRpcProvider;
-    JsonRpcApiProvider: typeof import("./providers/json-rpc-provider").JsonRpcApiProvider;
-    Provider: typeof import("./providers/provider").Provider;
-    AbstractProvider: typeof import("./providers/provider").AbstractProvider;
-    Block: typeof import("./providers/provider").Block;
-    TransactionResponse: typeof import("./providers/provider").TransactionResponse;
-    TransactionReceipt: typeof import("./providers/provider").TransactionReceipt;
-    Log: typeof import("./providers/provider").Log;
-    FeeData: typeof import("./providers/provider").FeeData;
-    version: string;
-    ZeroAddress: string;
-    ZeroHash: string;
-    MaxUint256: bigint;
-    MaxUint160: bigint;
-    MinInt256: bigint;
-    MaxInt256: bigint;
-    NumericFault: string;
-    NumericFaultCode: string;
-    EtherSymbol: string;
-    N: bigint;
-};
-export = _exports;
-import errors = require("./errors");
+declare const _exports: {
+    isError(error: any, code: string): boolean;
+    isCallException(error: any): boolean;
+    makeError(message: string, code: errors.ErrorCode, info?: Record<string, any> | undefined): Error & {
+        code: errors.ErrorCode;
+        shortMessage: string;
+    };
+    assert(check: any, message: string, code: errors.ErrorCode, info?: Record<string, any> | undefined): void;
+    assertArgument(check: any, message: string, name: string, value: any): void;
+    assertSecretArgument(check: any, message: string, name: string): void;
+    ProviderError: typeof errors.ProviderError;
+    TransactionError: typeof errors.TransactionError;
+    ContractError: typeof errors.ContractError;
+    FixedNumber: typeof import("./utils/fixednumber").FixedNumber;
+    formatUnits(value: import("./utils/units").BigNumberish, decimals?: number | undefined): string;
+    parseUnits(value: string, decimals?: number | undefined): bigint;
+    formatEther(value: import("./utils/units").BigNumberish): string;
+    parseEther(value: string): bigint;
+    WeiPerEther: bigint;
+    checkResultErrors(result: any): Array<{
+        error: Error;
+        path: Array<string | number>;
+    }>;
+    Result: typeof import("./utils/result").Result;
+    encodeRlp(value: any): string;
+    decodeRlp(data: string): any;
+    keccak256(data: string | Uint8Array): string;
+    sha256(data: string | Uint8Array): string;
+    sha512(data: string | Uint8Array): string;
+    ripemd160(data: string | Uint8Array): string;
+    id(text: string): string;
+    hashMessage(message: string | Uint8Array): string;
+    randomBytes(length: number): Uint8Array;
+    computeHmac(algorithm: string, key: string | Uint8Array, data: string | Uint8Array): string;
+    pbkdf2(password: string | Uint8Array, salt: string | Uint8Array, iterations: number, keylen: number, algorithm?: string | undefined): string;
+    scrypt(password: string | Uint8Array, salt: string | Uint8Array, N: number, r: number, p: number, dkLen: number): Promise<string>;
+    scryptSync(password: string | Uint8Array, salt: string | Uint8Array, N: number, r: number, p: number, dkLen: number): string;
+    toUtf8String(data: import("./utils/encoding").BytesLike): string;
+    toUtf8Bytes(str: string): Uint8Array;
+    toHex(data: import("./utils/encoding").BytesLike): string;
+    hexlify(data: import("./utils/encoding").BytesLike): string;
+    arrayify(data: import("./utils/encoding").BytesLike): Uint8Array;
+    concat(items: import("./utils/encoding").BytesLike[]): string;
+    stripZerosLeft(data: import("./utils/encoding").BytesLike): string;
+    encodeBytes32String(text: string): string;
+    decodeBytes32String(bytes: import("./utils/encoding").BytesLike): string;
+    decodeBase58(data: string): Uint8Array;
+    decodeBase64(data: string): Uint8Array;
+    encodeBase58(data: import("./utils/encoding").BytesLike): string;
+    encodeBase64(data: import("./utils/encoding").BytesLike): string;
+    toUtf8CodePoints(str: string): number[];
+    isBytesLike(value: any): boolean;
+    zeroPad(value: import("./utils/encoding").BytesLike, length: number): string;
+    zeroPadValue(value: import("./utils/encoding").BytesLike, length: number): string;
+    solidityPacked(): void;
+    solidityPackedKeccak256(): void;
+    solidityPackedSha256(): void;
+    isHexString: typeof import("./internal/hex").isHexString;
+    bytesToHex: typeof import("./internal/hex").bytesToHex;
+    hexToBytes: typeof import("./internal/hex").hexToBytes;
+    isAddress(address: string): boolean;
+    getAddress(address: string): string;
+    isAddressable(value: any): boolean;
+    resolveAddress(target: any): string | Promise<string>;
+    getContractAddress(tx: {
+        from: string;
+        nonce: number;
+    }): string;
+    getCreateAddress(tx: {
+        from: string;
+        nonce: number;
+    }): string;
+    getCreate2Address(from: string, salt: string, initCodeHash: string): string;
+    computeAddress(key: string | Uint8Array): string;
+    Interface: typeof import("./abi/interface").Interface;
+    AbiCoder: typeof import("./abi/interface").AbiCoder;
+    Fragment: typeof import("./abi/fragments").Fragment;
+    NamedFragment: typeof import("./abi/fragments").NamedFragment;
+    FunctionFragment: typeof import("./abi/fragments").FunctionFragment;
+    EventFragment: typeof import("./abi/fragments").EventFragment;
+    ErrorFragment: typeof import("./abi/fragments").ErrorFragment;
+    ConstructorFragment: typeof import("./abi/fragments").ConstructorFragment;
+    StructFragment: typeof import("./abi/fragments").StructFragment;
+    FallbackFragment: typeof import("./abi/fragments").FallbackFragment;
+    ContractFactory: typeof import("./contract/contract-factory").ContractFactory;
+    _sanitizeOverrides(overrides: any): Record<string, any>;
+    BaseContract: typeof import("./contract/contract").BaseContract;
+    Contract: typeof import("./contract/contract").Contract;
+    ContractTransactionResponse: typeof import("./contract/contract").ContractTransactionResponse;
+    ContractTransactionReceipt: typeof import("./contract/contract").ContractTransactionReceipt;
+    EventLog: typeof import("./contract/contract").EventLog;
+    verifyMessage(message: string | Uint8Array, signature: string | Uint8Array): string;
+    SigningKey: typeof import("./wallet/wallet").SigningKey;
+    AbstractSigner: typeof import("./wallet/wallet").AbstractSigner;
+    BaseWallet: typeof import("./wallet/wallet").BaseWallet;
+    Wallet: typeof import("./wallet/wallet").Wallet;
+    NonceManager: typeof import("./wallet/wallet").NonceManager;
+    JsonRpcSigner: typeof import("./wallet/wallet").JsonRpcSigner;
+    VoidSigner: typeof import("./wallet/wallet").VoidSigner;
+    getProvider(endpoint?: string | undefined, chainId?: number | undefined): import("./providers/provider").AbstractProvider;
+    WebSocketProvider: typeof import("./providers/extra-providers").WebSocketProvider;
+    IpcSocketProvider: typeof import("./providers/extra-providers").IpcSocketProvider;
+    BrowserProvider: typeof import("./providers/extra-providers").BrowserProvider;
+    FallbackProvider: typeof import("./providers/extra-providers").FallbackProvider;
+    FilterByBlockHash: typeof import("./providers/extra-providers").FilterByBlockHash;
+    JsonRpcProvider: typeof import("./providers/json-rpc-provider").JsonRpcProvider;
+    JsonRpcApiProvider: typeof import("./providers/json-rpc-provider").JsonRpcApiProvider;
+    Provider: typeof import("./providers/provider").Provider;
+    AbstractProvider: typeof import("./providers/provider").AbstractProvider;
+    Block: typeof import("./providers/provider").Block;
+    TransactionResponse: typeof import("./providers/provider").TransactionResponse;
+    TransactionReceipt: typeof import("./providers/provider").TransactionReceipt;
+    Log: typeof import("./providers/provider").Log;
+    FeeData: typeof import("./providers/provider").FeeData;
+    version: string;
+    ZeroAddress: string;
+    ZeroHash: string;
+    MaxUint256: bigint;
+    MaxUint160: bigint;
+    MinInt256: bigint;
+    MaxInt256: bigint;
+    NumericFault: string;
+    NumericFaultCode: string;
+    EtherSymbol: string;
+    N: bigint;
+};
+export = _exports;
+import errors = require("./errors");

package/src/internal/event-emitter.d.ts

@@ -0,0 +1,76 @@
+export = EventEmitter;
+/**
+ * @fileoverview Minimal, dependency-free EventEmitter.
+ *
+ * This mirrors the subset of the Node.js `events.EventEmitter` API used by the
+ * SDK's providers and contracts, so the main import path does not depend on the
+ * Node built-in `events` module and can run in the browser.
+ */
+declare class EventEmitter {
+    /** @type {Map<string|symbol, Function[]>} */
+    _events: Map<string | symbol, Function[]>;
+    /**
+     * @param {string|symbol} event
+     * @param {Function} listener
+     * @returns {this}
+     */
+    addListener(event: string | symbol, listener: Function): this;
+    /**
+     * @param {string|symbol} event
+     * @param {Function} listener
+     * @returns {this}
+     */
+    on(event: string | symbol, listener: Function): this;
+    /**
+     * @param {string|symbol} event
+     * @param {Function} listener
+     * @returns {this}
+     */
+    prependListener(event: string | symbol, listener: Function): this;
+    /**
+     * @param {string|symbol} event
+     * @param {Function} listener
+     * @returns {this}
+     */
+    once(event: string | symbol, listener: Function): this;
+    /**
+     * @param {string|symbol} event
+     * @param {Function} listener
+     * @returns {this}
+     */
+    removeListener(event: string | symbol, listener: Function): this;
+    /**
+     * @param {string|symbol} event
+     * @param {Function} listener
+     * @returns {this}
+     */
+    off(event: string | symbol, listener: Function): this;
+    /**
+     * @param {(string|symbol)=} event
+     * @returns {this}
+     */
+    removeAllListeners(event?: (string | symbol) | undefined): this;
+    /**
+     * @param {string|symbol} event
+     * @param {...any} args
+     * @returns {boolean}
+     */
+    emit(event: string | symbol, ...args: any[]): boolean;
+    /**
+     * @param {string|symbol} event
+     * @returns {Function[]}
+     */
+    listeners(event: string | symbol): Function[];
+    /**
+     * @param {string|symbol} event
+     * @returns {number}
+     */
+    listenerCount(event: string | symbol): number;
+    /**
+     * @returns {(string|symbol)[]}
+     */
+    eventNames(): (string | symbol)[];
+}
+declare namespace EventEmitter {
+    export { EventEmitter };
+}

package/src/internal/event-emitter.js

@@ -0,0 +1,144 @@
+/**
+ * @fileoverview Minimal, dependency-free EventEmitter.
+ *
+ * This mirrors the subset of the Node.js `events.EventEmitter` API used by the
+ * SDK's providers and contracts, so the main import path does not depend on the
+ * Node built-in `events` module and can run in the browser.
+ */
+
+class EventEmitter {
+  constructor() {
+    /** @type {Map<string|symbol, Function[]>} */
+    this._events = new Map();
+  }
+
+  /**
+   * @param {string|symbol} event
+   * @param {Function} listener
+   * @returns {this}
+   */
+  addListener(event, listener) {
+    return this.on(event, listener);
+  }
+
+  /**
+   * @param {string|symbol} event
+   * @param {Function} listener
+   * @returns {this}
+   */
+  on(event, listener) {
+    if (typeof listener !== "function") throw new TypeError("listener must be a function");
+    const list = this._events.get(event);
+    if (list) list.push(listener);
+    else this._events.set(event, [listener]);
+    return this;
+  }
+
+  /**
+   * @param {string|symbol} event
+   * @param {Function} listener
+   * @returns {this}
+   */
+  prependListener(event, listener) {
+    if (typeof listener !== "function") throw new TypeError("listener must be a function");
+    const list = this._events.get(event);
+    if (list) list.unshift(listener);
+    else this._events.set(event, [listener]);
+    return this;
+  }
+
+  /**
+   * @param {string|symbol} event
+   * @param {Function} listener
+   * @returns {this}
+   */
+  once(event, listener) {
+    if (typeof listener !== "function") throw new TypeError("listener must be a function");
+    const wrapper = (...args) => {
+      this.removeListener(event, wrapper);
+      listener.apply(this, args);
+    };
+    // Preserve a reference so removeListener(original) also works.
+    wrapper.listener = listener;
+    return this.on(event, wrapper);
+  }
+
+  /**
+   * @param {string|symbol} event
+   * @param {Function} listener
+   * @returns {this}
+   */
+  removeListener(event, listener) {
+    const list = this._events.get(event);
+    if (!list) return this;
+    for (let i = list.length - 1; i >= 0; i--) {
+      if (list[i] === listener || list[i].listener === listener) {
+        list.splice(i, 1);
+      }
+    }
+    if (list.length === 0) this._events.delete(event);
+    return this;
+  }
+
+  /**
+   * @param {string|symbol} event
+   * @param {Function} listener
+   * @returns {this}
+   */
+  off(event, listener) {
+    return this.removeListener(event, listener);
+  }
+
+  /**
+   * @param {(string|symbol)=} event
+   * @returns {this}
+   */
+  removeAllListeners(event) {
+    if (event === undefined) this._events.clear();
+    else this._events.delete(event);
+    return this;
+  }
+
+  /**
+   * @param {string|symbol} event
+   * @param {...any} args
+   * @returns {boolean}
+   */
+  emit(event, ...args) {
+    const list = this._events.get(event);
+    if (!list || list.length === 0) return false;
+    // Copy to tolerate mutation (e.g. once listeners) during iteration.
+    for (const listener of list.slice()) {
+      listener.apply(this, args);
+    }
+    return true;
+  }
+
+  /**
+   * @param {string|symbol} event
+   * @returns {Function[]}
+   */
+  listeners(event) {
+    const list = this._events.get(event);
+    return list ? list.slice() : [];
+  }
+
+  /**
+   * @param {string|symbol} event
+   * @returns {number}
+   */
+  listenerCount(event) {
+    const list = this._events.get(event);
+    return list ? list.length : 0;
+  }
+
+  /**
+   * @returns {(string|symbol)[]}
+   */
+  eventNames() {
+    return Array.from(this._events.keys());
+  }
+}
+
+module.exports = EventEmitter;
+module.exports.EventEmitter = EventEmitter;

package/src/internal/hex.d.ts

@@ -11,12 +11,35 @@ export function isUint8Array(value: any): value is Uint8Array;
  */
 export function normalizeHex(hex: string): string;
 /**
- * Format a number/bigint as a JSON-RPC QUANTITY hex string (no leading zeros).
- * @param value
+ * Format a number/bigint as a JSON-RPC QUANTITY hex string.
+ *
+ * Per the Ethereum JSON-RPC spec, quantities use the most compact
+ * representation with no leading zeros, with the single exception that
+ * zero is encoded as "0x0".
+ *
+ * Use this for block numbers, gas amounts, nonces, balances, and other
+ * numeric RPC parameters. Do NOT use it for DATA hex (addresses,
+ * bytecode, byte-arrays) — use `normalizeHex` for those.
+ *
+ * @param {number|bigint} value
+ * @returns {string}
  */
 export function toQuantityHex(value: number | bigint): string;
-/** Alias of `toQuantityHex` matching ethers.js v6 naming. */
-export const toQuantity: typeof toQuantityHex;
+/**
+ * Format a number/bigint as a JSON-RPC QUANTITY hex string.
+ *
+ * Per the Ethereum JSON-RPC spec, quantities use the most compact
+ * representation with no leading zeros, with the single exception that
+ * zero is encoded as "0x0".
+ *
+ * Use this for block numbers, gas amounts, nonces, balances, and other
+ * numeric RPC parameters. Do NOT use it for DATA hex (addresses,
+ * bytecode, byte-arrays) — use `normalizeHex` for those.
+ *
+ * @param {number|bigint} value
+ * @returns {string}
+ */
+export function toQuantity(value: number | bigint): string;
 /**
  * Returns true if value is a hex string.
  * @param {any} value

package/src/internal/hex.js

@@ -6,12 +6,16 @@
  * - All hex strings in this SDK are normalized to lowercase with a `0x` prefix.
  */
 
-const { TextEncoder, TextDecoder } = require("util");
+// TextEncoder/TextDecoder are available as globals in modern browsers and in
+// Node.js 20+, so we use the platform globals instead of requiring "util".
+// This keeps the module free of Node built-ins and usable in the browser.
+const _TextEncoder = globalThis.TextEncoder;
+const _TextDecoder = globalThis.TextDecoder;
 
 /** @type {TextEncoder} */
-const _utf8Encoder = new TextEncoder();
+const _utf8Encoder = new _TextEncoder();
 /** @type {TextDecoder} */
-const _utf8Decoder = new TextDecoder("utf-8", { fatal: false });
+const _utf8Decoder = new _TextDecoder("utf-8", { fatal: false });
 
 /**
  * Return true if `value` is a Uint8Array.