ccxt 4.2.60 → 4.2.61

package/js/src/static_dependencies/ethers/address/checks.js

@@ -0,0 +1,119 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+import { assert, assertArgument } from "../utils/index.js";
+import { getAddress } from "./address.js";
+/**
+ *  Returns true if %%value%% is an object which implements the
+ *  [[Addressable]] interface.
+ *
+ *  @example:
+ *    // Wallets and AbstractSigner sub-classes
+ *    isAddressable(Wallet.createRandom())
+ *    //_result:
+ *
+ *    // Contracts
+ *    contract = new Contract("dai.tokens.ethers.eth", [ ], provider)
+ *    isAddressable(contract)
+ *    //_result:
+ */
+export function isAddressable(value) {
+    return (value && typeof (value.getAddress) === "function");
+}
+/**
+ *  Returns true if %%value%% is a valid address.
+ *
+ *  @example:
+ *    // Valid address
+ *    isAddress("0x8ba1f109551bD432803012645Ac136ddd64DBA72")
+ *    //_result:
+ *
+ *    // Valid ICAP address
+ *    isAddress("XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36")
+ *    //_result:
+ *
+ *    // Invalid checksum
+ *    isAddress("0x8Ba1f109551bD432803012645Ac136ddd64DBa72")
+ *    //_result:
+ *
+ *    // Invalid ICAP checksum
+ *    isAddress("0x8Ba1f109551bD432803012645Ac136ddd64DBA72")
+ *    //_result:
+ *
+ *    // Not an address (an ENS name requires a provided and an
+ *    // asynchronous API to access)
+ *    isAddress("ricmoo.eth")
+ *    //_result:
+ */
+export function isAddress(value) {
+    try {
+        getAddress(value);
+        return true;
+    }
+    catch (error) { }
+    return false;
+}
+async function checkAddress(target, promise) {
+    const result = await promise;
+    if (result == null || result === "0x0000000000000000000000000000000000000000") {
+        assert(typeof (target) !== "string", "unconfigured name", "UNCONFIGURED_NAME", { value: target });
+        assertArgument(false, "invalid AddressLike value; did not resolve to a value address", "target", target);
+    }
+    return getAddress(result);
+}
+/**
+ *  Resolves to an address for the %%target%%, which may be any
+ *  supported address type, an [[Addressable]] or a Promise which
+ *  resolves to an address.
+ *
+ *  If an ENS name is provided, but that name has not been correctly
+ *  configured a [[UnconfiguredNameError]] is thrown.
+ *
+ *  @example:
+ *    addr = "0x6B175474E89094C44Da98b954EedeAC495271d0F"
+ *
+ *    // Addresses are return synchronously
+ *    resolveAddress(addr, provider)
+ *    //_result:
+ *
+ *    // Address promises are resolved asynchronously
+ *    resolveAddress(Promise.resolve(addr))
+ *    //_result:
+ *
+ *    // ENS names are resolved asynchronously
+ *    resolveAddress("dai.tokens.ethers.eth", provider)
+ *    //_result:
+ *
+ *    // Addressable objects are resolved asynchronously
+ *    contract = new Contract(addr, [ ])
+ *    resolveAddress(contract, provider)
+ *    //_result:
+ *
+ *    // Unconfigured ENS names reject
+ *    resolveAddress("nothing-here.ricmoo.eth", provider)
+ *    //_error:
+ *
+ *    // ENS names require a NameResolver object passed in
+ *    // (notice the provider was omitted)
+ *    resolveAddress("nothing-here.ricmoo.eth")
+ *    //_error:
+ */
+export function resolveAddress(target, resolver) {
+    if (typeof (target) === "string") {
+        if (target.match(/^0x[0-9a-f]{40}$/i)) {
+            return getAddress(target);
+        }
+        assert(resolver != null, "ENS resolution requires a provider", "UNSUPPORTED_OPERATION", { operation: "resolveName" });
+        return checkAddress(target, resolver.resolveName(target));
+    }
+    else if (isAddressable(target)) {
+        return checkAddress(target, target.getAddress());
+    }
+    else if (target && typeof (target.then) === "function") {
+        return checkAddress(target, target);
+    }
+    assertArgument(false, "unsupported addressable value", "target", target);
+}

package/js/src/static_dependencies/ethers/address/contract-address.d.ts

