quantumcoin 6.14.5 → 7.0.2

package/src.ts/providers/signer-noncemanager.ts

@@ -1,98 +0,0 @@
-import { defineProperties } from "../utils/index.js";
-import { AbstractSigner } from "./abstract-signer.js";
-
-import type { TypedDataDomain, TypedDataField } from "../hash/index.js";
-
-import type {
-    BlockTag, Provider, TransactionRequest, TransactionResponse
-} from "./provider.js";
-import type { Signer } from "./signer.js";
-
-
-/**
- *  A **NonceManager** wraps another [[Signer]] and automatically manages
- *  the nonce, ensuring serialized and sequential nonces are used during
- *  transaction.
- */
-export class NonceManager extends AbstractSigner {
-    /**
-     *  The Signer being managed.
-     */
-    signer!: Signer;
-
-    #noncePromise: null | Promise<number>;
-    #delta: number;
-
-    /**
-     *  Creates a new **NonceManager** to manage %%signer%%.
-     */
-    constructor(signer: Signer) {
-        super(signer.provider);
-        defineProperties<NonceManager>(this, { signer });
-
-        this.#noncePromise = null;
-        this.#delta = 0;
-    }
-
-    async getAddress(): Promise<string> {
-        return this.signer.getAddress();
-    }
-
-    connect(provider: null | Provider): NonceManager {
-        return new NonceManager(this.signer.connect(provider));
-    }
-
-    async getNonce(blockTag?: BlockTag): Promise<number> {
-        if (blockTag === "pending") {
-            if (this.#noncePromise == null) {
-                this.#noncePromise = super.getNonce("pending");
-            }
-
-            const delta = this.#delta;
-            return (await this.#noncePromise) + delta;
-        }
-
-        return super.getNonce(blockTag);
-    }
-
-    /**
-     *  Manually increment the nonce. This may be useful when managng
-     *  offline transactions.
-     */
-    increment(): void {
-        this.#delta++;
-    }
-
-    /**
-     *  Resets the nonce, causing the **NonceManager** to reload the current
-     *  nonce from the blockchain on the next transaction.
-     */
-    reset(): void {
-        this.#delta = 0;
-        this.#noncePromise = null;
-    }
-
-    async sendTransaction(tx: TransactionRequest): Promise<TransactionResponse> {
-        const noncePromise = this.getNonce("pending");
-        this.increment();
-
-        tx = await this.signer.populateTransaction(tx);
-        tx.nonce = await noncePromise;
-
-        // @TODO: Maybe handle interesting/recoverable errors?
-        // Like don't increment if the tx was certainly not sent
-        return await this.signer.sendTransaction(tx);
-    }
-
-    signTransaction(tx: TransactionRequest): Promise<string> {
-        return this.signer.signTransaction(tx);
-    }
-
-    signMessage(message: string | Uint8Array): Promise<string> {
-        return this.signer.signMessage(message);
-    }
-
-    signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, value: Record<string, any>): Promise<string> {
-        return this.signer.signTypedData(domain, types, value);
-    }
-}

package/src.ts/providers/signer.ts

