chore(ts-tests): add e2e contracts

.dockerignore

@@ -6,3 +6,4 @@ target
 netlify.toml
 *.md
 Dockerfile
+ts-tests

.github/workflows/ci.yml

@@ -119,4 +119,4 @@ jobs:
           node-version: '16'
           cache: 'npm'
           cache-dependency-path: 'ts-tests/package-lock.json'
-      - run: cd ts-tests && npm ci && npm t 
+      - run: cd ts-tests && npm ci && npm run build && npm t 

ts-tests/.prettierrc

@@ -1,5 +1,6 @@
 {
   "semi": true,
+  "singleQuote": true,
   "trailingComma": "none",
-  "singleQuote": true
+  "printWidth": 120
 }

ts-tests/__tests__/balances.test.ts

@@ -1,3 +1,4 @@
+import { ethers } from 'ethers';
 import { MetaDContainer } from '../containers';
 import {
   GENESIS_ACCOUNT,
@@ -9,54 +10,86 @@ import {
 const container = new MetaDContainer();
 const TEST_ACCOUNT = '0x1111111111111111111111111111111111111111';
 
-beforeAll(async () => {
-  await container.start();
-});
+const value = '0x200'; // 512, must be higher than ExistentialDeposit
+const gasPrice = '0x3B9ACA00'; // 1000000000
 
-afterAll(async () => {
-  await container.stop();
-});
+// GENESIS_ACCOUNT_BALANCE - (21000 * gasPrice) - value;
+const expectedGenesisBalance = (
+  BigInt(GENESIS_ACCOUNT_BALANCE) -
+  BigInt(21000) * BigInt(gasPrice) -
+  BigInt(value)
+).toString();
+
+const expectedTestBalance = (Number(value) - EXISTENTIAL_DEPOSIT).toString();
+
+describe('web3', () => {
+  beforeAll(async () => {
+    await container.start();
+  });
+
+  afterAll(async () => {
+    await container.stop();
+  });
+
+  it('should genesis balance setup correctly', async () => {
+    const bal = await container.web3.eth.getBalance(GENESIS_ACCOUNT);
+    expect(bal).toStrictEqual(GENESIS_ACCOUNT_BALANCE);
+  });
+
+  it('should transfer balance', async () => {
+    const tx = await container.web3.eth.accounts.signTransaction(
+      {
+        from: GENESIS_ACCOUNT,
+        to: TEST_ACCOUNT,
+        value: value,
+        gasPrice: gasPrice,
+        gas: '0x100000'
+      },
+      GENESIS_ACCOUNT_PRIVATE_KEY
+    );
+
+    await container.call('eth_sendRawTransaction', [tx?.rawTransaction]);
+
+    expect(await container.web3.eth.getBalance(GENESIS_ACCOUNT, 'pending')).toStrictEqual(expectedGenesisBalance);
+    expect(await container.web3.eth.getBalance(TEST_ACCOUNT, 'pending')).toStrictEqual(expectedTestBalance);
 
-it('should genesis balance setup correctly', async () => {
-  const bal = await container.web3.eth.getBalance(GENESIS_ACCOUNT);
-  expect(bal).toStrictEqual(GENESIS_ACCOUNT_BALANCE);
+    await container.generate();
+
+    expect(await container.web3.eth.getBalance(GENESIS_ACCOUNT)).toStrictEqual(expectedGenesisBalance);
+    expect(await container.web3.eth.getBalance(TEST_ACCOUNT)).toStrictEqual(expectedTestBalance);
+  });
 });
 
-it('should transfer balance', async () => {
-  const value = '0x200'; // 512, must be higher than ExistentialDeposit
-  const gasPrice = '0x3B9ACA00'; // 1000000000
-  const tx = await container.web3.eth.accounts.signTransaction(
-    {
-      from: GENESIS_ACCOUNT,
+describe('ethers', () => {
+  beforeAll(async () => {
+    await container.start();
+  });
+
+  afterAll(async () => {
+    await container.stop();
+  });
+
+  it('should genesis balance setup correctly', async () => {
+    const bal = await container.ethers.getBalance(GENESIS_ACCOUNT);
+    expect(bal.toString()).toStrictEqual(GENESIS_ACCOUNT_BALANCE);
+  });
+
+  it('should transfer balance', async () => {
+    const wallet = new ethers.Wallet(GENESIS_ACCOUNT_PRIVATE_KEY, container.ethers);
+
+    await wallet.sendTransaction({
       to: TEST_ACCOUNT,
       value: value,
       gasPrice: gasPrice,
-      gas: '0x100000'
-    },
-    GENESIS_ACCOUNT_PRIVATE_KEY
-  );
-  await container.call('eth_sendRawTransaction', [tx?.rawTransaction]);
-
-  // GENESIS_ACCOUNT_BALANCE - (21000 * gasPrice) - value;
-  const expectedGenesisBalance = (
-    BigInt(GENESIS_ACCOUNT_BALANCE) -
-    BigInt(21000) * BigInt(gasPrice) -
-    BigInt(value)
-  ).toString();
-  const expectedTestBalance = (Number(value) - EXISTENTIAL_DEPOSIT).toString();
-  expect(
-    await container.web3.eth.getBalance(GENESIS_ACCOUNT, 'pending')
-  ).toStrictEqual(expectedGenesisBalance);
-  expect(
-    await container.web3.eth.getBalance(TEST_ACCOUNT, 'pending')
-  ).toStrictEqual(expectedTestBalance);
-
-  await container.generate();
-
-  expect(await container.web3.eth.getBalance(GENESIS_ACCOUNT)).toStrictEqual(
-    expectedGenesisBalance
-  );
-  expect(await container.web3.eth.getBalance(TEST_ACCOUNT)).toStrictEqual(
-    expectedTestBalance
-  );
+      gasLimit: 0x100000
+    });
+
+    await container.generate();
+
+    const gBal = await container.ethers.getBalance(GENESIS_ACCOUNT);
+    expect(gBal.toString()).toStrictEqual(expectedGenesisBalance);
+
+    const tBal = await container.ethers.getBalance(TEST_ACCOUNT);
+    expect(tBal.toString()).toStrictEqual(expectedTestBalance);
+  });
 });

ts-tests/__tests__/contract.tests.ts

@@ -0,0 +1,62 @@
+import { MetaDContainer } from '../containers';
+import { GENESIS_ACCOUNT, GENESIS_ACCOUNT_PRIVATE_KEY, CONTRACT_ADDRESS } from '../utils/constant';
+import Test from '../build/contracts/Test.json';
+import { ethers } from 'ethers';
+
+const container = new MetaDContainer();
+
+beforeAll(async () => {
+  await container.start();
+});
+
+afterAll(async () => {
+  await container.stop();
+});
+
+it('should create and call contract', async () => {
+  // create contract
+  const wallet = new ethers.Wallet(GENESIS_ACCOUNT_PRIVATE_KEY, container.ethers);
+
+  const factory = new ethers.ContractFactory(Test.abi, Test.bytecode, wallet);
+
+  const contract = await factory.deploy();
+  expect(contract.address).toStrictEqual(CONTRACT_ADDRESS);
+
+  await container.generate();
+
+  // call contract
+  expect(await contract.name()).toStrictEqual('Meta');
+  expect(await contract.owner()).toStrictEqual(GENESIS_ACCOUNT);
+
+  // test environmental
+  const currentBlock = (await contract.getCurrentBlock()).toNumber();
+  expect(currentBlock).toStrictEqual(1);
+
+  const blockHash = await contract.getBlockHash(currentBlock);
+  expect(blockHash).toStrictEqual(expect.any(String));
+
+  const gasLimit = (await contract.getGasLimit()).toNumber();
+  expect(gasLimit).toStrictEqual(75000000);
+
+  // test functional
+  const mul = (await contract.mul(3, 7)).toNumber();
+  expect(mul).toStrictEqual(21);
+
+  const c0 = (await contract.getCount()).toNumber();
+  expect(c0).toStrictEqual(0);
+
+  await contract.incr();
+  await container.generate();
+
+  const c1 = (await contract.getCount()).toNumber();
+  expect(c1).toStrictEqual(1);
+
+  await contract.setCount(25);
+  await container.generate();
+
+  const c25 = (await contract.getCount()).toNumber();
+  expect(c25).toStrictEqual(25);
+
+  const promise = contract.max10(11);
+  await expect(promise).rejects.toThrow('Value must not be greater than 10');
+});

ts-tests/containers/MetaDContainer.ts

@@ -1,14 +1,10 @@
 import { ethers } from 'ethers';
 import Web3 from 'web3';
 import { JsonRpcResponse } from 'web3-core-helpers';
-import {
-  GenericContainer,
-  StartedTestContainer,
-  Network,
-  StartedNetwork
-} from 'testcontainers';
+import { GenericContainer, StartedTestContainer, Network, StartedNetwork } from 'testcontainers';
 import { CHAIN_ID } from '../utils/constant';
 import { HttpProvider, WebsocketProvider } from 'web3-core';
+import { META_LOG } from '../utils/constant';
 
 type MetaDNetwork = 'mainnet' | 'testnet';
 
@@ -65,9 +61,7 @@ export class MetaDContainer {
       '--no-telemetry', // disable connecting to substrate telemtry server
       '--no-prometheus', // do not expose a Prometheus exporter endpoint
       '--no-grandpa',
-      // TODO(canonbrother): set up chain spec exclusively for test
-      // '--chain= ./spec.json',
-      // `-l${FRONTIER_LOG}`,
+      `-l${META_LOG}`,
       `--port=${opts.port}`,
       `--rpc-port=${opts.rpcPort}`,
       `--ws-port=${opts.wsPort}`,
@@ -76,52 +70,56 @@ export class MetaDContainer {
       '--sealing=manual',
       '--force-authoring', // enable authoring even when offline
       '--rpc-cors=all',
-      '--alice', // shortcut for `--name Alice --validator` with session keys for `Alice` added to keystore
+      '--alice', // shortcut for `--name Alice --validator` with session keys for `Alice` added to keystore, required by manual sealing to author the blocks
       '--tmp' // run a temporary node
     ];
   }
 
   async start(startOptions: StartOptions = {}): Promise<void> {
     this.network = await new Network().start();
 
-    this.startOptions = Object.assign(
-      MetaDContainer.MetaDPorts[this.metaDNetwork],
-      startOptions
-    );
+    this.startOptions = Object.assign(MetaDContainer.MetaDPorts[this.metaDNetwork], startOptions);
     const timeout = this.startOptions.timeout ?? 100_000;
 
     this.startedContainer = await this.genericContainer
       .withName(this.generateName())
       .withNetworkMode(this.network.getName())
       .withCmd(this.getCmd(this.startOptions))
-      .withExposedPorts(
-        ...Object.values(MetaDContainer.MetaDPorts[this.metaDNetwork])
-      )
+      .withExposedPorts(...Object.values(MetaDContainer.MetaDPorts[this.metaDNetwork]))
       .withStartupTimeout(timeout)
       .start();
 
     this.web3 =
       this.provider !== 'http'
         ? new Web3(
-            `ws://127.0.0.1:${this.startedContainer.getMappedPort(
-              MetaDContainer.MetaDPorts[this.metaDNetwork].wsPort
-            )}`
+            `ws://127.0.0.1:${this.startedContainer.getMappedPort(MetaDContainer.MetaDPorts[this.metaDNetwork].wsPort)}`
           )
         : new Web3(
             `http://127.0.0.1:${this.startedContainer.getMappedPort(
               MetaDContainer.MetaDPorts[this.metaDNetwork].rpcPort
             )}`
           );
 
-    this.ethers = new ethers.providers.StaticJsonRpcProvider(
-      `http://127.0.0.1:${this.startedContainer.getMappedPort(
-        MetaDContainer.MetaDPorts[this.metaDNetwork].rpcPort
-      )}`,
-      {
-        chainId: CHAIN_ID,
-        name: 'meta'
-      }
-    );
+    this.ethers =
+      this.provider !== 'http'
+        ? new ethers.providers.JsonRpcProvider(
+            `ws://127.0.0.1:${this.startedContainer.getMappedPort(
+              MetaDContainer.MetaDPorts[this.metaDNetwork].wsPort
+            )}`,
+            {
+              chainId: CHAIN_ID,
+              name: 'meta'
+            }
+          )
+        : new ethers.providers.JsonRpcProvider(
+            `http://127.0.0.1:${this.startedContainer.getMappedPort(
+              MetaDContainer.MetaDPorts[this.metaDNetwork].rpcPort
+            )}`,
+            {
+              chainId: CHAIN_ID,
+              name: 'meta'
+            }
+          );
   }
 
   async stop(): Promise<void> {
@@ -130,26 +128,12 @@ export class MetaDContainer {
   }
 
   async call(method: string, params: any[]): Promise<any> {
-    return new Promise<JsonRpcResponse>((resolve, reject) => {
-      (this.web3.currentProvider as HttpProvider | WebsocketProvider).send(
-        {
-          jsonrpc: '2.0',
-          id: Math.floor(Math.random() * 100000000000000),
-          method,
-          params
-        },
-        (error: Error | null, response: JsonRpcResponse | undefined) => {
-          if (error) {
-            reject(
-              `Failed to send custom request (${method} (${params.join(
-                ','
-              )})): ${error.message || error.toString()}`
-            );
-          }
-          resolve(response?.result);
-        }
-      );
-    });
+    try {
+      return this.ethers.send(method, params);
+    } catch (err: any) {
+      const { error } = JSON.parse(err.body);
+      throw new MetaDRpcError(error);
+    }
   }
 
   // Create a block and finalize it.
@@ -168,3 +152,12 @@ export class MetaDContainer {
     return `${MetaDContainer.PREFIX}-${this.metaDNetwork}-${rand}`;
   }
 }
+
+/**
+ * RPC error from container
+ */
+export class MetaDRpcError extends Error {
+  constructor(error: { code: number; message: string }) {
+    super(`MetaDRpcError: ' ${error.message}', code: ${error.code}`);
+  }
+}