@@ -0,0 +1,47 @@
+import type { BigNumberish, BytesLike } from "../utils/index.js";
+/**
+ *  Returns the address that would result from a ``CREATE`` for %%tx%%.
+ *
+ *  This can be used to compute the address a contract will be
+ *  deployed to by an EOA when sending a deployment transaction (i.e.
+ *  when the ``to`` address is ``null``).
+ *
+ *  This can also be used to compute the address a contract will be
+ *  deployed to by a contract, by using the contract's address as the
+ *  ``to`` and the contract's nonce.
+ *
+ *  @example
+ *    from = "0x8ba1f109551bD432803012645Ac136ddd64DBA72";
+ *    nonce = 5;
+ *
+ *    getCreateAddress({ from, nonce });
+ *    //_result:
+ */
+export declare function getCreateAddress(tx: {
+    from: string;
+    nonce: BigNumberish;
+}): string;
+/**
+ *  Returns the address that would result from a ``CREATE2`` operation
+ *  with the given %%from%%, %%salt%% and %%initCodeHash%%.
+ *
+ *  To compute the %%initCodeHash%% from a contract's init code, use
+ *  the [[keccak256]] function.
+ *
+ *  For a quick overview and example of ``CREATE2``, see [[link-ricmoo-wisps]].
+ *
+ *  @example
+ *    // The address of the contract
+ *    from = "0x8ba1f109551bD432803012645Ac136ddd64DBA72"
+ *
+ *    // The salt
+ *    salt = id("HelloWorld")
+ *
+ *    // The hash of the initCode
+ *    initCode = "0x6394198df16000526103ff60206004601c335afa6040516060f3";
+ *    initCodeHash = keccak256(initCode)
+ *
+ *    getCreate2Address(from, salt, initCodeHash)
+ *    //_result:
+ */
+export declare function getCreate2Address(_from: string, _salt: BytesLike, _initCodeHash: BytesLike): string;

package/js/src/static_dependencies/ethers/address/contract-address.js

@@ -0,0 +1,73 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+import { concat, dataSlice, getBigInt, getBytes, encodeRlp, assertArgument, keccak256 } from "../utils/index.js";
+import { getAddress } from "./address.js";
+// http://ethereum.stackexchange.com/questions/760/how-is-the-address-of-an-ethereum-contract-computed
+/**
+ *  Returns the address that would result from a ``CREATE`` for %%tx%%.
+ *
+ *  This can be used to compute the address a contract will be
+ *  deployed to by an EOA when sending a deployment transaction (i.e.
+ *  when the ``to`` address is ``null``).
+ *
+ *  This can also be used to compute the address a contract will be
+ *  deployed to by a contract, by using the contract's address as the
+ *  ``to`` and the contract's nonce.
+ *
+ *  @example
+ *    from = "0x8ba1f109551bD432803012645Ac136ddd64DBA72";
+ *    nonce = 5;
+ *
+ *    getCreateAddress({ from, nonce });
+ *    //_result:
+ */
+export function getCreateAddress(tx) {
+    const from = getAddress(tx.from);
+    const nonce = getBigInt(tx.nonce, "tx.nonce");
+    let nonceHex = nonce.toString(16);
+    if (nonceHex === "0") {
+        nonceHex = "0x";
+    }
+    else if (nonceHex.length % 2) {
+        nonceHex = "0x0" + nonceHex;
+    }
+    else {
+        nonceHex = "0x" + nonceHex;
+    }
+    return getAddress(dataSlice(keccak256(encodeRlp([from, nonceHex])), 12));
+}
+/**
+ *  Returns the address that would result from a ``CREATE2`` operation
+ *  with the given %%from%%, %%salt%% and %%initCodeHash%%.
+ *
+ *  To compute the %%initCodeHash%% from a contract's init code, use
+ *  the [[keccak256]] function.
+ *
+ *  For a quick overview and example of ``CREATE2``, see [[link-ricmoo-wisps]].
+ *
+ *  @example
+ *    // The address of the contract
+ *    from = "0x8ba1f109551bD432803012645Ac136ddd64DBA72"
+ *
+ *    // The salt
+ *    salt = id("HelloWorld")
+ *
+ *    // The hash of the initCode
+ *    initCode = "0x6394198df16000526103ff60206004601c335afa6040516060f3";
+ *    initCodeHash = keccak256(initCode)
+ *
+ *    getCreate2Address(from, salt, initCodeHash)
+ *    //_result:
+ */
+export function getCreate2Address(_from, _salt, _initCodeHash) {
+    const from = getAddress(_from);
+    const salt = getBytes(_salt, "salt");
+    const initCodeHash = getBytes(_initCodeHash, "initCodeHash");
+    assertArgument(salt.length === 32, "salt must be 32 bytes", "salt", _salt);
+    assertArgument(initCodeHash.length === 32, "initCodeHash must be 32 bytes", "initCodeHash", _initCodeHash);
+    return getAddress(dataSlice(keccak256(concat(["0xff", from, salt, initCodeHash])), 12));
+}

