improve(sdk): add support for Multicall2 contract (#3325)

* Add support for Multipart2 contract

Signed-off-by: amateima <[email protected]>

* Fix linter issue

Signed-off-by: amateima <[email protected]>

* Revert client to old implementation

Signed-off-by: amateima <[email protected]>

* Add Multicall2 separate client

Signed-off-by: amateima <[email protected]>

* Implement changes suggested in review

Signed-off-by: amateima <[email protected]>

* Improve tests

Signed-off-by: amateima <[email protected]>

* Improve typescript integration

Signed-off-by: amateima <[email protected]>

* Make contract abstract

Signed-off-by: amateima <[email protected]>

Author: amateima

packages/core/contracts/common/interfaces/Multicall2.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity >=0.5.0;
+
+/**
+ * @title interface for MakerDao's Multicall2 contract.
+ * @dev This adds method to allow calls within the batch to fail
+ * @dev Full implementation can be found here: https://github.com/makerdao/multicall/blob/16ec5e2859b3a4829ceed4ee1ef609e6e9a744ee/src/Multicall2.sol
+ */
+abstract contract Multicall2 {
+    struct Call {
+        address target;
+        bytes callData;
+    }
+    struct Result {
+        bool success;
+        bytes returnData;
+    }
+
+    function aggregate(Call[] memory calls) public virtual returns (uint256 blockNumber, bytes[] memory returnData);
+
+    function tryBlockAndAggregate(bool requireSuccess, Call[] memory calls)
+        public
+        virtual
+        returns (
+            uint256 blockNumber,
+            bytes32 blockHash,
+            Result[] memory returnData
+        );
+}

packages/sdk/package.json

@@ -42,12 +42,13 @@
     "highland": "^2.13.5"
   },
   "devDependencies": {
-    "@types/highland": "^2.12.13",
     "@ethersproject/abi": "^5.4.0",
     "@ethersproject/abstract-provider": "^5.4.0",
     "@ethersproject/contracts": "^5.4.0",
     "@ethersproject/providers": "^5.4.2",
     "@size-limit/preset-small-lib": "^4.10.2",
+    "@types/dotenv": "^8.2.0",
+    "@types/highland": "^2.12.13",
     "size-limit": "^4.10.2",
     "tsdx": "^0.14.1",
     "tslib": "^2.2.0"

packages/sdk/src/clients/index.ts

@@ -2,5 +2,6 @@ export * as registry from "./registry";
 export * as emp from "./emp";
 export * as erc20 from "./erc20";
 export * as multicall from "./multicall";
+export * as multicall2 from "./multicall2";
 export * as lspCreator from "./lsp-creator";
 export * as lsp from "./lsp";

packages/sdk/src/clients/multicall/client.e2e.ts

@@ -18,6 +18,7 @@ describe("multicall", function () {
     assert.ok(client);
     assert.ok(empClient);
   });
+
   test("multicall on emp", async function () {
     const calls = ["priceIdentifier", "tokenCurrency", "collateralCurrency"];
     const multicalls = calls.map((call: any) => {

packages/sdk/src/clients/multicall2/README.md

@@ -0,0 +1,17 @@
+# UMA Multicall2 Client
+
+This client helps you batch multiple calls together in a single transaction. Useful also for
+reducing api calls to infura when reading many properties from contracts.
+
+## Usage
+
+```ts
+import { ethers } from "ethers"
+import * as uma from "@uma/sdk"
+
+// assume you have a url injected from env
+const provider = new ethers.providers.WebSocketProvider(env.CUSTOM_NODE_URL)
+
+// get the contract instance
+const client = uma.clients.multicall2.connect(address, provider)
+```

packages/sdk/src/clients/multicall2/client.e2e.ts

@@ -0,0 +1,78 @@
+import assert from "assert";
+import * as Client from "./client";
+import { ethers } from "ethers";
+import { emp } from "..";
+import dotenv from "dotenv";
+
+dotenv.config();
+// multicall contract deployed to mainnet
+const address = "0x5ba1e12693dc8f9c48aad8770482f4739beed696";
+const empAddress = "0x4E3168Ea1082f3dda1694646B5EACdeb572009F1";
+// these require integration testing, skip for ci
+describe("multicall2", function () {
+  let client: Client.Instance;
+  let empClient: emp.Instance;
+
+  test("inits", function () {
+    const provider = ethers.providers.getDefaultProvider(process.env.CUSTOM_NODE_URL);
+    client = Client.connect(address, provider);
+    empClient = emp.connect(empAddress, provider);
+    assert.ok(client);
+    assert.ok(empClient);
+  });
+
+  test("multicall2 on emp", async function () {
+    const calls = ["priceIdentifier", "tokenCurrency", "collateralCurrency"];
+    const multicalls = calls.map((call: any) => {
+      return {
+        target: empAddress,
+        callData: empClient.interface.encodeFunctionData(call),
+      };
+    });
+    const response = await client.callStatic.aggregate(multicalls);
+    const decoded = calls.map((call: any, i: number) => {
+      const result = response.returnData[i];
+      return empClient.interface.decodeFunctionResult(call, result);
+    });
+    assert.equal(decoded.length, calls.length);
+  });
+
+  test("multicall2 on emp with no errors", async function () {
+    const calls = ["priceIdentifier", "tokenCurrency", "collateralCurrency"];
+    const multicalls = calls.map((call: any) => {
+      return {
+        target: empAddress,
+        callData: empClient.interface.encodeFunctionData(call),
+      };
+    });
+    const response = await client.callStatic.tryBlockAndAggregate(false, multicalls);
+    const decoded = calls.map((call: any, i: number) => {
+      const result = response.returnData[i].returnData;
+      return empClient.interface.decodeFunctionResult(call, result);
+    });
+    assert.equal(decoded.length, calls.length);
+  });
+
+  test("multicall2 on emp with errors", async function () {
+    const calls = ["priceIdentifier", "tokenCurrency", "disputeBondPercentage"];
+    const multicalls = calls.map((call) => ({
+      target: empAddress,
+      callData: empClient.interface.encodeFunctionData(call as any),
+    }));
+    const response = await client.callStatic.tryBlockAndAggregate(false, multicalls);
+    const decoded: ethers.utils.Result[] = [];
+    const failedCalls: string[] = [];
+
+    for (let i = 0; i < calls.length; i++) {
+      const result = response.returnData[i].returnData;
+      const call = calls[i];
+
+      if (response.returnData[i].success) {
+        decoded.push(empClient.interface.decodeFunctionResult(call as any, result));
+      } else {
+        failedCalls.push(call);
+      }
+    }
+    assert.ok(decoded.length === 2 && failedCalls.length == 1);
+  });
+});

packages/sdk/src/clients/multicall2/client.ts

@@ -0,0 +1,9 @@
+import { EthersContracts } from "@uma/core";
+import type { SignerOrProvider } from "../..";
+
+export type Instance = EthersContracts.Multicall2;
+const Factory = EthersContracts.Multicall2__factory;
+
+export function connect(address: string, provider: SignerOrProvider): Instance {
+  return Factory.connect(address, provider);
+}

packages/sdk/src/clients/multicall2/index.ts

@@ -0,0 +1 @@
+export * from "./client";