essential-eth 0.4.7 → 0.4.9-beta.1

package/src/classes/test/Contract/uni.test.ts

@@ -0,0 +1,72 @@
+import { Contract as EthersContract } from '@ethersproject/contracts';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { JsonRpcProvider } from '../../../providers/JsonRpcProvider';
+import { Contract as EssentialEthContract } from '../../Contract';
+import { uniswapABI } from './uniswap-abi';
+
+// The JSONABI
+const JSONABI = uniswapABI;
+
+const rpcURL = `${process.env.RPC_ORIGIN}/api/eth`;
+const ethersProvider = new StaticJsonRpcProvider(rpcURL);
+const essentialEthProvider = new JsonRpcProvider(rpcURL);
+
+// The UNI airdrop merkle address
+// https://etherscan.io/address/0x090D4613473dEE047c3f2706764f49E0821D256e#readContract
+const contractAddress = '0x090D4613473dEE047c3f2706764f49E0821D256e';
+
+const smartContractIsUniClaimed = async (contract: any, index: number) => {
+  const isClaimed = (await contract.isClaimed(index)) as boolean;
+  return isClaimed;
+};
+
+const smartContractGetUniMerkleRoot = async (contract: any) => {
+  const merkleRoot = (await contract.merkleRoot()) as string;
+  return merkleRoot;
+};
+const smartContractGetUniTokenAddress = async (contract: any) => {
+  const merkleRoot = (await contract.token()) as string;
+  return merkleRoot;
+};
+
+const ethersContract = new EthersContract(
+  contractAddress,
+  JSONABI as any,
+  ethersProvider,
+);
+const essentialEthContract = new EssentialEthContract(
+  contractAddress,
+  JSONABI,
+  essentialEthProvider,
+);
+describe('uNI contract', () => {
+  it('should fetch "address" data-type', async () => {
+    const [ethersResponse, essentialEthResponse] = await Promise.all([
+      smartContractGetUniTokenAddress(ethersContract),
+      smartContractGetUniTokenAddress(essentialEthContract),
+    ]);
+    /* 0x1f9840a85d5af5bf1d1762f925bdaddc4201f984 */
+    expect(ethersResponse).toStrictEqual(essentialEthResponse);
+  });
+  it('should fetch "bytes32" merkle root', async () => {
+    const [ethersResponse, essentialEthResponse] = await Promise.all([
+      smartContractGetUniMerkleRoot(ethersContract),
+      smartContractGetUniMerkleRoot(essentialEthContract),
+    ]);
+    /* 0xc8500f8e2fcf3c9a32880e1b973fb28acc88be35787a8abcf9981b2b65dbdeb5 */
+    expect(ethersResponse).toStrictEqual(essentialEthResponse);
+  });
+
+  it('should fetch isClaimed "boolean" for random airdrop indexes', async () => {
+    /* indexes of addresses in the merkle tree */
+    const randomIndexes = [0, 4, 102, 999, 999999];
+
+    for (const i of randomIndexes) {
+      const [ethersClaimed, essentialEthClaimed] = await Promise.all([
+        smartContractIsUniClaimed(ethersContract, i),
+        smartContractIsUniClaimed(essentialEthContract, i),
+      ]);
+      expect(ethersClaimed).toStrictEqual(essentialEthClaimed);
+    }
+  });
+});

package/src/classes/test/Contract/uniswap-abi.ts

