quantumcoin 7.0.3 → 7.0.4

package/src/index.d.ts

@@ -1,127 +1,125 @@
-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;
-}
+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;
+    hashMessage(message: 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;
+    verifyMessage(message: string | Uint8Array, signature: string): string;
+    recoverAddress(message: string | Uint8Array, signature: string): 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;
+    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/index.js

@@ -1,41 +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,
-};
-
+/**
+ * @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

@@ -1,61 +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;
+/**
+ * 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;