feat: implement Ethereum, Polygon and Bitcoin with phantom

examples/sandbox/index.html

@@ -116,6 +116,7 @@ <h4>Select</h4>
       <button id="portis">Pair Portis</button>
       <button id="native">Pair Native</button>
       <button id="metaMask">Pair MetaMask</button>
+      <button id="phantom">Pair Phantom</button>
       <button id="xdefi">Pair XDEFI</button>
       <button id="keplr">Pair Keplr</button>
       <button id="tallyHo">Pair Tally Ho</button>

examples/sandbox/index.ts

@@ -11,6 +11,7 @@ import * as keplr from "@shapeshiftoss/hdwallet-keplr";
 import * as ledgerWebHID from "@shapeshiftoss/hdwallet-ledger-webhid";
 import * as ledgerWebUSB from "@shapeshiftoss/hdwallet-ledger-webusb";
 import * as metaMask from "@shapeshiftoss/hdwallet-metamask";
+import * as phantom from "@shapeshiftoss/hdwallet-phantom";
 import * as native from "@shapeshiftoss/hdwallet-native";
 import * as portis from "@shapeshiftoss/hdwallet-portis";
 import * as tallyHo from "@shapeshiftoss/hdwallet-tallyho";
@@ -127,6 +128,7 @@ const kkbridgeAdapter = keepkeyTcp.TCPKeepKeyAdapter.useKeyring(keyring);
 const kkemuAdapter = keepkeyTcp.TCPKeepKeyAdapter.useKeyring(keyring);
 const portisAdapter = portis.PortisAdapter.useKeyring(keyring, { portisAppId });
 const metaMaskAdapter = metaMask.MetaMaskAdapter.useKeyring(keyring);
+const phantomAdapter = phantom.PhantomAdapter.useKeyring(keyring);
 const tallyHoAdapter = tallyHo.TallyHoAdapter.useKeyring(keyring);
 const walletConnectAdapter = walletConnect.WalletConnectAdapter.useKeyring(keyring, walletConnectOptions);
 const walletConnectV2Adapter = walletConnectv2.WalletConnectV2Adapter.useKeyring(keyring, walletConnectV2Options);
@@ -159,6 +161,7 @@ const $ledgerwebhid = $("#ledgerwebhid");
 const $portis = $("#portis");
 const $native = $("#native");
 const $metaMask = $("#metaMask");
+const $phantom = $("#phantom");
 const $coinbase = $("#coinbase");
 const $tallyHo = $("#tallyHo");
 const $walletConnect = $("#walletConnect");
@@ -243,6 +246,19 @@ $metaMask.on("click", async (e) => {
   }
 });
 