@@ -1,166 +0,0 @@
-
-import type { Addressable, NameResolver } from "../address/index.js";
-import type {
-    AuthorizationRequest, TypedDataDomain, TypedDataField
-} from "../hash/index.js";
-import type { Authorization, TransactionLike } from "../transaction/index.js";
-
-import type { ContractRunner } from "./contracts.js";
-import type { BlockTag, Provider, TransactionRequest, TransactionResponse } from "./provider.js";
-
-/**
- *  A Signer represents an account on the Ethereum Blockchain, and is most often
- *  backed by a private key represented by a mnemonic or residing on a Hardware Wallet.
- *
- *  The API remains abstract though, so that it can deal with more advanced exotic
- *  Signing entities, such as Smart Contract Wallets or Virtual Wallets (where the
- *  private key may not be known).
- */
-export interface Signer extends Addressable, ContractRunner, NameResolver {
-
-    /**
-     *  The [[Provider]] attached to this Signer (if any).
-     */
-    provider: null | Provider;
-
-    /**
-     *  Returns a new instance of this Signer connected to //provider// or detached
-     *  from any Provider if null.
-     */
-    connect(provider: null | Provider): Signer;
-
-
-    ////////////////////
-    // State
-
-    /**
-     *  Get the address of the Signer.
-     */
-    getAddress(): Promise<string>;
-
-    /**
-     *  Gets the next nonce required for this Signer to send a transaction.
-     *
-     *  @param blockTag - The blocktag to base the transaction count on, keep in mind
-     *         many nodes do not honour this value and silently ignore it [default: ``"latest"``]
-     */
-    getNonce(blockTag?: BlockTag): Promise<number>;
-
-
-    ////////////////////
-    // Preparation
-
-    /**
-     *  Prepares a {@link TransactionRequest} for calling:
-     *  - resolves ``to`` and ``from`` addresses
-     *  - if ``from`` is specified , check that it matches this Signer
-     *
-     *  @param tx - The call to prepare
-     */
-    populateCall(tx: TransactionRequest): Promise<TransactionLike<string>>;
-
-    /**
-     *  Prepares a {@link TransactionRequest} for sending to the network by
-     *  populating any missing properties:
-     *  - resolves ``to`` and ``from`` addresses
-     *  - if ``from`` is specified , check that it matches this Signer
-     *  - populates ``nonce`` via ``signer.getNonce("pending")``
-     *  - populates ``gasLimit`` via ``signer.estimateGas(tx)``
-     *  - populates ``chainId`` via ``signer.provider.getNetwork()``
-     *  - populates ``type`` and relevant fee data for that type (``gasPrice``
-     *    for legacy transactions, ``maxFeePerGas`` for EIP-1559, etc)
-     *
-     *  @note Some Signer implementations may skip populating properties that
-     *        are populated downstream; for example JsonRpcSigner defers to the
-     *        node to populate the nonce and fee data.
-     *
-     *  @param tx - The call to prepare
-     */
-    populateTransaction(tx: TransactionRequest): Promise<TransactionLike<string>>;
-
-
-    ////////////////////
-    // Execution
-
-    /**
-     *  Estimates the required gas required to execute //tx// on the Blockchain. This
-     *  will be the expected amount a transaction will require as its ``gasLimit``
-     *  to successfully run all the necessary computations and store the needed state
-     *  that the transaction intends.
-     *
-     *  Keep in mind that this is **best efforts**, since the state of the Blockchain
-     *  is in flux, which could affect transaction gas requirements.
-     *
-     *  @throws UNPREDICTABLE_GAS_LIMIT A transaction that is believed by the node to likely
-     *          fail will throw an error during gas estimation. This could indicate that it
-     *          will actually fail or that the circumstances are simply too complex for the
-     *          node to take into account. In these cases, a manually determined ``gasLimit``
-     *          will need to be made.
-     */
-    estimateGas(tx: TransactionRequest): Promise<bigint>;
-
-    /**
-     *  Evaluates the //tx// by running it against the current Blockchain state. This
-     *  cannot change state and has no cost in ether, as it is effectively simulating
-     *  execution.
-     *
-     *  This can be used to have the Blockchain perform computations based on its state
-     *  (e.g. running a Contract's getters) or to simulate the effect of a transaction
-     *  before actually performing an operation.
-     */
-    call(tx: TransactionRequest): Promise<string>;
-
-    /**
-     *  Resolves an ENS Name to an address.
-     */
-    resolveName(name: string): Promise<null | string>;
-
-
-    ////////////////////
-    // Signing
-
-    /**
-     *  Signs %%tx%%, returning the fully signed transaction. This does not
-     *  populate any additional properties within the transaction.
-     */
-    signTransaction(tx: TransactionRequest): Promise<string>;
-
-    /**
-     *  Sends %%tx%% to the Network. The ``signer.populateTransaction(tx)``
-     *  is called first to ensure all necessary properties for the
-     *  transaction to be valid have been popualted first.
-     */
-    sendTransaction(tx: TransactionRequest): Promise<TransactionResponse>;
-
-    /**
-     *  Signs an [[link-eip-191]] prefixed personal message.
-     *
-     *  If the %%message%% is a string, it is signed as UTF-8 encoded bytes. It is **not**
-     *  interpretted as a [[BytesLike]]; so the string ``"0x1234"`` is signed as six
-     *  characters, **not** two bytes.
-     *
-     *  To sign that example as two bytes, the Uint8Array should be used
-     *  (i.e. ``new Uint8Array([ 0x12, 0x34 ])``).
-     */
-    signMessage(message: string | Uint8Array): Promise<string>;
-
-    /**
-     *  Signs the [[link-eip-712]] typed data.
-     */
-    signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, value: Record<string, any>): Promise<string>;
-
-    /**
-     *  Prepares an [[AuthorizationRequest]] for authorization by
-     *  populating any missing properties:
-     *  - resolves ``address`` (if an Addressable or ENS name)
-     *  - populates ``nonce`` via ``signer.getNonce("pending")``
-     *  - populates ``chainId`` via ``signer.provider.getNetwork()``
-     */
-    populateAuthorization(auth: AuthorizationRequest): Promise<AuthorizationRequest>;
-
-    /**
-     *  Signs an %%authorization%% to be used in [[link-eip-7702]]
-     *  transactions.
-     */
-    authorize(authorization: AuthorizationRequest): Promise<Authorization>;
-}

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

