quantumcoin 6.14.5 → 7.0.2

package/src.ts/providers/subscriber-polling.ts

@@ -1,321 +0,0 @@
-import { assert, isHexString } from "../utils/index.js";
-
-import type { AbstractProvider, Subscriber } from "./abstract-provider.js";
-import type { EventFilter, OrphanFilter, ProviderEvent } from "./provider.js";
-
-function copy(obj: any): any {
-    return JSON.parse(JSON.stringify(obj));
-}
-
-/**
- *  Return the polling subscriber for common events.
- *
- *  @_docloc: api/providers/abstract-provider
- */
-export function getPollingSubscriber(provider: AbstractProvider, event: ProviderEvent): Subscriber {
-    if (event === "block") { return new PollingBlockSubscriber(provider); }
-    if (isHexString(event, 32)) { return new PollingTransactionSubscriber(provider, event); }
-
-    assert(false, "unsupported polling event", "UNSUPPORTED_OPERATION", {
-        operation: "getPollingSubscriber", info: { event }
-    });
-}
-
-// @TODO: refactor this
-
-/**
- *  A **PollingBlockSubscriber** polls at a regular interval for a change
- *  in the block number.
- *
- *  @_docloc: api/providers/abstract-provider
- */
-export class PollingBlockSubscriber implements Subscriber {
-    #provider: AbstractProvider;
-    #poller: null | number;
-
-    #interval: number;
-
-    // The most recent block we have scanned for events. The value -2
-    // indicates we still need to fetch an initial block number
-    #blockNumber: number;
-
-    /**
-     *  Create a new **PollingBlockSubscriber** attached to %%provider%%.
-     */
-    constructor(provider: AbstractProvider) {
-        this.#provider = provider;
-        this.#poller = null;
-        this.#interval = 4000;
-
-        this.#blockNumber = -2;
-    }
-
-    /**
-     *  The polling interval.
-     */
-    get pollingInterval(): number { return this.#interval; }
-    set pollingInterval(value: number) { this.#interval = value; }
-
-    async #poll(): Promise<void> {
-        try {
-            const blockNumber = await this.#provider.getBlockNumber();
-
-            // Bootstrap poll to setup our initial block number
-            if (this.#blockNumber === -2) {
-                this.#blockNumber = blockNumber;
-                return;
-            }
-
-            // @TODO: Put a cap on the maximum number of events per loop?
-
-            if (blockNumber !== this.#blockNumber) {
-                for (let b = this.#blockNumber + 1; b <= blockNumber; b++) {
-                    // We have been stopped
-                    if (this.#poller == null) { return; }
-
-                    await this.#provider.emit("block", b);
-                }
-
-                this.#blockNumber = blockNumber;
-            }
-
-        } catch (error) {
-            // @TODO: Minor bump, add an "error" event to let subscribers
-            //        know things went awry.
-            //console.log(error);
-        }
-
-        // We have been stopped
-        if (this.#poller == null) { return; }
-
-        this.#poller = this.#provider._setTimeout(this.#poll.bind(this), this.#interval);
-    }
-
-    start(): void {
-        if (this.#poller) { return; }
-        this.#poller = this.#provider._setTimeout(this.#poll.bind(this), this.#interval);
-        this.#poll();
-    }
-
-    stop(): void {
-        if (!this.#poller) { return; }
-        this.#provider._clearTimeout(this.#poller);
-        this.#poller = null;
-    }
-
-    pause(dropWhilePaused?: boolean): void {
-        this.stop();
-        if (dropWhilePaused) { this.#blockNumber = -2; }
-    }
-
-    resume(): void {
-        this.start();
-    }
-}
-
-
-/**
- *  An **OnBlockSubscriber** can be sub-classed, with a [[_poll]]
- *  implmentation which will be called on every new block.
- *
- *  @_docloc: api/providers/abstract-provider
- */
-export class OnBlockSubscriber implements Subscriber {
-    #provider: AbstractProvider;
-    #poll: (b: number) => void;
-    #running: boolean;
-
-    /**
-     *  Create a new **OnBlockSubscriber** attached to %%provider%%.
-     */
-    constructor(provider: AbstractProvider) {
-        this.#provider = provider;
-        this.#running = false;
-        this.#poll = (blockNumber: number) => {
-            this._poll(blockNumber, this.#provider);
-        }
-    }
-
-    /**
-     *  Called on every new block.
-     */
-    async _poll(blockNumber: number, provider: AbstractProvider): Promise<void> {
-        throw new Error("sub-classes must override this");
-    }
-
-    start(): void {
-        if (this.#running) { return; }
-        this.#running = true;
-
-        this.#poll(-2);
-        this.#provider.on("block", this.#poll);
-    }
-
-    stop(): void {
-        if (!this.#running) { return; }
-        this.#running = false;
-
-        this.#provider.off("block", this.#poll);
-    }
-
-    pause(dropWhilePaused?: boolean): void { this.stop(); }
-    resume(): void { this.start(); }
-}
-
-export class PollingBlockTagSubscriber extends OnBlockSubscriber {
-    readonly #tag: string;
-    #lastBlock: number;
-
-    constructor(provider: AbstractProvider, tag: string) {
-        super(provider);
-        this.#tag = tag;
-        this.#lastBlock = -2;
-    }
-
-    pause(dropWhilePaused?: boolean): void {
-        if (dropWhilePaused) { this.#lastBlock = -2; }
-        super.pause(dropWhilePaused);
-    }
-
-    async _poll(blockNumber: number, provider: AbstractProvider): Promise<void> {
-        const block = await provider.getBlock(this.#tag);
-        if (block == null) { return; }
-
-        if (this.#lastBlock === -2) {
-            this.#lastBlock = block.number;
-        } else if (block.number > this.#lastBlock) {
-            provider.emit(this.#tag, block.number);
-            this.#lastBlock = block.number;
-        }
-    }
-}
-
-
-/**
- *  @_ignore:
- *
- *  @_docloc: api/providers/abstract-provider
- */
-export class PollingOrphanSubscriber extends OnBlockSubscriber {
-    #filter: OrphanFilter;
-
-    constructor(provider: AbstractProvider, filter: OrphanFilter) {
-        super(provider);
-        this.#filter = copy(filter);
-    }
-
-    async _poll(blockNumber: number, provider: AbstractProvider): Promise<void> {
-        throw new Error("@TODO");
-        console.log(this.#filter);
-    }
-}
-
-/**
- *  A **PollingTransactionSubscriber** will poll for a given transaction
- *  hash for its receipt.
- *
- *  @_docloc: api/providers/abstract-provider
- */
-export class PollingTransactionSubscriber extends OnBlockSubscriber {
-    #hash: string;
-
-    /**
-     *  Create a new **PollingTransactionSubscriber** attached to
-     *  %%provider%%, listening for %%hash%%.
-     */
-    constructor(provider: AbstractProvider, hash: string) {
-        super(provider);
-        this.#hash = hash;
-    }
-
-    async _poll(blockNumber: number, provider: AbstractProvider): Promise<void> {
-        const tx = await provider.getTransactionReceipt(this.#hash);
-        if (tx) { provider.emit(this.#hash, tx); }
-    }
-}
-
-/**
- *  A **PollingEventSubscriber** will poll for a given filter for its logs.
- *
- *  @_docloc: api/providers/abstract-provider
- */
-export class PollingEventSubscriber implements Subscriber {
-    #provider: AbstractProvider;
-    #filter: EventFilter;
-    #poller: (b: number) => void;
-
-    #running: boolean;
-
-    // The most recent block we have scanned for events. The value -2
-    // indicates we still need to fetch an initial block number
-    #blockNumber: number;
-
-    /**
-     *  Create a new **PollingTransactionSubscriber** attached to
-     *  %%provider%%, listening for %%filter%%.
-     */
-    constructor(provider: AbstractProvider, filter: EventFilter) {
-        this.#provider = provider;
-        this.#filter = copy(filter);
-        this.#poller = this.#poll.bind(this);
-        this.#running = false;
-        this.#blockNumber = -2;
-    }
-
-    async #poll(blockNumber: number): Promise<void> {
-        // The initial block hasn't been determined yet
-        if (this.#blockNumber === -2) { return; }
-
-        const filter = copy(this.#filter);
-        filter.fromBlock = this.#blockNumber + 1;
-        filter.toBlock = blockNumber;
-
-        const logs = await this.#provider.getLogs(filter);
-
-        // No logs could just mean the node has not indexed them yet,
-        // so we keep a sliding window of 60 blocks to keep scanning
-        if (logs.length === 0) {
-            if (this.#blockNumber < blockNumber - 60) {
-                this.#blockNumber = blockNumber - 60;
-            }
-            return;
-        }
-
-        for (const log of logs) {
-            this.#provider.emit(this.#filter, log);
-
-            // Only advance the block number when logs were found to
-            // account for networks (like BNB and Polygon) which may
-            // sacrifice event consistency for block event speed
-            this.#blockNumber = log.blockNumber;
-        }
-    }
-
-    start(): void {
-        if (this.#running) { return; }
-        this.#running = true;
-
-        if (this.#blockNumber === -2) {
-            this.#provider.getBlockNumber().then((blockNumber) => {
-                this.#blockNumber = blockNumber;
-            });
-        }
-        this.#provider.on("block", this.#poller);
-    }
-
-    stop(): void {
-        if (!this.#running) { return; }
-        this.#running = false;
-
-        this.#provider.off("block", this.#poller);
-    }
-
-    pause(dropWhilePaused?: boolean): void {
-        this.stop();
-        if (dropWhilePaused) { this.#blockNumber = -2; }
-    }
-
-    resume(): void {
-        this.start();
-    }
-}

package/src.ts/providers/ws-browser.ts

@@ -1,11 +0,0 @@
-
-function getGlobal(): any {
-  if (typeof self !== 'undefined') { return self; }
-  if (typeof window !== 'undefined') { return window; }
-  if (typeof global !== 'undefined') { return global; }
-  throw new Error('unable to locate global object');
-};
-
-const _WebSocket = getGlobal().WebSocket;
-
-export { _WebSocket as WebSocket };

package/src.ts/providers/ws.ts

@@ -1,3 +0,0 @@
-export { WebSocket } from "ws";
-
-

package/src.ts/quantumcoin.ts

@@ -1,219 +0,0 @@
-/////////////////////////////
-//
-import {initialize, Config} from "quantum-coin-js-sdk";
-
-async function initQuantum() {
-    let clientConfigVal = new Config("https://sdk.readrelay.quantumcoinapi.com", "https://sdk.writerelay.quantumcoinapi.com", 123123, "", ""); //Mainnet
-    return await initialize(clientConfigVal);
-}
-
-export { version } from "./_version.js";
-
-export {
-    initQuantum,
-}
-
-export {
-    decodeBytes32String, encodeBytes32String,
-
-    AbiCoder,
-    ConstructorFragment, ErrorFragment, EventFragment, Fragment, FallbackFragment, FunctionFragment, NamedFragment, ParamType, StructFragment,
-
-    checkResultErrors, ErrorDescription, Indexed, Interface, LogDescription, Result, TransactionDescription,
-    Typed,
-} from "./abi/index.js";
-
-export {
-    getAddress,
-    getCreateAddress, getCreate2Address,
-    isAddressable, isAddress, resolveAddress
-} from "./address/index.js";
-
-export {
-    ZeroAddress,
-    WeiPerEther, MaxUint256, MinInt256, MaxInt256, N,
-    ZeroHash,
-    EtherSymbol, MessagePrefix
-} from "./constants/index.js";
-
-export {
-    BaseContract, Contract,
-    ContractFactory,
-    ContractEventPayload, ContractTransactionReceipt, ContractTransactionResponse, ContractUnknownEventPayload, EventLog, UndecodedEventLog
-} from "./contract/index.js";
-
-export {
-    computeHmac,
-    randomBytes,
-    keccak256,
-    ripemd160,
-    sha256, sha512,
-    pbkdf2,
-    scrypt, scryptSync,
-    lock,
-    Signature, SigningKey
-} from "./crypto/index.js";
-
-export {
-    id,
-    ensNormalize, isValidName, namehash, dnsEncode,
-    hashAuthorization, verifyAuthorization,
-    hashMessage, verifyMessage,
-    solidityPacked, solidityPackedKeccak256, solidityPackedSha256,
-    TypedDataEncoder,
-    verifyTypedData
-} from "./hash/index.js";
-
-export {
-    getDefaultProvider,
-
-    Block, FeeData, Log, TransactionReceipt, TransactionResponse,
-
-    AbstractSigner, NonceManager, VoidSigner,
-
-    AbstractProvider,
-
-    FallbackProvider,
-    JsonRpcApiProvider, JsonRpcProvider, JsonRpcSigner,
-
-    BrowserProvider,
-
-    IpcSocketProvider, SocketProvider, WebSocketProvider,
-
-    EnsResolver,
-    Network,
-
-    EnsPlugin,
-    FeeDataNetworkPlugin, FetchUrlFeeDataNetworkPlugin,
-    GasCostPlugin, NetworkPlugin, MulticoinProviderPlugin,
-
-    SocketBlockSubscriber, SocketEventSubscriber, SocketPendingSubscriber,
-    SocketSubscriber, UnmanagedSubscriber,
-
-    copyRequest, showThrottleMessage
-} from "./providers/index.js";
-
-export {
-    accessListify, authorizationify,
-    computeAddress, recoverAddress,
-    Transaction
-} from "./transaction/index.js";
-
-export {
-    decodeBase58, encodeBase58,
-    decodeBase64, encodeBase64,
-    concat, dataLength, dataSlice, getBytes, getBytesCopy, hexlify,
-    isHexString, isBytesLike, stripZerosLeft, zeroPadBytes, zeroPadValue,
-    defineProperties, resolveProperties,
-    assert, assertArgument, assertArgumentCount, assertNormalize, assertPrivate,
-    makeError,
-    isCallException, isError,
-    EventPayload,
-    FetchRequest, FetchResponse, FetchCancelSignal,
-    FixedNumber,
-    getBigInt, getNumber, getUint, toBeArray, toBigInt, toBeHex, toNumber, toQuantity,
-    fromTwos, toTwos, mask,
-    formatEther, parseEther, formatUnits, parseUnits,
-    toUtf8Bytes, toUtf8CodePoints, toUtf8String,
-    Utf8ErrorFuncs,
-    decodeRlp, encodeRlp,
-    uuidV4,
-} from "./utils/index.js";
-
-export {
-    BaseWallet,
-    Wallet,
-    isKeystoreJson,
-    decryptKeystoreJsonSync,
-    encryptKeystoreJsonSync,
-} from "./wallet/index.js";
-
-export {
-    Wordlist, LangEn, WordlistOwl, WordlistOwlA, wordlists
-} from "./wordlists/index.js";
-
-
-
-/////////////////////////////
-// Types
-
-export type {
-    JsonFragment, JsonFragmentType,
-    FormatType, FragmentType,
-    InterfaceAbi,
-    ParamTypeWalkFunc, ParamTypeWalkAsyncFunc
-} from "./abi/index.js";
-
-export type {
-    Addressable, AddressLike, NameResolver
-} from "./address/index.js";
-
-export type {
-    ConstantContractMethod, ContractEvent, ContractEventArgs, ContractEventName,
-    ContractInterface, ContractMethod, ContractMethodArgs, ContractTransaction,
-    DeferredTopicFilter, Overrides,
-    BaseContractMethod, ContractDeployTransaction, PostfixOverrides,
-    WrappedFallback
-} from "./contract/index.js";
-
-export type { ProgressCallback, SignatureLike } from "./crypto/index.js";
-
-export type {
-    AuthorizationRequest, TypedDataDomain, TypedDataField
-} from "./hash/index.js";
-
-export type {
-    Provider, Signer,
-
-    CommunityResourcable,
-
-    AbstractProviderOptions, BrowserProviderOptions, FallbackProviderOptions,
-
-    AbstractProviderPlugin, BlockParams, BlockTag, BrowserDiscoverOptions,
-    ContractRunner, DebugEventBrowserProvider, Eip1193Provider,
-    Eip6963ProviderInfo, EventFilter, Filter, FilterByBlockHash,
-    GasCostParameters, JsonRpcApiProviderOptions, JsonRpcError,
-    JsonRpcPayload, JsonRpcResult, JsonRpcTransactionRequest, LogParams,
-    MinedBlock, MinedTransactionResponse, Networkish, OrphanFilter,
-    PerformActionFilter, PerformActionRequest, PerformActionTransaction,
-    PreparedTransactionRequest, ProviderEvent, Subscriber, Subscription,
-    TopicFilter, TransactionReceiptParams, TransactionRequest,
-    TransactionResponseParams, WebSocketCreator, WebSocketLike
-} from "./providers/index.js";
-
-export type {
-    AccessList, AccessListish, AccessListEntry,
-    Authorization, AuthorizationLike,
-    Blob, BlobLike, KzgLibrary, KzgLibraryLike,
-    TransactionLike
-} from "./transaction/index.js";
-
-export type {
-    BytesLike,
-    BigNumberish, Numeric,
-    ErrorCode,
-    FixedFormat,
-    Utf8ErrorFunc, UnicodeNormalizationForm, Utf8ErrorReason,
-    RlpStructuredData, RlpStructuredDataish,
-
-    GetUrlResponse,
-    FetchPreflightFunc, FetchProcessFunc, FetchRetryFunc,
-    FetchGatewayFunc, FetchGetUrlFunc,
-
-    EthersError, UnknownError, NotImplementedError, UnsupportedOperationError, NetworkError,
-    ServerError, TimeoutError, BadDataError, CancelledError, BufferOverrunError,
-    NumericFaultError, InvalidArgumentError, MissingArgumentError, UnexpectedArgumentError,
-    CallExceptionError, InsufficientFundsError, NonceExpiredError, OffchainFaultError,
-    ReplacementUnderpricedError, TransactionReplacedError, UnconfiguredNameError,
-    ActionRejectedError,
-    CodedEthersError,
-
-    CallExceptionAction, CallExceptionTransaction,
-    EventEmitterable, Listener
-} from "./utils/index.js";
-
-export type {
-    KeystoreAccount
-} from "./wallet/index.js";
-
-// dummy change; to pick-up ws security issue changes

package/src.ts/thirdparty.d.ts

@@ -1,16 +0,0 @@
-
-
-declare module "ws" {
-    export class WebSocket {
-        constructor(...args: Array<any>);
-
-        onopen: null | ((...args: Array<any>) => any);
-        onmessage: null | ((...args: Array<any>) => any);
-        onerror: null | ((...args: Array<any>) => any);
-
-        readyState: number;
-
-        send(payload: any): void;
-        close(code?: number, reason?: string): void;
-    }
-}

package/src.ts/transaction/accesslist.ts

@@ -1,43 +0,0 @@
-import { getAddress } from "../address/index.js";
-import { assertArgument, isHexString } from "../utils/index.js";
-
-import type { AccessList, AccessListish } from "./index.js";
-
-
-function accessSetify(addr: string, storageKeys: Array<string>): { address: string,storageKeys: Array<string> } {
-    return {
-        address: getAddress(addr),
-        storageKeys: storageKeys.map((storageKey, index) => {
-            assertArgument(isHexString(storageKey, 32), "invalid slot", `storageKeys[${ index }]`, storageKey);
-            return storageKey.toLowerCase();
-        })
-    };
-}
-
-/**
- *  Returns a [[AccessList]] from any ethers-supported access-list structure.
- */
-export function accessListify(value: AccessListish): AccessList {
-    if (Array.isArray(value)) {
-        return (<Array<[ string, Array<string>] | { address: string, storageKeys: Array<string>}>>value).map((set, index) => {
-            if (Array.isArray(set)) {
-                assertArgument(set.length === 2, "invalid slot set", `value[${ index }]`, set);
-                return accessSetify(set[0], set[1])
-            }
-            assertArgument(set != null && typeof(set) === "object", "invalid address-slot set", "value", value);
-            return accessSetify(set.address, set.storageKeys);
-        });
-    }
-
-    assertArgument(value != null && typeof(value) === "object", "invalid access list", "value", value);
-
-    const result: Array<{ address: string, storageKeys: Array<string> }> = Object.keys(value).map((addr) => {
-        const storageKeys: Record<string, true> = value[addr].reduce((accum, storageKey) => {
-            accum[storageKey] = true;
-            return accum;
-        }, <Record<string, true>>{ });
-        return accessSetify(addr, Object.keys(storageKeys).sort())
-    });
-    result.sort((a, b) => (a.address.localeCompare(b.address)));
-    return result;
-}

package/src.ts/transaction/address.ts

@@ -1,35 +0,0 @@
-//import { getAddress } from "../address/index.js";
-// keccak256,
-import {SigningKey } from "../crypto/index.js";
-
-import type { SignatureLike } from "../crypto/index.js";
-import {BytesLike, getBytes} from "../utils/index.js";
-import {addressFromPublicKey} from "quantum-coin-js-sdk";
-
-/**
- *  Returns the address for the %%key%%.
- *
- *  The key may be any standard form of public key or a private key.
- */
-export function computeAddress(key: string | SigningKey): string {
-    let pubkey: string;
-    if (typeof(key) === "string") {
-        if (key.startsWith("0x")) {
-            pubkey = SigningKey.computePublicKey(key);
-        } else {
-            pubkey = SigningKey.computePublicKey("0x" + key);
-        }
-    } else {
-        pubkey = key.publicKey;
-    }
-    let pubKeyBytes: any = getBytes(pubkey);
-    return addressFromPublicKey(pubKeyBytes);
-}
-
-/**
- *  Returns the recovered address for the private key that was
- *  used to sign %%digest%% that resulted in %%signature%%.
- */
-export function recoverAddress(digest: BytesLike, signature: SignatureLike): string {
-    return computeAddress(SigningKey.recoverPublicKey(digest, signature));
-}

package/src.ts/transaction/authorization.ts

@@ -1,14 +0,0 @@
-import { getAddress } from "../address/index.js";
-import { Signature } from "../crypto/index.js";
-import { getBigInt } from "../utils/index.js";
-
-import type { Authorization, AuthorizationLike } from "./index.js";
-
-export function authorizationify(auth: AuthorizationLike): Authorization {
-    return {
-        address: getAddress(auth.address),
-        nonce: getBigInt((auth.nonce != null) ? auth.nonce: 0),
-        chainId: getBigInt((auth.chainId != null)? auth.chainId: 0),
-        signature: Signature.from(auth.signature)
-    };
-}