@@ -0,0 +1,121 @@
+import { JSONABI } from '../../../types/Contract.types';
+
+export const uniswapABI: JSONABI =
+  // http://api.etherscan.io/api?module=contract&action=getabi&address=0x090d4613473dee047c3f2706764f49e0821d256e&format=raw
+
+  [
+    {
+      inputs: [
+        {
+          internalType: 'address',
+          name: 'token_',
+          type: 'address',
+        },
+        {
+          internalType: 'bytes32',
+          name: 'merkleRoot_',
+          type: 'bytes32',
+        },
+      ],
+      stateMutability: 'nonpayable',
+      type: 'constructor',
+    },
+    {
+      anonymous: false,
+      inputs: [
+        {
+          indexed: false,
+          internalType: 'uint256',
+          name: 'index',
+          type: 'uint256',
+        },
+        {
+          indexed: false,
+          internalType: 'address',
+          name: 'account',
+          type: 'address',
+        },
+        {
+          indexed: false,
+          internalType: 'uint256',
+          name: 'amount',
+          type: 'uint256',
+        },
+      ],
+      name: 'Claimed',
+      type: 'event',
+    },
+    {
+      inputs: [
+        {
+          internalType: 'uint256',
+          name: 'index',
+          type: 'uint256',
+        },
+        {
+          internalType: 'address',
+          name: 'account',
+          type: 'address',
+        },
+        {
+          internalType: 'uint256',
+          name: 'amount',
+          type: 'uint256',
+        },
+        {
+          internalType: 'bytes32[]',
+          name: 'merkleProof',
+          type: 'bytes32[]',
+        },
+      ],
+      name: 'claim',
+      outputs: [],
+      stateMutability: 'nonpayable',
+      type: 'function',
+    },
+    {
+      inputs: [
+        {
+          internalType: 'uint256',
+          name: 'index',
+          type: 'uint256',
+        },
+      ],
+      name: 'isClaimed',
+      outputs: [
+        {
+          internalType: 'bool',
+          name: '',
+          type: 'bool',
+        },
+      ],
+      stateMutability: 'view',
+      type: 'function',
+    },
+    {
+      inputs: [],
+      name: 'merkleRoot',
+      outputs: [
+        {
+          internalType: 'bytes32',
+          name: '',
+          type: 'bytes32',
+        },
+      ],
+      stateMutability: 'view',
+      type: 'function',
+    },
+    {
+      inputs: [],
+      name: 'token',
+      outputs: [
+        {
+          internalType: 'address',
+          name: '',
+          type: 'address',
+        },
+      ],
+      stateMutability: 'view',
+      type: 'function',
+    },
+  ];

package/src/classes/utils/clean-block.ts

@@ -0,0 +1,49 @@
+import { Block, toChecksumAddress } from '../..';
+import { RPCBlock } from '../../types/Block.types';
+import { RPCTransaction } from '../../types/Transaction.types';
+import { cleanTransaction } from './clean-transaction';
+import { hexToDecimal } from './hex-to-decimal';
+
+/**
+ * Converts hex to decimal and checksum-addresses all addresses
+ */
+export function cleanBlock(
+  block: RPCBlock,
+  returnTransactionObjects: boolean,
+): Block {
+  const cleanedBlock: any = { ...block };
+  (Object.keys(block) as Array<keyof RPCBlock>).forEach((key) => {
+    // pending blocks have null instead of a difficulty
+    // pending blocks have null instead of a miner address
+    if (!block[key]) return;
+    switch (key) {
+      case 'gasLimit':
+      case 'gasUsed':
+      case 'number':
+      case 'size':
+      case 'timestamp':
+      case 'baseFeePerGas':
+        cleanedBlock[key] = Number(hexToDecimal(block[key]));
+        break;
+      case 'difficulty':
+      case 'totalDifficulty':
+        cleanedBlock[key] = hexToDecimal(block[key]);
+        break;
+      case 'miner':
+        if (block[key]) {
+          cleanedBlock[key] = toChecksumAddress(block[key]);
+        }
+        break;
+    }
+  });
+  // for all full transactions
+  if (returnTransactionObjects) {
+    // could be renamed "cleanTransaction" in the future
+    (cleanedBlock.transactions as RPCTransaction[]).forEach(
+      (transaction, index) => {
+        cleanedBlock.transactions[index] = cleanTransaction(transaction);
+      },
+    );
+  }
+  return cleanedBlock;
+}

package/src/classes/utils/clean-transaction.ts