package/js/src/static_dependencies/ethers/address/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ *  Addresses are a fundamental part of interacting with Ethereum. They
+ *  represent the gloabal identity of Externally Owned Accounts (accounts
+ *  backed by a private key) and contracts.
+ *
+ *  The Ethereum Naming Service (ENS) provides an interconnected ecosystem
+ *  of contracts, standards and libraries which enable looking up an
+ *  address for an ENS name.
+ *
+ *  These functions help convert between various formats, validate
+ *  addresses and safely resolve ENS names.
+ *
+ *  @_section: api/address:Addresses  [about-addresses]
+ */
+/**
+ *  An interface for objects which have an address, and can
+ *  resolve it asyncronously.
+ *
+ *  This allows objects such as [[Signer]] or [[Contract]] to
+ *  be used most places an address can be, for example getting
+ *  the [balance](Provider-getBalance).
+ */
+export interface Addressable {
+    /**
+     *  Get the object address.
+     */
+    getAddress(): Promise<string>;
+}
+/**
+ *  Anything that can be used to return or resolve an address.
+ */
+export declare type AddressLike = string | Promise<string> | Addressable;
+/**
+ *  An interface for any object which can resolve an ENS name.
+ */
+export interface NameResolver {
+    /**
+     *  Resolve to the address for the ENS %%name%%.
+     *
+     *  Resolves to ``null`` if the name is unconfigued. Use
+     *  [[resolveAddress]] (passing this object as %%resolver%%) to
+     *  throw for names that are unconfigured.
+     */
+    resolveName(name: string): Promise<null | string>;
+}
+export { getAddress, getIcapAddress } from "./address.js";
+export { getCreateAddress, getCreate2Address } from "./contract-address.js";
+export { isAddressable, isAddress, resolveAddress } from "./checks.js";

package/js/src/static_dependencies/ethers/address/index.js

@@ -0,0 +1,24 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+/**
+ *  Addresses are a fundamental part of interacting with Ethereum. They
+ *  represent the gloabal identity of Externally Owned Accounts (accounts
+ *  backed by a private key) and contracts.
+ *
+ *  The Ethereum Naming Service (ENS) provides an interconnected ecosystem
+ *  of contracts, standards and libraries which enable looking up an
+ *  address for an ENS name.
+ *
+ *  These functions help convert between various formats, validate
+ *  addresses and safely resolve ENS names.
+ *
+ *  @_section: api/address:Addresses  [about-addresses]
+ */
+null;
+export { getAddress, getIcapAddress } from "./address.js";
+export { getCreateAddress, getCreate2Address } from "./contract-address.js";
+export { isAddressable, isAddress, resolveAddress } from "./checks.js";

package/js/src/static_dependencies/ethers/bytes32.d.ts

@@ -0,0 +1,14 @@
+/**
+ *  About bytes32 strings...
+ *
+ *  @_docloc: api/utils:Bytes32 Strings
+ */
+import type { BytesLike } from "./utils/index.js";
+/**
+ *  Encodes %%text%% as a Bytes32 string.
+ */
+export declare function encodeBytes32String(text: string): string;
+/**
+ *  Encodes the Bytes32-encoded %%bytes%% into a string.
+ */
+export declare function decodeBytes32String(_bytes: BytesLike): string;

package/js/src/static_dependencies/ethers/bytes32.js

@@ -0,0 +1,45 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+/**
+ *  About bytes32 strings...
+ *
+ *  @_docloc: api/utils:Bytes32 Strings
+ */
+import { getBytes, toUtf8Bytes, toUtf8String, zeroPadBytes } from "./utils/index.js";
+/**
+ *  Encodes %%text%% as a Bytes32 string.
+ */
+export function encodeBytes32String(text) {
+    // Get the bytes
+    const bytes = toUtf8Bytes(text);
+    // Check we have room for null-termination
+    if (bytes.length > 31) {
+        throw new Error("bytes32 string must be less than 32 bytes");
+    }
+    // Zero-pad (implicitly null-terminates)
+    return zeroPadBytes(bytes, 32);
+}
+/**
+ *  Encodes the Bytes32-encoded %%bytes%% into a string.
+ */
+export function decodeBytes32String(_bytes) {
+    const data = getBytes(_bytes, "bytes");
+    // Must be 32 bytes with a null-termination
+    if (data.length !== 32) {
+        throw new Error("invalid bytes32 - not 32 bytes long");
+    }
+    if (data[31] !== 0) {
+        throw new Error("invalid bytes32 string - no null terminator");
+    }
+    // Find the null termination
+    let length = 31;
+    while (data[length - 1] === 0) {
+        length--;
+    }
+    // Determine the string value
+    return toUtf8String(data.slice(0, length));
+}

