eteres 0.0.1-security → 6.7.1

package/src.ts/providers/format.ts

@@ -0,0 +1,293 @@
+/**
+ *  @_ignore
+ */
+import { getAddress, getCreateAddress } from "../address/index.js";
+import { Signature } from "../crypto/index.js"
+import { accessListify } from "../transaction/index.js";
+import {
+    getBigInt, getNumber, hexlify, isHexString, zeroPadValue,
+    assert, assertArgument
+} from "../utils/index.js";
+
+import type {
+    BlockParams, LogParams,
+    TransactionReceiptParams, TransactionResponseParams,
+} from "./formatting.js";
+
+
+const BN_0 = BigInt(0);
+
+export type FormatFunc = (value: any) => any;
+
+export function allowNull(format: FormatFunc, nullValue?: any): FormatFunc {
+    return (function(value: any) {
+        if (value == null) { return nullValue; }
+        return format(value);
+    });
+}
+
+export function arrayOf(format: FormatFunc): FormatFunc {
+    return ((array: any) => {
+        if (!Array.isArray(array)) { throw new Error("not an array"); }
+        return array.map((i) => format(i));
+    });
+}
+
+// Requires an object which matches a fleet of other formatters
+// Any FormatFunc may return `undefined` to have the value omitted
+// from the result object. Calls preserve `this`.
+export function object(format: Record<string, FormatFunc>, altNames?: Record<string, Array<string>>): FormatFunc {
+    return ((value: any) => {
+        const result: any = { };
+        for (const key in format) {
+            let srcKey = key;
+            if (altNames && key in altNames && !(srcKey in value)) {
+                for (const altKey of altNames[key]) {
+                    if (altKey in value) {
+                        srcKey = altKey;
+                        break;
+                    }
+                }
+            }
+
+            try {
+                const nv = format[key](value[srcKey]);
+                if (nv !== undefined) { result[key] = nv; }
+            } catch (error) {
+                const message = (error instanceof Error) ? error.message: "not-an-error";
+                assert(false, `invalid value for value.${ key } (${ message })`, "BAD_DATA", { value })
+            }
+        }
+        return result;
+    });
+}
+
+export function formatBoolean(value: any): boolean {
+    switch (value) {
+        case true: case "true":
+            return true;
+        case false: case "false":
+            return false;
+    }
+    assertArgument(false, `invalid boolean; ${ JSON.stringify(value) }`, "value", value);
+}
+
+export function formatData(value: string): string {
+    assertArgument(isHexString(value, true), "invalid data", "value", value);
+    return value;
+}
+
+export function formatHash(value: any): string {
+    assertArgument(isHexString(value, 32), "invalid hash", "value", value);
+    return value;
+}
+
+export function formatUint256(value: any): string {
+    if (!isHexString(value)) {
+        throw new Error("invalid uint256");
+    }
+    return zeroPadValue(value, 32);
+}
+
+const _formatLog = object({
+    address: getAddress,
+    blockHash: formatHash,
+    blockNumber: getNumber,
+    data: formatData,
+    index: getNumber,
+    removed: allowNull(formatBoolean, false),
+    topics: arrayOf(formatHash),
+    transactionHash: formatHash,
+    transactionIndex: getNumber,
+}, {
+    index: [ "logIndex" ]
+});
+
+export function formatLog(value: any): LogParams {
+    return _formatLog(value);
+}
+
+const _formatBlock = object({
+    hash: allowNull(formatHash),
+    parentHash: formatHash,
+    number: getNumber,
+
+    timestamp: getNumber,
+    nonce: allowNull(formatData),
+    difficulty: getBigInt,
+
+    gasLimit: getBigInt,
+    gasUsed: getBigInt,
+
+    miner: allowNull(getAddress),
+    extraData: formatData,
+
+    baseFeePerGas: allowNull(getBigInt)
+});
+
+export function formatBlock(value: any): BlockParams {
+    const result = _formatBlock(value);
+    result.transactions = value.transactions.map((tx: string | TransactionResponseParams) => {
+        if (typeof(tx) === "string") { return tx; }
+        return formatTransactionResponse(tx);
+    });
+    return result;
+}
+
+const _formatReceiptLog = object({
+    transactionIndex: getNumber,
+    blockNumber: getNumber,
+    transactionHash: formatHash,
+    address: getAddress,
+    topics: arrayOf(formatHash),
+    data: formatData,
+    index: getNumber,
+    blockHash: formatHash,
+}, {
+    index: [ "logIndex" ]
+});
+
+export function formatReceiptLog(value: any): LogParams {
+    return _formatReceiptLog(value);
+}
+
+const _formatTransactionReceipt = object({
+    to: allowNull(getAddress, null),
+    from: allowNull(getAddress, null),
+    contractAddress: allowNull(getAddress, null),
+    // should be allowNull(hash), but broken-EIP-658 support is handled in receipt
+    index: getNumber,
+    root: allowNull(hexlify),
+    gasUsed: getBigInt,
+    logsBloom: allowNull(formatData),
+    blockHash: formatHash,
+    hash: formatHash,
+    logs: arrayOf(formatReceiptLog),
+    blockNumber: getNumber,
+    //confirmations: allowNull(getNumber, null),
+    cumulativeGasUsed: getBigInt,
+    effectiveGasPrice: allowNull(getBigInt),
+    status: allowNull(getNumber),
+    type: allowNull(getNumber, 0)
+}, {
+    effectiveGasPrice: [ "gasPrice" ],
+    hash: [ "transactionHash" ],
+    index: [ "transactionIndex" ],
+});
+
+export function formatTransactionReceipt(value: any): TransactionReceiptParams {
+    return _formatTransactionReceipt(value);
+}
+
+export function formatTransactionResponse(value: any): TransactionResponseParams {
+
+    // Some clients (TestRPC) do strange things like return 0x0 for the
+    // 0 address; correct this to be a real address
+    if (value.to && getBigInt(value.to) === BN_0) {
+        value.to = "0x0000000000000000000000000000000000000000";
+    }
+
+    const result = object({
+        hash: formatHash,
+
+        type: (value: any) => {
+            if (value === "0x" || value == null) { return 0; }
+            return getNumber(value);
+        },
+        accessList: allowNull(accessListify, null),
+
+        blockHash: allowNull(formatHash, null),
+        blockNumber: allowNull(getNumber, null),
+        transactionIndex: allowNull(getNumber, null),
+
+        //confirmations: allowNull(getNumber, null),
+
+        from: getAddress,
+
+        // either (gasPrice) or (maxPriorityFeePerGas + maxFeePerGas) must be set
+        gasPrice: allowNull(getBigInt),
+        maxPriorityFeePerGas: allowNull(getBigInt),
+        maxFeePerGas: allowNull(getBigInt),
+
+        gasLimit: getBigInt,
+        to: allowNull(getAddress, null),
+        value: getBigInt,
+        nonce: getNumber,
+        data: formatData,
+
+        creates: allowNull(getAddress, null),
+
+        chainId: allowNull(getBigInt, null)
+    }, {
+        data: [ "input" ],
+        gasLimit: [ "gas" ]
+    })(value);
+
+    // If to and creates are empty, populate the creates from the value
+    if (result.to == null && result.creates == null) {
+        result.creates = getCreateAddress(result);
+    }
+
+    // @TODO: Check fee data
+
+    // Add an access list to supported transaction types
+    if ((value.type === 1 || value.type === 2) && value.accessList == null) {
+        result.accessList = [ ];
+    }
+
+    // Compute the signature
+    if (value.signature) {
+        result.signature = Signature.from(value.signature);
+    } else {
+        result.signature = Signature.from(value);
+    }
+
+    // Some backends omit ChainId on legacy transactions, but we can compute it
+    if (result.chainId == null) {
+        const chainId = result.signature.legacyChainId;
+        if (chainId != null) { result.chainId = chainId; }
+    }
+
+
+    // @TODO: check chainID
+    /*
+    if (value.chainId != null) {
+        let chainId = value.chainId;
+
+        if (isHexString(chainId)) {
+            chainId = BigNumber.from(chainId).toNumber();
+        }
+
+        result.chainId = chainId;
+
+    } else {
+        let chainId = value.networkId;
+
+        // geth-etc returns chainId
+        if (chainId == null && result.v == null) {
+            chainId = value.chainId;
+        }
+
+        if (isHexString(chainId)) {
+            chainId = BigNumber.from(chainId).toNumber();
+        }
+
+        if (typeof(chainId) !== "number" && result.v != null) {
+            chainId = (result.v - 35) / 2;
+            if (chainId < 0) { chainId = 0; }
+            chainId = parseInt(chainId);
+        }
+
+        if (typeof(chainId) !== "number") { chainId = 0; }
+
+        result.chainId = chainId;
+    }
+    */
+
+    // 0x0000... should actually be null
+    if (result.blockHash && getBigInt(result.blockHash) === BN_0) {
+        result.blockHash = null;
+    }
+
+    return result;
+}