@@ -0,0 +1,35 @@
+import { toChecksumAddress } from '../..';
+import { RPCTransaction, Transaction } from '../../types/Transaction.types';
+import { hexToDecimal } from './hex-to-decimal';
+
+/**
+ * Converts hex to decimal and checksum-addresses all addresses
+ */
+export function cleanTransaction(transaction: RPCTransaction): Transaction {
+  const cleanedTransaction: any = { ...transaction };
+  (Object.keys(transaction) as Array<keyof RPCTransaction>).forEach((key) => {
+    // pending blocks have null instead of a difficulty
+    // pending blocks have null instead of a miner address
+    if (!transaction[key]) return;
+    switch (key) {
+      case 'blockNumber':
+      case 'gas':
+      case 'nonce':
+      case 'transactionIndex':
+      case 'type':
+        cleanedTransaction[key] = Number(hexToDecimal(transaction[key]));
+        break;
+      case 'gasPrice':
+      case 'value':
+        cleanedTransaction[key] = hexToDecimal(transaction[key]);
+        break;
+      case 'from':
+      case 'to':
+        if (transaction[key]) {
+          cleanedTransaction[key] = toChecksumAddress(transaction[key]);
+        }
+        break;
+    }
+  });
+  return cleanedTransaction;
+}

package/src/classes/utils/encode-decode-transaction.ts

@@ -0,0 +1,126 @@
+import { Keccak } from 'sha3';
+import { tinyBig, toChecksumAddress } from '../..';
+import { ContractTypes, JSONABIArgument } from '../../types/Contract.types';
+import { hexToDecimal } from './hex-to-decimal';
+
+const hexTrue =
+  '0000000000000000000000000000000000000000000000000000000000000001';
+const hexFalse =
+  '0000000000000000000000000000000000000000000000000000000000000000';
+
+function expandType(type: ContractTypes) {
+  // https://docs.soliditylang.org/en/v0.8.7/types.html#integers
+  if (type === 'uint[]') {
+    return 'uint256[]';
+  } else if (type === 'int[]') {
+    return 'int256[]';
+  }
+  return type;
+}
+export function encodeData(jsonABIArgument: JSONABIArgument, args: any[]) {
+  const hash = new Keccak(256);
+  /* first 4 bytes will create the data parameter */
+  const functionString = `${jsonABIArgument.name}(${jsonABIArgument.inputs.map(
+    (input) => expandType(input.type),
+  )})`;
+
+  // encoding learnt from https://ethereum.stackexchange.com/questions/3514/how-to-call-a-contract-method-using-the-eth-call-json-rpc-api
+  const functionHash = hash.update(functionString).digest('hex');
+  // no arrays
+  const jsonABIInputsLength = jsonABIArgument.inputs.length;
+  let shouldValidateInputLength = true;
+
+  // inputs contains 1 or more arrays
+  if (jsonABIArgument.inputs.find((input) => input.type.includes('['))) {
+    shouldValidateInputLength = false;
+  }
+  if (shouldValidateInputLength && args.length !== jsonABIInputsLength) {
+    throw new Error(
+      `args inputs  of "${args.length}" does not match expected length of "${jsonABIArgument.inputs.length}"`,
+    );
+  }
+
+  const argsWithTypes: [arg: any, type: ContractTypes][] = (
+    jsonABIArgument.inputs || []
+  ).reduce((acc, input, i) => {
+    if (input.type.includes('[')) {
+      // strip array and length like "[2]" from type
+      const basicType = /([^[]*)\[.*$/g.exec(input.type)?.[1] as string;
+      args.forEach((arg: any) => {
+        acc = acc.concat([[arg, basicType]]);
+      });
+      return acc;
+    } else {
+      return acc.concat([[args[i], input.type]]);
+    }
+  }, [] as [arg: any, type: ContractTypes][]);
+
+  const encodedArgs = argsWithTypes.map(([arg, inputType]) => {
+    let rawArg = arg;
+    switch (inputType) {
+      case 'bool':
+        return arg ? hexTrue : hexFalse;
+      case 'address':
+        // remove leading "0x"
+        rawArg = arg.replace(/^0x/g, '').toLowerCase();
+        break;
+      default:
+        if (inputType.startsWith('bytes')) {
+          // encode each character to hex
+          const argEncoded = rawArg
+            .split('')
+            .map((character: string) => character.charCodeAt(0).toString(16))
+            .join('');
+          const paddedEncodedArg = argEncoded.padEnd(64, '0');
+          return paddedEncodedArg;
+        } else if (inputType === 'uint256') {
+          const argEncoded = BigInt(arg).toString(16);
+          const paddedEncodedArg = argEncoded.padStart(64, '0');
+          return paddedEncodedArg;
+        } else if (inputType.startsWith('uint')) {
+          break;
+        } else {
+          throw new Error(
+            `essential-eth does not yet support "${inputType}" inputs. Make a PR today!"`,
+          );
+        }
+    }
+    const argEncoded = rawArg.toString(16) as string;
+    const paddedEncodedArg = argEncoded.padStart(64, '0');
+    return paddedEncodedArg;
+  });
+  const functionEncoded = functionHash.slice(0, 8);
+  const data = `0x${functionEncoded}${encodedArgs.join('')}`;
+  return data;
+}
+
+export function decodeRPCResponse(
+  jsonABIArgument: JSONABIArgument,
+  nodeResponse: string,
+) {
+  const rawOutputs = jsonABIArgument.outputs;
+  // chunk response every 64 characters
+  const encodedOutputs = nodeResponse.slice(2).match(/.{1,64}/g);
+  const outputs = (encodedOutputs || []).map((output: string, i: number) => {
+    const outputType = (rawOutputs || [])[i].type;
+    switch (outputType) {
+      case 'bool':
+        return output === hexTrue;
+      case 'address':
+        /* address types have 26 leading zeroes to remove */
+        return toChecksumAddress(`0x${output.slice(24)}`);
+      case 'uint256':
+        return tinyBig(hexToDecimal(`0x${output}`));
+      case 'bytes32':
+        return `0x${output}`;
+      case 'uint8':
+        return Number(hexToDecimal(`0x${output}`));
+      default:
+        throw new Error(
+          `essential-eth does not yet support "${outputType}" outputs. Make a PR today!"`,
+        );
+    }
+  });
+
+  return outputs.length === 1 ? outputs[0] : outputs;
+}

package/src/classes/utils/fetchers.ts

@@ -0,0 +1,27 @@
+import unfetch from 'isomorphic-unfetch';
+export function post(url: string, body: Record<string, unknown>) {
+  return unfetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(body),
+  })
+    .then((r) => r.json())
+    .then((response) => {
+      if (response.error) {
+        throw new Error(response.error);
+      }
+      return response.result;
+    });
+}
+
+type RPCMethodName = 'eth_getBlockByNumber' | 'eth_call' | 'eth_chainId';
+export function buildRPCPostBody(method: RPCMethodName, params: any[]) {
+  return {
+    jsonrpc: '2.0',
+    id: 1,
+    method,
+    params,
+  };
+}