+$phantom.on("click", async (e) => {
+  e.preventDefault();
+  wallet = await phantomAdapter.pairDevice();
+  window["wallet"] = wallet;
+  let deviceID = "nothing";
+  try {
+    deviceID = await wallet.getDeviceID();
+    $("#keyring select").val(deviceID);
+  } catch (err) {
+    console.error(err);
+  }
+});
+
 $coinbase.on("click", async (e) => {
   e.preventDefault();
   wallet = await coinbaseAdapter.pairDevice();
@@ -405,6 +421,12 @@ async function deviceConnected(deviceId) {
     console.error("Could not initialize MetaMaskAdapter", e);
   }
 
+  try {
+    await phantomAdapter.initialize();
+  } catch (e) {
+    console.error("Could not initialize PhantomAdapter", e);
+  }
+
   try {
     await tallyHoAdapter.initialize();
   } catch (e) {

examples/sandbox/package.json

@@ -19,6 +19,7 @@
     "@shapeshiftoss/hdwallet-ledger-webhid": "1.55.0",
     "@shapeshiftoss/hdwallet-ledger-webusb": "1.55.0",
     "@shapeshiftoss/hdwallet-metamask": "1.55.0",
+    "@shapeshiftoss/hdwallet-phantom": "1.55.0",
     "@shapeshiftoss/hdwallet-native": "1.55.0",
     "@shapeshiftoss/hdwallet-portis": "1.55.0",
     "@shapeshiftoss/hdwallet-tallyho": "1.55.0",

packages/hdwallet-phantom/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@shapeshiftoss/hdwallet-phantom",
+  "version": "1.55.0",
+  "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 node_modules tsconfig.tsbuildinfo",
+    "prepublishOnly": "yarn clean && yarn build"
+  },
+  "dependencies": {
+    "@shapeshiftoss/hdwallet-core": "1.54.2",
+    "eth-rpc-errors": "^4.0.3",
+    "lodash": "^4.17.21"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.14.168"
+  }
+}

packages/hdwallet-phantom/src/adapter.ts

@@ -0,0 +1,59 @@
+import * as core from "@shapeshiftoss/hdwallet-core";
+import { providers } from "ethers";
+
+import { PhantomHDWallet } from "./phantom";
+
+declare global {
+  interface Window {
+    phantom?: {
+      ethereum?: providers.ExternalProvider;
+      bitcoin?: providers.ExternalProvider;
+    };
+  }
+}
+
+export class PhantomAdapter {
+  keyring: core.Keyring;
+
+  private constructor(keyring: core.Keyring) {
+    this.keyring = keyring;
+  }
+
+  public static useKeyring(keyring: core.Keyring) {
+    return new PhantomAdapter(keyring);
+  }
+
+  public async initialize(): Promise<number> {
+    return Object.keys(this.keyring.wallets).length;
+  }
+
+  public async pairDevice(): Promise<PhantomHDWallet | undefined> {
+    const evmProvider = window.phantom?.ethereum;
+    const bitcoinProvider = window.phantom?.bitcoin;
+
+    if (!evmProvider || !bitcoinProvider) {
+      window.open("https://phantom.app/", "_blank");
+      console.error("Please install Phantom!");
+      throw new Error("Phantom provider not found");
+    }
+
+    try {
+      await evmProvider.request?.({ method: "eth_requestAccounts" }).catch(() =>
+        evmProvider.request?.({
+          method: "wallet_requestPermissions",
+          params: [{ eth_accounts: {} }],
+        })
+      );
+    } catch (error) {
+      console.error("Could not get Phantom accounts. ");
+      throw error;
+    }
+    const wallet = new PhantomHDWallet(evmProvider, bitcoinProvider);
+    await wallet.initialize();
+    const deviceID = await wallet.getDeviceID();
+    this.keyring.add(wallet, deviceID);
+    this.keyring.emit(["Phantom", deviceID, core.Events.CONNECT], deviceID);
+
+    return wallet;
+  }
+}

packages/hdwallet-phantom/src/bitcoin.ts

@@ -0,0 +1,180 @@
+import * as bitcoin from "@shapeshiftoss/bitcoinjs-lib";
+import * as core from "@shapeshiftoss/hdwallet-core";
+
+type BtcAccount = {
+  address: string;
+  addressType: "p2tr" | "p2wpkh" | "p2sh" | "p2pkh";
+  publicKey: string;
+  purpose: "payment" | "ordinals";
+};
+
+function getNetwork(coin: string): bitcoin.networks.Network {
+  switch (coin.toLowerCase()) {
+    case "bitcoin":
+      return bitcoin.networks.bitcoin;
+    case "testnet":
+      return bitcoin.networks.testnet;
+    default:
+      throw new Error(`Unsupported coin: ${coin}`);
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function bitcoinNextAccountPath(msg: core.BTCAccountPath): core.BTCAccountPath | undefined {
+  // Only support one account for now (like portis).
+  return undefined;
+}
+
+export async function bitcoinGetPublicKeys(msg: core.BTCGetAddress, provider: any): Promise<string[]> {
+  const accounts = await provider.requestAccounts();
+  const paymentPublicKey = accounts.find((account: BtcAccount) => account.purpose === "payment")?.publicKey;
+
+  return [paymentPublicKey];
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export async function bitcoinGetAddress(msg: core.BTCGetAddress, provider: any): Promise<string> {
+  const accounts = await provider.requestAccounts();
+  const paymentAddress = accounts.find((account: BtcAccount) => account.purpose === "payment")?.address;
+
+  return paymentAddress;
+}
+
+async function addInput(
+  wallet: core.BTCWallet,
+  psbt: bitcoin.Psbt,
+  input: core.BTCSignTxInput,
+  coin: string,
+  network: bitcoin.networks.Network
+): Promise<void> {
+  const inputData: bitcoin.PsbtTxInput & {
+    nonWitnessUtxo?: Buffer;
+    witnessUtxo?: { script: Buffer; value: number };
+  } = {
+    hash: Buffer.from(input.txid, "hex"),
+    index: input.vout,
+  };
+
+  if (input.sequence !== undefined) {
+    inputData.sequence = input.sequence;
+  }
+
+  if (input.scriptType) {
+    switch (input.scriptType) {
+      case "p2pkh":
+        inputData.nonWitnessUtxo = Buffer.from(input.hex, "hex");
+        break;
+      case "p2sh-p2wpkh":
+      case "p2wpkh": {
+        const inputAddress = await wallet.btcGetAddress({ addressNList: input.addressNList, coin, showDisplay: false });
+
+        if (!inputAddress) throw new Error("Could not get address from wallet");
+
+        inputData.witnessUtxo = {
+          script: bitcoin.address.toOutputScript(inputAddress, network),
+          value: parseInt(input.amount),
+        };
+        break;
+      }
+      default:
+        throw new Error(`Unsupported script type: ${input.scriptType}`);
+    }
+  }
+
+  psbt.addInput(inputData);
+}
+
+async function addOutput(
+  wallet: core.BTCWallet,
+  psbt: bitcoin.Psbt,
+  output: core.BTCSignTxOutput,
+  coin: string
+): Promise<void> {
+  if ("address" in output && output.address) {
+    psbt.addOutput({
+      address: output.address,
+      value: parseInt(output.amount),
+    });
+  } else if ("addressNList" in output && output.addressNList) {
+    const outputAddress = await wallet.btcGetAddress({ addressNList: output.addressNList, coin, showDisplay: false });
+
+    if (!outputAddress) throw new Error("Could not get address from wallet");
+
+    psbt.addOutput({
+      address: outputAddress,
+      value: parseInt(output.amount),
+    });
+  } else if ("opReturnData" in output && output.opReturnData) {
+    const data = Buffer.from(output.opReturnData.toString(), "hex");
+    const embed = bitcoin.payments.embed({ data: [data] });
+    psbt.addOutput({
+      script: embed.output!,
+      value: 0,
+    });
+  }
+}
+
+export async function bitcoinSignTx(
+  wallet: core.BTCWallet,
+  msg: core.BTCSignTx,
+  provider: any
+): Promise<core.BTCSignedTx | null> {
+  if (!msg.inputs.length || !msg.outputs.length) {
+    throw new Error("Invalid input: Empty inputs or outputs");
+  }
+
+  const network = getNetwork(msg.coin);
+
+  const psbt = new bitcoin.Psbt({ network });
+
+  psbt.setVersion(msg.version ?? 2);
+  if (msg.locktime) {
+    psbt.setLocktime(msg.locktime);
+  }
+
+  for (const input of msg.inputs) {
+    await addInput(wallet, psbt, input, msg.coin, network);
+  }
+
+  for (const output of msg.outputs) {
+    await addOutput(wallet, psbt, output, msg.coin);
+  }
+
+  const inputsToSign = await Promise.all(
+    msg.inputs.map(async (input, index) => {
+      const address = await wallet.btcGetAddress({
+        addressNList: input.addressNList,
+        coin: msg.coin,
+        showDisplay: false,
+      });
+
+      return {
+        address,
+        signingIndexes: [index],
+        sigHash: bitcoin.Transaction.SIGHASH_ALL,
+      };
+    })
+  );
+
+  const fromHexString = (hexString: string) => {
+    const bytes = hexString.match(/.{1,2}/g);
+    if (!bytes) throw new Error("Invalid hex string");
+
+    return Uint8Array.from(bytes.map((byte) => parseInt(byte, 16)));
+  };
+  const signedPsbtHex = await provider.signPSBT(fromHexString(psbt.toHex()), { inputsToSign });
+
+  const signedPsbt = bitcoin.Psbt.fromHex(signedPsbtHex, { network });
+
+  signedPsbt.finalizeAllInputs();
+  const tx = signedPsbt.extractTransaction();
+
+  const signatures = signedPsbt.data.inputs.map((input) =>
+    input.partialSig ? input.partialSig[0].signature.toString("hex") : ""
+  );
+
+  return {
+    signatures,
+    serializedTx: tx.toHex(),
+  };
+}