@shapeshiftoss/hdwallet-metamask-multichain 1.55.10-mipd.0

package/src/ethereum.ts

@@ -0,0 +1,125 @@
+import * as core from "@shapeshiftoss/hdwallet-core";
+import { ETHSignedMessage } from "@shapeshiftoss/hdwallet-core";
+import { isHexString } from "ethers/lib/utils";
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export async function ethVerifyMessage(msg: core.ETHVerifyMessage, ethereum: any): Promise<boolean | null> {
+  console.error("Method ethVerifyMessage unsupported for MetaMask wallet!");
+  return null;
+}
+
+export function ethGetAccountPaths(msg: core.ETHGetAccountPath): Array<core.ETHAccountPath> {
+  const slip44 = core.slip44ByCoin(msg.coin);
+  if (slip44 === undefined) return [];
+  return [
+    {
+      addressNList: [0x80000000 + 44, 0x80000000 + slip44, 0x80000000 + msg.accountIdx, 0, 0],
+      hardenedPath: [0x80000000 + 44, 0x80000000 + slip44, 0x80000000 + msg.accountIdx],
+      relPath: [0, 0],
+      description: "MetaMask(Shapeshift Multichain)",
+    },
+  ];
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export async function ethSignTx(msg: core.ETHSignTx, ethereum: any, from: string): Promise<core.ETHSignedTx | null> {
+  console.error("Method ethSignTx unsupported for MetaMask wallet!");
+  return null;
+}
+
+export async function ethSendTx(msg: core.ETHSignTx, ethereum: any, from: string): Promise<core.ETHTxHash | null> {
+  try {
+    const utxBase = {
+      from: from,
+      to: msg.to,
+      value: msg.value,
+      data: msg.data,
+      chainId: msg.chainId,
+      nonce: msg.nonce,
+      // MetaMask, like other Web3 libraries, derives its transaction schema from Ethereum's official JSON-RPC API specification
+      // (https://github.com/ethereum/execution-apis/blob/d63d2a02bcd2a8cef54ae2fc5bbff8b4fac944eb/src/schemas/transaction.json).
+      // That schema defines the use of the label `gas` to set the transaction's gas limit and not `gasLimit` as used in other
+      // libraries and as stated in the official yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf).
+      gas: msg.gasLimit,
+    };
+
+    const utx = msg.maxFeePerGas
+      ? {
+          ...utxBase,
+          maxFeePerGas: msg.maxFeePerGas,
+          maxPriorityFeePerGas: msg.maxPriorityFeePerGas,
+        }
+      : { ...utxBase, gasPrice: msg.gasPrice };
+
+    const signedTx = await ethereum.request({
+      method: "eth_sendTransaction",
+      params: [utx],
+    });
+
+    return {
+      hash: signedTx,
+    } as core.ETHTxHash;
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+}
+
+export async function ethSignMessage(
+  msg: core.ETHSignMessage,
+  ethereum: any,
+  address: string
+): Promise<core.ETHSignedMessage | null> {
+  try {
+    if (!isHexString(msg.message)) throw new Error("data is not an hex string");
+    const signedMsg = await ethereum.request({
+      method: "personal_sign",
+      params: [msg.message, address],
+    });
+
+    return {
+      address: address,
+      signature: signedMsg,
+    } as ETHSignedMessage;
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+}
+
+export async function ethSignTypedData(
+  msg: core.ETHSignTypedData,
+  ethereum: any,
+  address: string
+): Promise<core.ETHSignedMessage | null> {
+  try {
+    const signedMsg = await ethereum.request({
+      method: "eth_signTypedData_v4",
+      params: [address, JSON.stringify(msg.typedData)],
+      from: address,
+    });
+
+    return {
+      address: address,
+      signature: signedMsg,
+    } as ETHSignedMessage;
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+}
+
+export async function ethGetAddress(ethereum: any): Promise<string | null> {
+  if (!(ethereum && ethereum.request)) {
+    return null;
+  }
+  try {
+    const ethAccounts = await ethereum.request({
+      method: "eth_accounts",
+    });
+    return ethAccounts[0];
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+}

package/src/index.ts

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

package/src/litecoin.ts

@@ -0,0 +1,31 @@
+import * as core from "@shapeshiftoss/hdwallet-core";
+import {
+  LTCGetAddress as snapLitecoinGetAddress,
+  LTCGetPublicKeys as snapLitecoinGetPublicKeys,
+  LTCSignTransaction as snapLitecoinSignTransaction,
+} from "@shapeshiftoss/metamask-snaps-adapter";
+import { BitcoinGetPublicKeysResponse, LitecoinGetAddressResponse } from "@shapeshiftoss/metamask-snaps-types";
+
+import { SNAP_ID } from "./common";
+import { utxoGetAccountPaths } from "./utxo";
+
+export function litecoinGetAccountPaths(msg: core.BTCGetAccountPaths): Array<core.BTCAccountPath> {
+  return utxoGetAccountPaths(msg);
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function litecoinNextAccountPath(msg: core.BTCAccountPath): core.BTCAccountPath | undefined {
+  // Only support one account for now (like portis).
+  return undefined;
+}
+
+export async function litecoinGetAddress(msg: core.BTCGetAddress): Promise<LitecoinGetAddressResponse> {
+  return await snapLitecoinGetAddress({ snapId: SNAP_ID, addressParams: msg });
+}
+export async function litecoinGetPublicKeys(msg: core.BTCGetAddress): Promise<BitcoinGetPublicKeysResponse> {
+  return await snapLitecoinGetPublicKeys({ snapId: SNAP_ID, addressParams: msg });
+}
+
+export async function litecoinSignTx(msg: core.BTCSignTx): Promise<core.BTCSignedTx | null> {
+  return await snapLitecoinSignTransaction({ snapId: SNAP_ID, transaction: msg });
+}

package/src/shapeshift-multichain.test.ts

@@ -0,0 +1,170 @@
+import * as core from "@shapeshiftoss/hdwallet-core";
+
+import { MetaMaskShapeShiftMultiChainHDWallet, MetaMaskShapeShiftMultiChainHDWalletInfo } from ".";
+
+describe("HDWalletInfo", () => {
+  const info = new MetaMaskShapeShiftMultiChainHDWalletInfo();
+
+  it("should have correct metadata", async () => {
+    expect(info.getVendor()).toBe("MetaMask");
+    expect(info.hasOnDevicePinEntry()).toBe(false);
+    expect(info.hasOnDevicePassphrase()).toBe(true);
+    expect(info.hasOnDeviceDisplay()).toBe(true);
+    expect(info.hasOnDeviceRecovery()).toBe(true);
+    expect(await info.ethSupportsNetwork(1)).toBe(true);
+    expect(await info.ethSupportsSecureTransfer()).toBe(false);
+    expect(info.ethSupportsNativeShapeShift()).toBe(false);
+    expect(await info.ethSupportsEIP1559()).toBe(true);
+    expect(await info.supportsOfflineSigning()).toBe(false);
+    expect(await info.supportsBroadcast()).toBe(true);
+  });
+});
+
+describe("MetaMaskShapeShiftMultiChainHDWallet", () => {
+  let wallet: MetaMaskShapeShiftMultiChainHDWallet;
+  beforeEach(() => {
+    wallet = new MetaMaskShapeShiftMultiChainHDWallet(
+      core.untouchable("MetaMaskShapeShiftMultiChainHDWallet:provider")
+    );
+    wallet.ethAddress = "0x73d0385F4d8E00C5e6504C6030F47BF6212736A8";
+  });
+
+  it("should match the metadata", async () => {
+    expect(wallet.getVendor()).toBe("MetaMask");
+    expect(wallet.hasOnDevicePinEntry()).toBe(false);
+    expect(wallet.hasOnDevicePassphrase()).toBe(true);
+    expect(wallet.hasOnDeviceDisplay()).toBe(true);
+    expect(wallet.hasOnDeviceRecovery()).toBe(true);
+    expect(await wallet.ethSupportsNetwork(1)).toBe(true);
+    expect(await wallet.ethSupportsSecureTransfer()).toBe(false);
+    expect(wallet.ethSupportsNativeShapeShift()).toBe(false);
+    expect(await wallet.ethSupportsEIP1559()).toBe(true);
+    expect(await wallet.supportsOfflineSigning()).toBe(false);
+    expect(wallet.supportsBip44Accounts()).toBe(false);
+    expect(await wallet.supportsBroadcast()).toBe(true);
+  });
+
+  it("should test ethSignMessage", async () => {
+    wallet.provider = {
+      request: jest.fn().mockReturnValue(
+        `Object {
+          "address": "0x73d0385F4d8E00C5e6504C6030F47BF6212736A8",
+          "signature": "0x05f51140905ffa33ffdc57f46b0b8d8fbb1d2a99f8cd843ca27893c01c31351c08b76d83dce412731c846e3b50649724415deb522d00950fbf4f2c1459c2b70b1b",
+        }`
+      ),
+    };
+    const msg = "0x737570657220736563726574206d657373616765"; // super secret message
+    expect(
+      await wallet.ethSignMessage({
+        addressNList: core.bip32ToAddressNList("m/44'/60'/0'/0/0"),
+        message: msg,
+      })
+    ).toMatchInlineSnapshot(`
+    Object {
+      "address": "0x73d0385F4d8E00C5e6504C6030F47BF6212736A8",
+      "signature": "Object {
+              \\"address\\": \\"0x73d0385F4d8E00C5e6504C6030F47BF6212736A8\\",
+              \\"signature\\": \\"0x05f51140905ffa33ffdc57f46b0b8d8fbb1d2a99f8cd843ca27893c01c31351c08b76d83dce412731c846e3b50649724415deb522d00950fbf4f2c1459c2b70b1b\\",
+            }",
+    }
+  `);
+  });
+
+  it("ethSignMessage returns null on error", async () => {
+    wallet.provider = {
+      request: jest.fn().mockRejectedValue(new Error("An Error has occurred")),
+    };
+
+    const msg = "0x737570657220736563726574206d657373616765"; // super secret message
+    const sig = await wallet.ethSignMessage({
+      addressNList: core.bip32ToAddressNList("m/44'/60'/0'/0/0"),
+      message: msg,
+    });
+
+    expect(sig).toBe(null);
+  });
+
+  it("ethGetAddress returns a valid address", async () => {
+    wallet.provider = {
+      request: jest.fn().mockReturnValue(["0x73d0385F4d8E00C5e6504C6030F47BF6212736A8"]),
+    };
+
+    const msg = "0x737570657220736563726574206d657373616765"; // super secret message
+    const sig = await wallet.ethSignMessage({
+      addressNList: core.bip32ToAddressNList("m/44'/60'/0'/0/0"),
+      message: msg,
+    });
+
+    expect(sig).toMatchObject({
+      address: "0x73d0385F4d8E00C5e6504C6030F47BF6212736A8",
+      signature: ["0x73d0385F4d8E00C5e6504C6030F47BF6212736A8"],
+    });
+  });
+  it("ethSendTx returns a valid hash", async () => {
+    wallet.provider = {
+      request: jest.fn().mockReturnValue("0x123"),
+    };
+
+    const hash = await wallet.ethSendTx({
+      addressNList: core.bip32ToAddressNList("m/44'/60'/0'/0/0"),
+      nonce: "0xDEADBEEF",
+      gasPrice: "0xDEADBEEF",
+      gasLimit: "0xDEADBEEF",
+      to: "0xDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF",
+      value: "0xDEADBEEFDEADBEEFDEADBEEFDEADBEEF",
+      data: "0xDEADBEEFDEADBEEFDEADBEEFDEADBEEF",
+      chainId: 1,
+    });
+    expect(wallet.provider.request).toHaveBeenCalled();
+    expect(hash).toMatchObject({ hash: "0x123" });
+  });
+  it("ethSendTx returns a valid hash if maxFeePerGas is present in msg", async () => {
+    wallet.provider = {
+      request: jest.fn().mockReturnValue("0x123"),
+    };
+
+    const hash = await wallet.ethSendTx({
+      addressNList: core.bip32ToAddressNList("m/44'/60'/0'/0/0"),
+      nonce: "0xDEADBEEF",
+      gasLimit: "0xDEADBEEF",
+      maxFeePerGas: "0xDEADBEEF",
+      to: "0xDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF",
+      value: "0xDEADBEEFDEADBEEFDEADBEEFDEADBEEF",
+      data: "0xDEADBEEFDEADBEEFDEADBEEFDEADBEEF",
+      chainId: 1,
+    });
+    expect(wallet.provider.request).toHaveBeenCalled();
+    expect(hash).toMatchObject({ hash: "0x123" });
+  });
+  it("ethSendTx returns null on error", async () => {
+    wallet.provider = {
+      request: jest.fn().mockRejectedValue(new Error("An Error has occurred")),
+    };
+
+    const hash = await wallet.ethSendTx({
+      addressNList: core.bip32ToAddressNList("m/44'/60'/0'/0/0"),
+      nonce: "0xDEADBEEF",
+      gasPrice: "0xDEADBEEF",
+      gasLimit: "0xDEADBEEF",
+      to: "0xDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF",
+      value: "0xDEADBEEFDEADBEEFDEADBEEFDEADBEEF",
+      data: "0xDEADBEEFDEADBEEFDEADBEEFDEADBEEF",
+      chainId: 1,
+    });
+    expect(wallet.provider.request).toHaveBeenCalled();
+    expect(hash).toBe(null);
+  });
+  it("ethVerifyMessage returns null as its not implemented", async () => {
+    wallet.provider = {
+      request: jest.fn().mockReturnValue("0x3f2329C9ADFbcCd9A84f52c906E936A42dA18CB8"),
+    };
+    expect(
+      await wallet.ethVerifyMessage({
+        address: "0x3f2329C9ADFbcCd9A84f52c906E936A42dA18CB8",
+        message: "hello world",
+        signature:
+          "0x29f7212ecc1c76cea81174af267b67506f754ea8c73f144afa900a0d85b24b21319621aeb062903e856352f38305710190869c3ce5a1425d65ef4fa558d0fc251b",
+      })
+    ).toEqual(null);
+  });
+});