package/{lib/cjs/classes/utils/hex-to-decimal.d.ts → src/classes/utils/hex-to-decimal.ts}

@@ -2,4 +2,6 @@
  * Converts a hexadecimal string it's decimal equivalent.
  * This is needed instead of parseInt because parseInt loses precision
  */
-export declare function hexToDecimal(hex: string): string;
+export function hexToDecimal(hex: string) {
+  return BigInt(hex).toString();
+}

package/src/index.ts

@@ -0,0 +1,27 @@
+import { Contract } from './classes/Contract';
+import { JsonRpcProvider, jsonRpcProvider } from './providers/JsonRpcProvider';
+import { tinyBig, TinyBig } from './shared/tiny-big/tiny-big';
+import { Block } from './types/Block.types';
+import {
+  ContractTypes,
+  JSONABI,
+  JSONABIArgument,
+} from './types/Contract.types';
+import { Network } from './types/Network.types';
+import { Transaction } from './types/Transaction.types';
+export * from './utils';
+export {
+  jsonRpcProvider,
+  JsonRpcProvider,
+  tinyBig,
+  /* classes */
+  Contract,
+  TinyBig,
+  /* types */
+  Block,
+  ContractTypes,
+  JSONABI,
+  JSONABIArgument,
+  Network,
+  Transaction,
+};

