essential-eth 0.4.9-beta.0 → 0.4.9-beta.3

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

@@ -1,72 +0,0 @@
-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

@@ -1,121 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,126 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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/src/providers/JsonRpcProvider.ts

@@ -1,94 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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);
-  // });
-});