feat: walletconnect

integration/src/integration.ts

@@ -6,6 +6,7 @@ import * as native from "@shapeshiftoss/hdwallet-native";
 import * as portis from "@shapeshiftoss/hdwallet-portis";
 import * as tallyHo from "@shapeshiftoss/hdwallet-tallyho";
 import * as trezor from "@shapeshiftoss/hdwallet-trezor";
+import * as walletconnect from "@shapeshiftoss/hdwallet-walletconnect";
 import * as xdefi from "@shapeshiftoss/hdwallet-xdefi";
 
 import { binanceTests } from "./binance";
@@ -56,6 +57,7 @@ export function integration(suite: WalletSuite): void {
             (native.isNative(wallet) ? 1 : 0) +
             (metamask.isMetaMask(wallet) ? 1 : 0) +
             (tallyHo.isTallyHo(wallet) ? 1 : 0) +
+            (walletconnect.isWalletConnect(wallet) ? 1 : 0) +
             (xdefi.isXDEFI(wallet) ? 1 : 0)
         ).toEqual(1);
       });

integration/src/walletconnect.test.ts

@@ -0,0 +1,3 @@
+import { integration } from "./integration";
+import * as WalletConnect from "./wallets/walletconnect";
+integration(WalletConnect);

integration/src/wallets/walletconnect.ts

