quantumcoin 6.14.5 → 7.0.2

package/src/index.d.ts

@@ -0,0 +1,127 @@
+declare const _exports: {
+    isError: typeof errors.isError;
+    isCallException: typeof errors.isCallException;
+    makeError: typeof errors.makeError;
+    assert: typeof errors.assert;
+    assertArgument: typeof errors.assertArgument;
+    ProviderError: typeof errors.ProviderError;
+    TransactionError: typeof errors.TransactionError;
+    ContractError: typeof errors.ContractError;
+    formatUnits: typeof import("./utils/units").formatUnits;
+    parseUnits: typeof import("./utils/units").parseUnits;
+    formatEther: typeof import("./utils/units").formatEther;
+    parseEther: typeof import("./utils/units").parseEther;
+    WeiPerEther: bigint;
+    Result: typeof import("./utils/result").Result;
+    checkResultErrors: typeof import("./utils/result").checkResultErrors;
+    encodeRlp: typeof import("./utils/rlp").encodeRlp;
+    decodeRlp: typeof import("./utils/rlp").decodeRlp;
+    keccak256: typeof import("./utils/hashing").keccak256;
+    sha256: typeof import("./utils/hashing").sha256;
+    sha512: typeof import("./utils/hashing").sha512;
+    ripemd160: typeof import("./utils/hashing").ripemd160;
+    id: typeof import("./utils/hashing").id;
+    randomBytes: typeof import("./utils/hashing").randomBytes;
+    computeHmac: typeof import("./utils/hashing").computeHmac;
+    pbkdf2: typeof import("./utils/hashing").pbkdf2;
+    scrypt: typeof import("./utils/hashing").scrypt;
+    scryptSync: typeof import("./utils/hashing").scryptSync;
+    toUtf8String: typeof import("./utils/encoding").toUtf8String;
+    toUtf8Bytes: typeof import("./utils/encoding").toUtf8Bytes;
+    toHex: typeof import("./utils/encoding").toHex;
+    hexlify: typeof import("./utils/encoding").hexlify;
+    arrayify: typeof import("./utils/encoding").arrayify;
+    concat: typeof import("./utils/encoding").concat;
+    stripZerosLeft: typeof import("./utils/encoding").stripZerosLeft;
+    encodeBytes32String: typeof import("./utils/encoding").encodeBytes32String;
+    decodeBytes32String: typeof import("./utils/encoding").decodeBytes32String;
+    decodeBase58: typeof import("./utils/encoding").decodeBase58;
+    decodeBase64: typeof import("./utils/encoding").decodeBase64;
+    encodeBase58: typeof import("./utils/encoding").encodeBase58;
+    encodeBase64: typeof import("./utils/encoding").encodeBase64;
+    toUtf8CodePoints: typeof import("./utils/encoding").toUtf8CodePoints;
+    isHexString: typeof import("./internal/hex").isHexString;
+    isBytesLike: typeof import("./utils/encoding").isBytesLike;
+    zeroPad: typeof import("./utils/encoding").zeroPad;
+    zeroPadValue: typeof import("./utils/encoding").zeroPadValue;
+    solidityPacked: typeof import("./utils/encoding").solidityPacked;
+    solidityPackedKeccak256: typeof import("./utils/encoding").solidityPackedKeccak256;
+    solidityPackedSha256: typeof import("./utils/encoding").solidityPackedSha256;
+    bytesToHex: typeof import("./internal/hex").bytesToHex;
+    hexToBytes: typeof import("./internal/hex").hexToBytes;
+    isAddress: typeof import("./utils/address").isAddress;
+    getAddress: typeof import("./utils/address").getAddress;
+    isAddressable: typeof import("./utils/address").isAddressable;
+    resolveAddress: typeof import("./utils/address").resolveAddress;
+    getContractAddress: typeof import("./utils/address").getContractAddress;
+    getCreateAddress: typeof import("./utils/address").getCreateAddress;
+    getCreate2Address: typeof import("./utils/address").getCreate2Address;
+    computeAddress: typeof import("./utils/address").computeAddress;
+    verifyMessage: typeof import("./utils/address").verifyMessage;
+    recoverAddress: typeof import("./utils/address").recoverAddress;
+    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;
+    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;
+    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");
+
+// ---------------------------------------------------------------------------
+// Core Solidity typing exports (type-only)
+// ---------------------------------------------------------------------------
+declare namespace _exports {
+    export type AddressLike = import("./types").AddressLike;
+    export type BytesLike = import("./types").BytesLike;
+    export type Bytes32Like = import("./types").Bytes32Like;
+    export type BigNumberish = import("./types").BigNumberish;
+    export type HexString = import("./types").HexString;
+    export type SolidityTypeName = import("./types").SolidityTypeName;
+    export type SolidityInputValue<T extends SolidityTypeName> = import("./types").SolidityInputValue<T>;
+    export type SolidityOutputValue<T extends SolidityTypeName> = import("./types").SolidityOutputValue<T>;
+    export type SolidityTuple = import("./types").SolidityTuple;
+    export type SolidityStruct = import("./types").SolidityStruct;
+}

package/src/index.js

@@ -0,0 +1,41 @@
+/**
+ * @fileoverview QuantumCoin.js main entrypoint (ethers.js v6 compatible API surface).
+ *
+ * IMPORTANT: Call `Initialize()` (from `quantumcoin/config`) before using
+ * any functionality that relies on `quantum-coin-js-sdk` (address validation,
+ * ABI packing/unpacking, signing, etc.).
+ */
+
+// Core constants
+const constants = require("./constants");
+
+// Modules
+const providers = require("./providers");
+const wallet = require("./wallet");
+const contract = require("./contract");
+const abi = require("./abi");
+const utils = require("./utils");
+const errors = require("./errors");
+
+module.exports = {
+  ...constants,
+
+  // Providers
+  ...providers,
+
+  // Wallet / signers
+  ...wallet,
+
+  // Contracts
+  ...contract,
+
+  // ABI
+  ...abi,
+
+  // Utils
+  ...utils,
+
+  // Errors
+  ...errors,
+};
+

package/src/internal/hex.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Return true if `value` is a Uint8Array.
+ * @param {any} value
+ * @returns {value is Uint8Array}
+ */
+export function isUint8Array(value: any): value is Uint8Array;
+/**
+ * Normalize a hex string.
+ * @param {string} hex
+ * @returns {string}
+ */
+export function normalizeHex(hex: string): string;
+/**
+ * Returns true if value is a hex string.
+ * @param {any} value
+ * @param {number=} lengthBytes Optional exact byte length.
+ * @returns {boolean}
+ */
+export function isHexString(value: any, lengthBytes?: number | undefined): boolean;
+/**
+ * Strip 0x prefix.
+ * @param {string} hex
+ * @returns {string}
+ */
+export function strip0x(hex: string): string;
+/**
+ * Ensure a 0x prefix.
+ * @param {string} hex
+ * @returns {string}
+ */
+export function add0x(hex: string): string;
+/**
+ * Convert a hex string to bytes.
+ * @param {string} hex
+ * @returns {Uint8Array}
+ */
+export function hexToBytes(hex: string): Uint8Array;
+/**
+ * Convert bytes to hex string.
+ * @param {Uint8Array} bytes
+ * @returns {string}
+ */
+export function bytesToHex(bytes: Uint8Array): string;
+/**
+ * UTF-8 encode a string to bytes.
+ * @param {string} str
+ * @returns {Uint8Array}
+ */
+export function utf8ToBytes(str: string): Uint8Array;
+/**
+ * UTF-8 decode bytes to a string.
+ * @param {Uint8Array} bytes
+ * @returns {string}
+ */
+export function bytesToUtf8(bytes: Uint8Array): string;
+/**
+ * Convert BytesLike to Uint8Array.
+ * @param {string | Uint8Array} data
+ * @returns {Uint8Array}
+ */
+export function arrayify(data: string | Uint8Array): Uint8Array;

package/src/internal/hex.js

@@ -0,0 +1,144 @@
+/**
+ * @fileoverview Internal hex and bytes helpers.
+ *
+ * IMPORTANT:
+ * - This module intentionally avoids external dependencies.
+ * - All hex strings in this SDK are normalized to lowercase with a `0x` prefix.
+ */
+
+const { TextEncoder, TextDecoder } = require("util");
+
+/** @type {TextEncoder} */
+const _utf8Encoder = new TextEncoder();
+/** @type {TextDecoder} */
+const _utf8Decoder = new TextDecoder("utf-8", { fatal: false });
+
+/**
+ * Return true if `value` is a Uint8Array.
+ * @param {any} value
+ * @returns {value is Uint8Array}
+ */
+function isUint8Array(value) {
+  return value instanceof Uint8Array;
+}
+
+/**
+ * Normalize a hex string.
+ * @param {string} hex
+ * @returns {string}
+ */
+function normalizeHex(hex) {
+  if (typeof hex !== "string") throw new TypeError("hex must be a string");
+  let h = hex.toLowerCase();
+  if (!h.startsWith("0x")) h = "0x" + h;
+  if (h.length % 2 !== 0) h = "0x0" + h.slice(2);
+  return h;
+}
+
+/**
+ * Returns true if value is a hex string.
+ * @param {any} value
+ * @param {number=} lengthBytes Optional exact byte length.
+ * @returns {boolean}
+ */
+function isHexString(value, lengthBytes) {
+  if (typeof value !== "string") return false;
+  const v = value.startsWith("0x") ? value.slice(2) : value;
+  if (v.length === 0) return false;
+  if (!/^[0-9a-fA-F]+$/.test(v)) return false;
+  if (v.length % 2 !== 0) return false;
+  if (lengthBytes != null) return v.length === lengthBytes * 2;
+  return true;
+}
+
+/**
+ * Strip 0x prefix.
+ * @param {string} hex
+ * @returns {string}
+ */
+function strip0x(hex) {
+  if (typeof hex !== "string") throw new TypeError("hex must be a string");
+  return hex.startsWith("0x") ? hex.slice(2) : hex;
+}
+
+/**
+ * Ensure a 0x prefix.
+ * @param {string} hex
+ * @returns {string}
+ */
+function add0x(hex) {
+  if (typeof hex !== "string") throw new TypeError("hex must be a string");
+  return hex.startsWith("0x") ? hex : "0x" + hex;
+}
+
+/**
+ * Convert a hex string to bytes.
+ * @param {string} hex
+ * @returns {Uint8Array}
+ */
+function hexToBytes(hex) {
+  if (!isHexString(hex)) throw new TypeError("invalid hex string");
+  const h = strip0x(hex);
+  const out = new Uint8Array(h.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = parseInt(h.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
+
+/**
+ * Convert bytes to hex string.
+ * @param {Uint8Array} bytes
+ * @returns {string}
+ */
+function bytesToHex(bytes) {
+  if (!isUint8Array(bytes)) throw new TypeError("bytes must be Uint8Array");
+  let out = "0x";
+  for (const b of bytes) out += b.toString(16).padStart(2, "0");
+  return out;
+}
+
+/**
+ * UTF-8 encode a string to bytes.
+ * @param {string} str
+ * @returns {Uint8Array}
+ */
+function utf8ToBytes(str) {
+  if (typeof str !== "string") throw new TypeError("str must be a string");
+  return _utf8Encoder.encode(str);
+}
+
+/**
+ * UTF-8 decode bytes to a string.
+ * @param {Uint8Array} bytes
+ * @returns {string}
+ */
+function bytesToUtf8(bytes) {
+  if (!isUint8Array(bytes)) throw new TypeError("bytes must be Uint8Array");
+  return _utf8Decoder.decode(bytes);
+}
+
+/**
+ * Convert BytesLike to Uint8Array.
+ * @param {string | Uint8Array} data
+ * @returns {Uint8Array}
+ */
+function arrayify(data) {
+  if (typeof data === "string") return hexToBytes(data);
+  if (isUint8Array(data)) return new Uint8Array(data);
+  throw new TypeError("unsupported BytesLike");
+}
+
+module.exports = {
+  isUint8Array,
+  normalizeHex,
+  isHexString,
+  strip0x,
+  add0x,
+  hexToBytes,
+  bytesToHex,
+  utf8ToBytes,
+  bytesToUtf8,
+  arrayify,
+};
+

package/src/providers/extra-providers.d.ts

@@ -0,0 +1,128 @@
+export class WebSocketProvider extends AbstractProvider {
+    /**
+     * Create a WebSocket JSON-RPC provider.
+     *
+     * This uses the built-in global `WebSocket` available in recent Node.js
+     * versions (via undici). No additional npm dependencies are required.
+     *
+     * @param {string} url WebSocket endpoint (e.g. ws://127.0.0.1:8546)
+     * @param {number=} chainId Optional chain id (compat)
+     */
+    constructor(url: string, chainId?: number | undefined);
+    url: string;
+    chainId: number;
+    /** @type {any|null} */
+    _ws: any | null;
+    /** @type {Promise<void>|null} */
+    _wsReady: Promise<void> | null;
+    /** @type {Map<number, { resolve: Function, reject: Function, timer: any }>} */
+    _pending: Map<number, {
+        resolve: Function;
+        reject: Function;
+        timer: any;
+    }>;
+    /**
+     * Close the underlying WebSocket connection and reject any pending requests.
+     * This is important for tests so the Node.js event loop can exit cleanly.
+     */
+    destroy(): void;
+    _rejectAllPending(err: any): void;
+    _connect(): Promise<void>;
+}
+export class IpcSocketProvider extends AbstractProvider {
+    /**
+     * Create an IPC provider.
+     *
+     * On Windows, use a named pipe path like: `\\\\.\\pipe\\geth.ipc`
+     * On Unix, use a domain socket path like: `/path/to/geth.ipc`
+     *
+     * @param {string} path IPC socket path
+     */
+    constructor(path: string);
+    path: string;
+}
+export class BrowserProvider extends AbstractProvider {
+    /**
+     * Create a BrowserProvider from an EIP-1193 provider (e.g. MetaMask).
+     *
+     * This is a lightweight implementation that focuses on the core behaviors:
+     * - `send(method, params)` dispatches EIP-1193 requests
+     * - `getSigner()` resolves the connected account
+     * - emits ethers-like `debug` events for request/response tracking
+     *
+     * @param {{ request: Function }} eip1193Provider
+     * @param {any=} network Unused (compat)
+     * @param {{ providerInfo?: any }=} options
+     */
+    constructor(eip1193Provider: {
+        request: Function;
+    }, network?: any | undefined, options?: {
+        providerInfo?: any;
+    } | undefined);
+    provider: {
+        request: Function;
+    };
+    providerInfo: any;
+    /**
+     * Send an EIP-1193 JSON-RPC request.
+     * @param {string} method
+     * @param {any[]|Record<string, any>=} params
+     * @returns {Promise<any>}
+     */
+    send(method: string, params?: (any[] | Record<string, any>) | undefined): Promise<any>;
+    /**
+     * Map an EIP-1193 error into a normalized Error.
+     * @param {{ method: string, params?: any }} payload
+     * @param {any} error
+     * @returns {Error}
+     */
+    getRpcError(payload: {
+        method: string;
+        params?: any;
+    }, error: any): Error;
+    /**
+     * Ethers compatibility: internal send for single or batched payloads.
+     * @param {any|any[]} payload
+     * @returns {Promise<any>}
+     */
+    _send(payload: any | any[]): Promise<any>;
+    /**
+     * Returns a signer for the specified account index or address.
+     * @param {number|string=} address
+     * @returns {Promise<JsonRpcSigner>}
+     */
+    getSigner(address?: (number | string) | undefined): Promise<JsonRpcSigner>;
+    /**
+     * Resolve whether this provider manages the address/index.
+     * @param {number|string} address
+     * @returns {Promise<boolean>}
+     */
+    hasSigner(address: number | string): Promise<boolean>;
+}
+/**
+ * FallbackProvider - uses the first provider in the list.
+ */
+export class FallbackProvider extends AbstractProvider {
+    /**
+     * @param {AbstractProvider[]|AbstractProvider} providers
+     */
+    constructor(providers: AbstractProvider[] | AbstractProvider);
+    providers: AbstractProvider[];
+    _perform(method: any, params: any): Promise<any>;
+}
+/**
+ * FilterByBlockHash placeholder.
+ */
+export class FilterByBlockHash {
+    constructor(blockHash: any, address: any, topics: any);
+    blockHash: string;
+    address: any;
+    topics: any;
+    toJSON(): {
+        blockHash: string;
+        address: any;
+        topics: any;
+    };
+}
+import { AbstractProvider } from "./provider";
+import { JsonRpcSigner } from "../wallet/wallet";