package/src/providers/JsonRpcProvider.ts

@@ -0,0 +1,94 @@
+import { cleanBlock } from '../classes/utils/clean-block';
+import { buildRPCPostBody, post } from '../classes/utils/fetchers';
+import { hexToDecimal } from '../classes/utils/hex-to-decimal';
+import { Block, RPCBlock } from '../types/Block.types';
+import { Network } from '../types/Network.types';
+import chainsInfo from './utils/chains-info';
+export class JsonRpcProvider {
+  /**
+   * The URL to your Eth node. Consider POKT or Infura
+   */
+  readonly _rpcUrl: Array<string>;
+  _rpcUrlCounter: number;
+  constructor(rpcUrl?: string | Array<string>) {
+    this._rpcUrl = ((): Array<string> => {
+      if (!rpcUrl) {
+        return ['https://free-eth-node.com/api/eth'];
+      } else if (!Array.isArray(rpcUrl)) {
+        return [rpcUrl];
+      }
+      return rpcUrl;
+    })();
+    this._rpcUrlCounter = 0;
+  }
+
+  /**
+   * Returns the block requested
+   * Same as `web3.eth.getBlock`
+   */
+  public async getBlock(
+    timeFrame:
+      | 'latest'
+      | 'earliest'
+      | 'pending'
+      | number /* block number as integer */,
+    returnTransactionObjects = false,
+  ): Promise<Block> {
+    let rpcTimeFrame: string;
+    if (typeof timeFrame === 'number') {
+      // exact block numbers require hex string format
+      rpcTimeFrame = `0x${timeFrame.toString(16)}`;
+    } else {
+      // "latest", "earliest", and "pending" require no manipulation
+      rpcTimeFrame = timeFrame;
+    }
+    const req = async (): Promise<RPCBlock> => {
+      return await post(
+        this._rpcUrl[this._rpcUrlCounter],
+        buildRPCPostBody('eth_getBlockByNumber', [
+          rpcTimeFrame,
+          returnTransactionObjects,
+        ]),
+      ).catch((e) => {
+        if (e.code === 'ENOTFOUND') {
+          this._rpcUrlCounter++;
+          return req();
+        }
+      });
+    };
+    const nodeResponse = (await req()) as RPCBlock;
+
+    return cleanBlock(nodeResponse, returnTransactionObjects);
+  }
+  /**
+   * Returns the network this provider is connected to
+   */
+  public async getNetwork(): Promise<Network> {
+    const req = async (): Promise<string> => {
+      return await post(
+        this._rpcUrl[this._rpcUrlCounter],
+        buildRPCPostBody('eth_chainId', []),
+      ).catch((e) => {
+        if (e.code === 'ENOTFOUND') {
+          this._rpcUrlCounter++;
+          return req();
+        }
+      });
+    };
+    const nodeResponse = (await req()) as string;
+    const chainId = hexToDecimal(nodeResponse);
+    const info = (chainsInfo as any)[chainId];
+    return {
+      chainId: Number(chainId),
+      name: info[0] || 'unknown',
+      ensAddress: info[1] || null, // only send ensAddress if it exists
+    };
+  }
+}
+
+/**
+ * Helper function to avoid "new"
+ */
+export function jsonRpcProvider(rpcUrl?: string) {
+  return new JsonRpcProvider(rpcUrl);
+}

package/src/providers/test/get-block.test.ts