@@ -0,0 +1,215 @@
+import * as core from "@shapeshiftoss/hdwallet-core";
+import * as walletconnect from "@shapeshiftoss/hdwallet-walletconnect";
+import WalletConnectProvider from "@walletconnect/web3-provider";
+
+export function name(): string {
+  return "WalletConnect";
+}
+
+export function createInfo(): core.HDWalletInfo {
+  return new walletconnect.WalletConnectWalletInfo();
+}
+
+export async function createWallet(): Promise<core.HDWallet> {
+  const accounts = ["0x3f2329C9ADFbcCd9A84f52c906E936A42dA18CB8", "0x8CB8864f185f14e8d7da0000e4a55a09e4156ff6", "0x4e8d2E3d5FDe8CB80A917e258548268734973f23"];
+  const provider = {
+    request: jest.fn(({ method, params }: any) => {
+      switch (method) {
+        case "eth_accounts":
+          return accounts;
+        case "personal_sign": {
+          const [message] = params;
+
+          if (message === "48656c6c6f20576f726c64")
+            return "0x29f7212ecc1c76cea81174af267b67506f754ea8c73f144afa900a0d85b24b21319621aeb062903e856352f38305710190869c3ce5a1425d65ef4fa558d0fc251b";
+
+          throw new Error("unknown message");
+        }
+        case "eth_sendTransaction": {
+          const [{ to }] = params;
+
+          return `txHash-${to}`;
+        }
+        default:
+          throw new Error(`ethereum: Unkown method ${method}`);
+      }
+    }),
+    bridge: "https://bridge.walletconnect.org",
+    qrcode: true,
+    qrcodeModal: {},
+    qrcodeModalOptions: undefined,
+    rpc: null,
+    infuraId: "",
+    http: null,
+    wc: {
+      sendTransaction: jest.fn((msg) => {
+        const { to } = msg;
+        return {hash: `txHash-${to}`};
+      }),
+      signMessage: jest.fn().mockReturnValue({
+        address: "0x3f2329C9ADFbcCd9A84f52c906E936A42dA18CB8",
+        signature:
+          "0x29f7212ecc1c76cea81174af267b67506f754ea8c73f144afa900a0d85b24b21319621aeb062903e856352f38305710190869c3ce5a1425d65ef4fa558d0fc251b",
+      })
+    }, // connector
+    isConnecting: false,
+    connected: false,
+    connectCallbacks: [],
+    rpcUrl: "",
+    isWalletConnect: true,
+    connector: {
+      chainId: 1,
+      accounts,
+      connected: true
+    },
+    walletMeta: { // wc.peerMeta
+
+    },
+    enable: async () => Promise.resolve(accounts),
+    send: jest.fn(),
+    onConnect: jest.fn(),
+    triggerConnect: jest.fn(),
+    disconnect: jest.fn(), // alias for close
+    close: jest.fn(),
+    handleRequest: jest.fn(),
+    handleOtherRequests: jest.fn(),
+    handleReadRequests: jest.fn(),
+    formatResponse: jest.fn(),
+    getWalletConnector: jest.fn(),
+    subscribeWalletConnector: jest.fn(),
+    onDisconnect: jest.fn(),
+    updateState: jest.fn(),
+    updateRpcUrl: jest.fn(),
+    updateHttpConnection: jest.fn(),
+    sendAsyncPromise: jest.fn()
+  };
+  const wallet = new walletconnect.WalletConnectHDWallet(provider as any);
+  await wallet.initialize();
+  return wallet;
+}
+
+export function selfTest(get: () => core.HDWallet): void {
+  let wallet: walletconnect.WalletConnectHDWallet;
+
+  beforeAll(async () => {
+    const w = get() as walletconnect.WalletConnectHDWallet;
+
+    if (walletconnect.isWalletConnect(w) && !core.supportsBTC(w) && core.supportsETH(w)) {
+      wallet = w;
+    } else {
+      throw new Error("Wallet is not a WalletConnect");
+    }
+  });
+
+  it("supports Ethereum mainnet", async () => {
+    if (!wallet) return;
+    expect(await wallet.ethSupportsNetwork()).toEqual(true);
+  });
+
+  it("does not support BTC", async () => {
+    if (!wallet) return;
+    expect(core.supportsBTC(wallet)).toBe(false);
+  });
+
+  it("does not support Native ShapeShift", async () => {
+    if (!wallet) return;
+    expect(wallet.ethSupportsNativeShapeShift()).toEqual(false);
+  });
+
+  it("does not support EIP1559", async () => {
+    if (!wallet) return;
+    expect(await wallet.ethSupportsEIP1559()).toEqual(false);
+  });
+
+  it("does not support Secure Transfer", async () => {
+    if (!wallet) return;
+    expect(await wallet.ethSupportsSecureTransfer()).toEqual(false);
+  });
+
+  it("uses correct eth bip44 paths", () => {
+    if (!wallet) return;
+    [0, 1, 3, 27].forEach((account) => {
+      const paths = wallet.ethGetAccountPaths({
+        coin: "Ethereum",
+        accountIdx: account,
+      });
+      expect(paths).toEqual([
+        {
+          addressNList: core.bip32ToAddressNList(`m/44'/60'/${account}'/0/0`),
+          hardenedPath: core.bip32ToAddressNList(`m/44'/60'/${account}'`),
+          relPath: [0, 0],
+          description: "WalletConnect",
+        },
+      ]);
+      paths.forEach((path) => {
+        expect(
+          wallet.describePath({
+            coin: "Ethereum",
+            path: path.addressNList,
+          }).isKnown
+        ).toBeTruthy();
+      });
+    });
+  });
+
+  it("can describe ETH paths", () => {
+    if (!wallet) return;
+    expect(
+      wallet.describePath({
+        path: core.bip32ToAddressNList("m/44'/60'/0'/0/0"),
+        coin: "Ethereum",
+      })
+    ).toEqual({
+      verbose: "Ethereum Account #0",
+      coin: "Ethereum",
+      isKnown: true,
+      isPrefork: false,
+      accountIdx: 0,
+      wholeAccount: true,
+    });
+
+    expect(
+      wallet.describePath({
+        path: core.bip32ToAddressNList("m/44'/60'/3'/0/0"),
+        coin: "Ethereum",
+      })
+    ).toEqual({
+      verbose: "Ethereum Account #3",
+      coin: "Ethereum",
+      isKnown: true,
+      isPrefork: false,
+      accountIdx: 3,
+      wholeAccount: true,
+    });
+
+    expect(
+      wallet.describePath({
+        path: core.bip32ToAddressNList("m/44'/60'/0'/0/3"),
+        coin: "Ethereum",
+      })
+    ).toEqual({
+      verbose: "m/44'/60'/0'/0/3",
+      coin: "Ethereum",
+      isKnown: false,
+    });
+  });
+
+  it("should return a valid ETH address", async () => {
+    if (!wallet) return;
+    expect(
+      await wallet.ethGetAddress()
+    ).toEqual("0x3f2329C9ADFbcCd9A84f52c906E936A42dA18CB8");
+  });
+
+  it("should sign a message", async () => {
+    if (!wallet) return;
+    const res = await wallet.ethSignMessage({
+      addressNList: core.bip32ToAddressNList("m/44'/60'/0'/0/0"),
+      message: "Hello World",
+    });
+    expect(res?.address).toEqual("0x3f2329C9ADFbcCd9A84f52c906E936A42dA18CB8");
+    expect(res?.signature).toEqual(
+      "0x29f7212ecc1c76cea81174af267b67506f754ea8c73f144afa900a0d85b24b21319621aeb062903e856352f38305710190869c3ce5a1425d65ef4fa558d0fc251b"
+    );
+  });
+}