package/src.ts/providers/formatting.ts

@@ -0,0 +1,356 @@
+/**
+ *  About provider formatting?
+ *
+ *  @_section: api/providers/formatting:Formatting  [provider-formatting]
+ */
+
+import type { Signature } from "../crypto/index.js";
+import type { AccessList } from "../transaction/index.js";
+
+
+//////////////////////
+// Block
+
+/**
+ *  a **BlockParams** encodes the minimal required properties for a
+ *  formatted block.
+ */
+export interface BlockParams {
+    /**
+     *  The block hash.
+     */
+    hash?: null | string;
+
+    /**
+     *  The block number.
+     */
+    number: number;
+
+    /**
+     *  The timestamp for this block, which is the number of seconds
+     *  since epoch that this block was included.
+     */
+    timestamp: number;
+
+    /**
+     *  The hash of the previous block in the blockchain. The genesis block
+     *  has the parentHash of the [[ZeroHash]].
+     */
+    parentHash: string;
+
+    /**
+     *  A random sequence provided during the mining process for
+     *  proof-of-work networks.
+     */
+    nonce: string;
+
+    /**
+     *  For proof-of-work networks, the difficulty target is used to
+     *  adjust the difficulty in mining to ensure a expected block rate.
+     */
+    difficulty: bigint;
+
+    /**
+     *  The maximum amount of gas a block can consume.
+     */
+    gasLimit: bigint;
+
+    /**
+     *  The amount of gas a block consumed.
+     */
+    gasUsed: bigint;
+
+    /**
+     *  The miner (or author) of a block.
+     */
+    miner: string;
+
+    /**
+     *  Additional data the miner choose to include.
+     */
+    extraData: string;
+
+    /**
+     *  The protocol-defined base fee per gas in an [[link-eip-1559]]
+     *  block.
+     */
+    baseFeePerGas: null | bigint;
+
+    /**
+     *  The list of transactions in the block.
+     */
+    transactions: ReadonlyArray<string | TransactionResponseParams>;
+};
+
+
+//////////////////////
+// Log
+
+/**
+ *  a **LogParams** encodes the minimal required properties for a
+ *  formatted log.
+ */
+export interface LogParams {
+    /**
+     *  The transaction hash for the transaxction the log occurred in.
+     */
+    transactionHash: string;
+
+    /**
+     *  The block hash of the block that included the transaction for this
+     *  log.
+     */
+    blockHash: string;
+
+    /**
+     *  The block number of the block that included the transaction for this
+     *  log.
+     */
+    blockNumber: number;
+
+    /**
+     *  Whether this log was removed due to the transaction it was included
+     *  in being removed dur to an orphaned block.
+     */
+    removed: boolean;
+
+    /**
+     *  The address of the contract that emitted this log.
+     */
+    address: string;
+
+    /**
+     *  The data emitted with this log.
+     */
+    data: string;
+
+    /**
+     *  The topics emitted with this log.
+     */
+    topics: ReadonlyArray<string>;
+
+    /**
+     *  The index of this log.
+     */
+    index: number;
+
+    /**
+     *  The transaction index of this log.
+     */
+    transactionIndex: number;
+}
+
+
+//////////////////////
+// Transaction Receipt
+
+/**
+ *  a **TransactionReceiptParams** encodes the minimal required properties
+ *  for a formatted transaction receipt.
+ */
+export interface TransactionReceiptParams {
+    /**
+     *  The target of the transaction. If null, the transaction was trying
+     *  to deploy a transaction with the ``data`` as the initi=code.
+     */
+    to: null | string;
+
+    /**
+     *  The sender of the transaction.
+     */
+    from: string;
+
+    /**
+     *  If the transaction was directly deploying a contract, the [[to]]
+     *  will be null, the ``data`` will be initcode and if successful, this
+     *  will be the address of the contract deployed.
+     */
+    contractAddress: null | string;
+
+    /**
+     *  The transaction hash.
+     */
+    hash: string;
+
+    /**
+     *  The transaction index.
+     */
+    index: number;
+
+    /**
+     *  The block hash of the block that included this transaction.
+     */
+    blockHash: string;
+
+    /**
+     *  The block number of the block that included this transaction.
+     */
+    blockNumber: number;
+
+    /**
+     *  The bloom filter for the logs emitted during execution of this
+     *  transaction.
+     */
+    logsBloom: string;
+
+    /**
+     *  The logs emitted during the execution of this transaction.
+     */
+    logs: ReadonlyArray<LogParams>;
+
+    /**
+     *  The amount of gas consumed executing this transaciton.
+     */
+    gasUsed: bigint;
+
+    /**
+     *  The total amount of gas consumed during the entire block up to
+     *  and including this transaction.
+     */
+    cumulativeGasUsed: bigint;
+
+    /**
+     *  The actual gas price per gas charged for this transaction.
+     */
+    gasPrice?: null | bigint;
+
+    /**
+     *  The actual gas price per gas charged for this transaction.
+     */
+    effectiveGasPrice?: null | bigint;
+
+    /**
+     *  The [[link-eip-2718]] envelope type.
+     */
+    type: number;
+    //byzantium: boolean;
+
+    /**
+     *  The status of the transaction execution. If ``1`` then the
+     *  the transaction returned success, if ``0`` then the transaction
+     *  was reverted. For pre-byzantium blocks, this is usually null, but
+     *  some nodes may have backfilled this data.
+     */
+    status: null | number;
+
+    /**
+     *  The root of this transaction in a pre-bazatium block. In
+     *  post-byzantium blocks this is null.
+     */
+    root: null | string;
+}
+
+/*
+export interface LegacyTransactionReceipt {
+    byzantium: false;
+    status: null;
+    root: string;
+}
+
+export interface ByzantiumTransactionReceipt {
+    byzantium: true;
+    status: number;
+    root: null;
+}
+*/
+
+
+
+//////////////////////
+// Transaction Response
+
+/**
+ *  a **TransactionResponseParams** encodes the minimal required properties
+ *  for a formatted transaction response.
+ */
+export interface TransactionResponseParams {
+    /**
+     *  The block number of the block that included this transaction.
+     */
+    blockNumber: null | number;
+
+    /**
+     *  The block hash of the block that included this transaction.
+     */
+    blockHash: null | string;
+
+    /**
+     *  The transaction hash.
+     */
+    hash: string;
+
+    /**
+     *  The transaction index.
+     */
+    index: number;
+
+    /**
+     *  The [[link-eip-2718]] transaction type.
+     */
+    type: number;
+
+    /**
+     *  The target of the transaction. If ``null``, the ``data`` is initcode
+     *  and this transaction is a deployment transaction.
+     */
+    to: null | string;
+
+    /**
+     *  The sender of the transaction.
+     */
+    from: string;
+
+    /**
+     *  The nonce of the transaction, used for replay protection.
+     */
+    nonce: number;
+
+    /**
+     *  The maximum amount of gas this transaction is authorized to consume.
+     */
+    gasLimit: bigint;
+
+    /**
+     *  For legacy transactions, this is the gas price per gas to pay.
+     */
+    gasPrice: bigint;
+
+    /**
+     *  For [[link-eip-1559]] transactions, this is the maximum priority
+     *  fee to allow a producer to claim.
+     */
+    maxPriorityFeePerGas: null | bigint;
+
+    /**
+     *  For [[link-eip-1559]] transactions, this is the maximum fee that
+     *  will be paid.
+     */
+    maxFeePerGas: null | bigint;
+
+    /**
+     *  The transaction data.
+     */
+    data: string;
+
+    /**
+     *  The transaction value (in wei).
+     */
+    value: bigint;
+
+    /**
+     *  The chain ID this transaction is valid on.
+     */
+    chainId: bigint;
+
+    /**
+     *  The signature of the transaction.
+     */
+    signature: Signature;
+
+    /**
+     *  The transaction access list.
+     */
+    accessList: null | AccessList;
+};
+
+