@@ -0,0 +1,63 @@
+import Big from 'big.js';
+import omit from 'just-omit';
+import Web3 from 'web3';
+import { Block, JsonRpcProvider } from '../..';
+
+const rpcUrl = `${process.env.RPC_ORIGIN}/api/eth`;
+
+describe('matches web3', () => {
+  function testBlockEquality(block1: Block, block2: Block) {
+    // slight mis-timing in eth node responses
+    expect(
+      (omit as any)(block1, ['totalDifficulty', 'difficulty']),
+    ).toStrictEqual((omit as any)(block2, ['totalDifficulty', 'difficulty']));
+
+    // validate that difficulty and totalDifficulty are still very close
+    expect(
+      Big(block1.difficulty).minus(block2.difficulty).abs().toNumber(),
+    ).toBeLessThan(3);
+
+    expect(
+      Big(block1.totalDifficulty)
+        .minus(block2.totalDifficulty)
+        .abs()
+        .toNumber(),
+    ).toBeLessThan(5000000 /* 2616793 and 1187442 on recent tests */);
+  }
+
+  it('should get latest block', async () => {
+    const essentialEth = new JsonRpcProvider(rpcUrl);
+    const web3 = new Web3(rpcUrl);
+    const [eeLatestBlock, web3LatestBlock] = await Promise.all([
+      essentialEth.getBlock('latest'),
+      web3.eth.getBlock('latest'),
+    ]);
+    testBlockEquality(eeLatestBlock, web3LatestBlock as unknown as Block);
+  });
+  it('should get latest block, uses fallback when first URL fails', async () => {
+    const essentialEth = new JsonRpcProvider([
+      'https://invalid-url.test',
+      rpcUrl,
+    ]);
+    await essentialEth.getBlock('latest');
+  });
+  it('should get earliest block', async () => {
+    const essentialEth = new JsonRpcProvider(rpcUrl);
+    const web3 = new Web3(rpcUrl);
+    const [eeEarliestBlock, web3EarliestBlock] = await Promise.all([
+      essentialEth.getBlock('earliest'),
+      web3.eth.getBlock('earliest'),
+    ]);
+    testBlockEquality(eeEarliestBlock, web3EarliestBlock as unknown as Block);
+  });
+  const blockNumber = Math.floor(Math.random() * 13250630);
+  it(`should get random block as decimal integer. (block #${blockNumber})`, async () => {
+    const essentialEth = new JsonRpcProvider(rpcUrl);
+    const web3 = new Web3(rpcUrl);
+    const [eeRandomBlock, web3RandomBlock] = await Promise.all([
+      essentialEth.getBlock(blockNumber, true),
+      web3.eth.getBlock(blockNumber, true),
+    ]);
+    testBlockEquality(eeRandomBlock, web3RandomBlock as unknown as Block);
+  });
+});

package/src/providers/test/get-network.test.ts

@@ -0,0 +1,34 @@
+import { ethers } from 'ethers';
+import { JsonRpcProvider } from '../..';
+
+const xdaiRPCUrl = `${process.env.RPC_ORIGIN}/api/xdai`;
+const bscRPCUrl = `${process.env.RPC_ORIGIN}/api/bsc`;
+// const kovanRPCUrl = `${process.env.RPC_ORIGIN}/api/kovan`;
+
+describe('get-network', () => {
+  async function testNetwork(rpcUrl: string) {
+    const essentialEth = new JsonRpcProvider(rpcUrl);
+    const ethersProvider = new ethers.providers.StaticJsonRpcProvider(rpcUrl);
+    const [eeNetwork, ethersNetwork] = await Promise.all([
+      essentialEth.getNetwork(),
+      ethersProvider.getNetwork(),
+    ]);
+
+    expect(eeNetwork.chainId).toBe(ethersNetwork.chainId);
+    expect(eeNetwork.ensAddress).toBe(ethersNetwork.ensAddress);
+    expect(eeNetwork.name).toBe(
+      // xdai was renamed to gnosis but ethers is still out-of-date
+      ethersNetwork.name === 'xdai' ? 'gno' : ethersNetwork.name,
+    );
+  }
+  it('xdai should match ethers', async () => {
+    await testNetwork(xdaiRPCUrl);
+  });
+  it('bsc should match ethers', async () => {
+    await testNetwork(bscRPCUrl);
+  });
+  /* ethers returns "kovan", essential-eth returns "kov" */
+  // it('kovan should match ethers', async () => {
+  //   await testNetwork(kovanRPCUrl);
+  // });
+});