integration/tsconfig.json

@@ -3,7 +3,8 @@
   "compilerOptions": {
     "rootDir": "src",
     "outDir": "dist",
-    "resolveJsonModule": true
+    "resolveJsonModule": true,
+    "types": ["jest"]
   },
   "include": ["./src/**/*.[ts|json]"],
   "exclude": ["node_modules", "dist"]

packages/hdwallet-walletconnect/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@shapeshiftoss/hdwallet-walletconnect",
+  "version": "1.21.1",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "source": "src/index.ts",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc --build",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo",
+    "prepublishOnly": "yarn clean && yarn build"
+  },
+  "dependencies": {
+    "@shapeshiftoss/hdwallet-core": "1.21.1",
+    "@walletconnect/qrcode-modal": "^1.7.8",
+    "@walletconnect/web3-provider": "^1.7.8",
+    "ethers": "^5.6.5"
+  },
+  "devDependencies": {
+    "typescript": "^4.3.2"
+  }
+}

packages/hdwallet-walletconnect/src/adapter.ts

@@ -0,0 +1,33 @@
+import WalletConnectProvider from "@walletconnect/web3-provider";
+import * as core from "@shapeshiftoss/hdwallet-core";
+
+import { WalletConnectHDWallet } from "./walletconnect";
+
+export class WalletConnectAdapter {
+  keyring: core.Keyring;
+
+  private constructor(keyring: core.Keyring) {
+    this.keyring = keyring;
+  }
+
+  public static useKeyring(keyring: core.Keyring) {
+    return new WalletConnectAdapter(keyring);
+  }
+
+  public async initialize(): Promise<number> {
+    return Object.keys(this.keyring.wallets).length;
+  }
+
+  public async pairDevice(provider: WalletConnectProvider): Promise<WalletConnectHDWallet> {
+    try {
+      const wallet = new WalletConnectHDWallet(provider);
+      const deviceID = await wallet.getDeviceID();
+      this.keyring.add(wallet, deviceID);
+      this.keyring.emit(["WalletConnect", deviceID, core.Events.CONNECT], deviceID);
+      return wallet;
+    } catch (error) {
+      console.error("Could not pair WalletConnect");
+      throw error;
+    }
+  }
+}

packages/hdwallet-walletconnect/src/ethereum.ts

@@ -0,0 +1,31 @@
+import * as core from "@shapeshiftoss/hdwallet-core";
+
+export function describeETHPath(path: core.BIP32Path): core.PathDescription {
+  const pathStr = core.addressNListToBIP32(path);
+  const unknown: core.PathDescription = {
+    verbose: pathStr,
+    coin: "Ethereum",
+    isKnown: false,
+  };
+
+  if (path.length !== 5) return unknown;
+
+  if (path[0] !== 0x80000000 + 44) return unknown;
+
+  if (path[1] !== 0x80000000 + core.slip44ByCoin("Ethereum")) return unknown;
+
+  if ((path[2] & 0x80000000) >>> 0 !== 0x80000000) return unknown;
+
+  if (path[3] !== 0) return unknown;
+
+  if (path[4] !== 0) return unknown;
+
+  const index = path[2] & 0x7fffffff;
+  return {
+    verbose: `Ethereum Account #${index}`,
+    accountIdx: index,
+    wholeAccount: true,
+    coin: "Ethereum",
+    isKnown: true,
+  };
+}

packages/hdwallet-walletconnect/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./adapter";
+export * from "./walletconnect";