@@ -1,74 +0,0 @@
-
-import { getNumber } from "../utils/index.js";
-
-import type { Subscriber } from "./abstract-provider.js";
-
-
-//#TODO: Temp
-import type { Provider } from "./provider.js";
-
-/**
- *  @TODO
- *
- *  @_docloc: api/providers/abstract-provider
- */
-export interface ConnectionRpcProvider extends Provider {
-    //send(method: string, params: Array<any>): Promise<any>;
-    _subscribe(param: Array<any>, processFunc: (result: any) => void): number;
-    _unsubscribe(filterId: number): void;
-}
-
-/**
- *  @TODO
- *
- *  @_docloc: api/providers/abstract-provider
- */
-export class BlockConnectionSubscriber implements Subscriber {
-    #provider: ConnectionRpcProvider;
-    #blockNumber: number;
-
-    #running: boolean;
-
-    #filterId: null | number;
-
-    constructor(provider: ConnectionRpcProvider) {
-        this.#provider = provider;
-        this.#blockNumber = -2;
-        this.#running = false;
-        this.#filterId = null;
-    }
-
-    start(): void {
-        if (this.#running) { return; }
-        this.#running = true;
-
-        this.#filterId = this.#provider._subscribe([ "newHeads" ], (result: any) => {
-            const blockNumber = getNumber(result.number);
-            const initial = (this.#blockNumber === -2) ? blockNumber: (this.#blockNumber + 1)
-            for (let b = initial; b <= blockNumber; b++) {
-                this.#provider.emit("block", b);
-            }
-            this.#blockNumber = blockNumber;
-        });
-    }
-
-    stop(): void {
-        if (!this.#running) { return; }
-        this.#running = false;
-
-        if (this.#filterId != null) {
-            this.#provider._unsubscribe(this.#filterId);
-            this.#filterId = null;
-        }
-    }
-
-    pause(dropWhilePaused?: boolean): void {
-        if (dropWhilePaused) { this.#blockNumber = -2; }
-        this.stop();
-    }
-
-    resume(): void {
-        this.start();
-    }
-}
-

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

@@ -1,199 +0,0 @@
-import { isError } from "../utils/index.js";
-
-import { PollingEventSubscriber } from "./subscriber-polling.js";
-
-import type { AbstractProvider, Subscriber } from "./abstract-provider.js";
-import type { Network } from "./network.js";
-import type { EventFilter } from "./provider.js";
-import type { JsonRpcApiProvider } from "./provider-jsonrpc.js";
-
-function copy(obj: any): any {
-    return JSON.parse(JSON.stringify(obj));
-}
-
-/**
- *  Some backends support subscribing to events using a Filter ID.
- *
- *  When subscribing with this technique, the node issues a unique
- *  //Filter ID//. At this point the node dedicates resources to
- *  the filter, so that periodic calls to follow up on the //Filter ID//
- *  will receive any events since the last call.
- *
- *  @_docloc: api/providers/abstract-provider
- */
-export class FilterIdSubscriber implements Subscriber {
-    #provider: JsonRpcApiProvider;
-
-    #filterIdPromise: null | Promise<string>;
-    #poller: (b: number) => Promise<void>;
-
-    #running: boolean;
-
-    #network: null | Network;
-
-    #hault: boolean;
-
-    /**
-     *  Creates a new **FilterIdSubscriber** which will used [[_subscribe]]
-     *  and [[_emitResults]] to setup the subscription and provide the event
-     *  to the %%provider%%.
-     */
-    constructor(provider: JsonRpcApiProvider) {
-        this.#provider = provider;
-
-        this.#filterIdPromise = null;
-        this.#poller = this.#poll.bind(this);
-
-        this.#running = false;
-
-        this.#network = null;
-
-        this.#hault = false;
-    }
-
-    /**
-     *  Sub-classes **must** override this to begin the subscription.
-     */
-    _subscribe(provider: JsonRpcApiProvider): Promise<string> {
-        throw new Error("subclasses must override this");
-    }
-
-    /**
-     *  Sub-classes **must** override this handle the events.
-     */
-    _emitResults(provider: AbstractProvider, result: Array<any>): Promise<void> {
-        throw new Error("subclasses must override this");
-    }
-
-    /**
-     *  Sub-classes **must** override this handle recovery on errors.
-     */
-    _recover(provider: AbstractProvider): Subscriber {
-        throw new Error("subclasses must override this");
-    }
-
-    async #poll(blockNumber: number): Promise<void> {
-        try {
-            // Subscribe if necessary
-            if (this.#filterIdPromise == null) {
-                this.#filterIdPromise = this._subscribe(this.#provider);
-            }
-
-            // Get the Filter ID
-            let filterId: null | string = null;
-            try {
-                filterId = await this.#filterIdPromise;
-            } catch (error) {
-                if (!isError(error, "UNSUPPORTED_OPERATION") || error.operation !== "eth_newFilter") {
-                    throw error;
-                }
-            }
-
-            // The backend does not support Filter ID; downgrade to
-            // polling
-            if (filterId == null) {
-                this.#filterIdPromise = null;
-                this.#provider._recoverSubscriber(this, this._recover(this.#provider));
-                return;
-            }
-
-            const network = await this.#provider.getNetwork();
-            if (!this.#network) { this.#network = network; }
-
-            if ((this.#network as Network).chainId !== network.chainId) {
-                throw new Error("chaid changed");
-            }
-
-            if (this.#hault) { return; }
-
-            const result = await this.#provider.send("eth_getFilterChanges", [ filterId ]);
-            await this._emitResults(this.#provider, result);
-        } catch (error) { console.log("@TODO", error); }
-
-        this.#provider.once("block", this.#poller);
-    }
-
-    #teardown(): void {
-        const filterIdPromise = this.#filterIdPromise;
-        if (filterIdPromise) {
-            this.#filterIdPromise = null;
-            filterIdPromise.then((filterId) => {
-                if (this.#provider.destroyed) { return; }
-                this.#provider.send("eth_uninstallFilter", [ filterId ]);
-            });
-        }
-    }
-
-    start(): void {
-        if (this.#running) { return; }
-        this.#running = true;
-
-        this.#poll(-2);
-    }
-
-    stop(): void {
-        if (!this.#running) { return; }
-        this.#running = false;
-
-        this.#hault = true;
-        this.#teardown();
-        this.#provider.off("block", this.#poller);
-    }
-
-    pause(dropWhilePaused?: boolean): void {
-        if (dropWhilePaused){ this.#teardown(); }
-        this.#provider.off("block", this.#poller);
-    }
-
-    resume(): void { this.start(); }
-}
-
-/**
- *  A **FilterIdSubscriber** for receiving contract events.
- *
- *  @_docloc: api/providers/abstract-provider
- */
-export class FilterIdEventSubscriber extends FilterIdSubscriber {
-    #event: EventFilter;
-
-    /**
-     *  Creates a new **FilterIdEventSubscriber** attached to %%provider%%
-     *  listening for %%filter%%.
-     */
-    constructor(provider: JsonRpcApiProvider, filter: EventFilter) {
-        super(provider);
-        this.#event = copy(filter);
-    }
-
-    _recover(provider: AbstractProvider): Subscriber {
-        return new PollingEventSubscriber(provider, this.#event);
-    }
-
-    async _subscribe(provider: JsonRpcApiProvider): Promise<string> {
-        const filterId = await provider.send("eth_newFilter", [ this.#event ]);
-        return filterId;
-    }
-
-    async _emitResults(provider: JsonRpcApiProvider, results: Array<any>): Promise<void> {
-        for (const result of results) {
-            provider.emit(this.#event, provider._wrapLog(result, provider._network));
-        }
-    }
-}
-
-/**
- *  A **FilterIdSubscriber** for receiving pending transactions events.
- *
- *  @_docloc: api/providers/abstract-provider
- */
-export class FilterIdPendingSubscriber extends FilterIdSubscriber {
-    async _subscribe(provider: JsonRpcApiProvider): Promise<string> {
-        return await provider.send("eth_newPendingTransactionFilter", [ ]);
-    }
-
-    async _emitResults(provider: JsonRpcApiProvider, results: Array<any>): Promise<void> {
-        for (const result of results) {
-            provider.emit("pending", result);
-        }
-    }
-}