package/js/src/static_dependencies/ethers/coders/abstract-coder.d.ts

@@ -0,0 +1,120 @@
+import type { BigNumberish, BytesLike } from "../utils/index.js";
+/**
+ * @_ignore:
+ */
+export declare const WordSize: number;
+/**
+ *  A [[Result]] is a sub-class of Array, which allows accessing any
+ *  of its values either positionally by its index or, if keys are
+ *  provided by its name.
+ *
+ *  @_docloc: api/abi
+ */
+export declare class Result extends Array<any> {
+    #private;
+    [K: string | number]: any;
+    /**
+     *  @private
+     */
+    constructor(...args: Array<any>);
+    /**
+     *  Returns the Result as a normal Array.
+     *
+     *  This will throw if there are any outstanding deferred
+     *  errors.
+     */
+    toArray(): Array<any>;
+    /**
+     *  Returns the Result as an Object with each name-value pair.
+     *
+     *  This will throw if any value is unnamed, or if there are
+     *  any outstanding deferred errors.
+     */
+    toObject(): Record<string, any>;
+    /**
+     *  @_ignore
+     */
+    slice(start?: number | undefined, end?: number | undefined): Result;
+    /**
+     *  @_ignore
+     */
+    filter(callback: (el: any, index: number, array: Result) => boolean, thisArg?: any): Result;
+    /**
+     *  @_ignore
+     */
+    map<T extends any = any>(callback: (el: any, index: number, array: Result) => T, thisArg?: any): Array<T>;
+    /**
+     *  Returns the value for %%name%%.
+     *
+     *  Since it is possible to have a key whose name conflicts with
+     *  a method on a [[Result]] or its superclass Array, or any
+     *  JavaScript keyword, this ensures all named values are still
+     *  accessible by name.
+     */
+    getValue(name: string): any;
+    /**
+     *  Creates a new [[Result]] for %%items%% with each entry
+     *  also accessible by its corresponding name in %%keys%%.
+     */
+    static fromItems(items: Array<any>, keys?: Array<null | string>): Result;
+}
+/**
+ *  Returns all errors found in a [[Result]].
+ *
+ *  Since certain errors encountered when creating a [[Result]] do
+ *  not impact the ability to continue parsing data, they are
+ *  deferred until they are actually accessed. Hence a faulty string
+ *  in an Event that is never used does not impact the program flow.
+ *
+ *  However, sometimes it may be useful to access, identify or
+ *  validate correctness of a [[Result]].
+ *
+ *  @_docloc api/abi
+ */
+export declare function checkResultErrors(result: Result): Array<{
+    path: Array<string | number>;
+    error: Error;
+}>;
+/**
+ *  @_ignore
+ */
+export declare abstract class Coder {
+    readonly name: string;
+    readonly type: string;
+    readonly localName: string;
+    readonly dynamic: boolean;
+    constructor(name: string, type: string, localName: string, dynamic: boolean);
+    _throwError(message: string, value: any): never;
+    abstract encode(writer: Writer, value: any): number;
+    abstract decode(reader: Reader): any;
+    abstract defaultValue(): any;
+}
+/**
+ *  @_ignore
+ */
+export declare class Writer {
+    #private;
+    constructor();
+    get data(): string;
+    get length(): number;
+    appendWriter(writer: Writer): number;
+    writeBytes(value: BytesLike): number;
+    writeValue(value: BigNumberish): number;
+    writeUpdatableValue(): (value: BigNumberish) => void;
+}
+/**
+ *  @_ignore
+ */
+export declare class Reader {
+    #private;
+    readonly allowLoose: boolean;
+    constructor(data: BytesLike, allowLoose?: boolean, maxInflation?: number);
+    get data(): string;
+    get dataLength(): number;
+    get consumed(): number;
+    get bytes(): Uint8Array;
+    subReader(offset: number): Reader;
+    readBytes(length: number, loose?: boolean): Uint8Array;
+    readValue(): bigint;
+    readIndex(): number;
+}