@shapeshiftoss/hdwallet-phantom 1.55.6

package/src/bitcoin.ts

@@ -0,0 +1,169 @@
+import * as bitcoin from "@shapeshiftoss/bitcoinjs-lib";
+import * as core from "@shapeshiftoss/hdwallet-core";
+import { BTCInputScriptType } from "@shapeshiftoss/hdwallet-core";
+
+import { PhantomUtxoProvider } from "./types";
+
+export type BtcAccount = {
+  address: string;
+  // Phantom supposedly supports more scriptTypes but in effect, doesn't (currently)
+  // https://github.com/orgs/phantom/discussions/173
+  addressType: BTCInputScriptType.SpendWitness;
+  publicKey: string;
+  purpose: "payment" | "ordinals";
+};
+
+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 getNetwork = (coin: string): bitcoin.networks.Network => {
+  switch (coin.toLowerCase()) {
+    case "bitcoin":
+      return bitcoin.networks.bitcoin;
+    default:
+      throw new Error(`Unsupported coin: ${coin}`);
+  }
+};
+
+export const btcGetAccountPaths = (msg: core.BTCGetAccountPaths): Array<core.BTCAccountPath> => {
+  const slip44 = core.slip44ByCoin(msg.coin);
+  if (slip44 === undefined) return [];
+
+  const bip84 = core.segwitNativeAccount(msg.coin, slip44, msg.accountIdx);
+
+  const coinPaths = {
+    bitcoin: [bip84],
+  } as Partial<Record<string, Array<core.BTCAccountPath>>>;
+
+  let paths: Array<core.BTCAccountPath> = coinPaths[msg.coin.toLowerCase()] || [];
+
+  if (msg.scriptType !== undefined) {
+    paths = paths.filter((path) => {
+      return path.scriptType === msg.scriptType;
+    });
+  }
+
+  return paths;
+};
+
+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(psbt: bitcoin.Psbt, input: core.BTCSignTxInput): Promise<void> {
+  switch (input.scriptType) {
+    // Phantom supposedly supports more scriptTypes but in effect, doesn't (currently)
+    // https://github.com/orgs/phantom/discussions/173
+    case BTCInputScriptType.SpendWitness: {
+      psbt.addInput({
+        hash: input.txid,
+        index: input.vout,
+        nonWitnessUtxo: Buffer.from(input.hex, "hex"),
+      });
+
+      break;
+    }
+    default:
+      throw new Error(`Unsupported script type: ${input.scriptType}`);
+  }
+}
+
+async function addOutput(
+  wallet: core.BTCWallet,
+  psbt: bitcoin.Psbt,
+  output: core.BTCSignTxOutput,
+  coin: string
+): Promise<void> {
+  if (!output.amount) throw new Error("Invalid output - missing amount.");
+
+  const address = await (async () => {
+    if (output.address) return output.address;
+
+    if (output.addressNList) {
+      const outputAddress = await wallet.btcGetAddress({ addressNList: output.addressNList, coin, showDisplay: false });
+      if (!outputAddress) throw new Error("Could not get address from wallet");
+      return outputAddress;
+    }
+  })();
+
+  if (!address) throw new Error("Invalid output - no address");
+
+  psbt.addOutput({ address, value: parseInt(output.amount) });
+}
+
+export async function bitcoinSignTx(
+  wallet: core.BTCWallet,
+  msg: core.BTCSignTx,
+  provider: PhantomUtxoProvider
+): Promise<core.BTCSignedTx | null> {
+  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(psbt, input);
+  }
+
+  for (const output of msg.outputs) {
+    await addOutput(wallet, psbt, output, msg.coin);
+  }
+
+  if (msg.opReturnData) {
+    const data = Buffer.from(msg.opReturnData, "utf-8");
+    const embed = bitcoin.payments.embed({ data: [data] });
+    const script = embed.output;
+    if (!script) throw new Error("unable to build OP_RETURN script");
+    psbt.addOutput({ script, value: 0 });
+  }
+
+  const inputsToSign = await Promise.all(
+    msg.inputs.map(async (input, index) => {
+      const address = await wallet.btcGetAddress({
+        addressNList: input.addressNList,
+        coin: msg.coin,
+        showDisplay: false,
+      });
+
+      if (!address) throw new Error("Could not get address from wallet");
+
+      return {
+        address,
+        signingIndexes: [index],
+        sigHash: bitcoin.Transaction.SIGHASH_ALL,
+      };
+    })
+  );
+
+  const signedPsbtHex = await provider.signPSBT(fromHexString(psbt.toHex()), { inputsToSign });
+  const signedPsbt = bitcoin.Psbt.fromBuffer(Buffer.from(signedPsbtHex), { network });
+
+  signedPsbt.finalizeAllInputs();
+
+  const tx = signedPsbt.extractTransaction();
+
+  // If this is a THORChain transaction, validate the vout ordering
+  if (msg.vaultAddress && !core.validateVoutOrdering(msg, tx)) {
+    throw new Error("Improper vout ordering for BTC Thorchain transaction");
+  }
+
+  const signatures = signedPsbt.data.inputs.map((input) =>
+    input.partialSig ? input.partialSig[0].signature.toString("hex") : ""
+  );
+
+  return {
+    signatures,
+    serializedTx: tx.toHex(),
+  };
+}

package/src/ethereum.ts

@@ -0,0 +1,111 @@
+import * as core from "@shapeshiftoss/hdwallet-core";
+import { ETHSignedMessage } from "@shapeshiftoss/hdwallet-core";
+import { isHexString } from "ethers/lib/utils";
+
+import { PhantomEvmProvider } from "./types";
+
+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: "Phantom",
+    },
+  ];
+}
+
+export async function ethSendTx(
+  msg: core.ETHSignTx,
+  phantom: PhantomEvmProvider,
+  from: string
+): Promise<core.ETHTxHash | null> {
+  try {
+    const utxBase = {
+      from: from,
+      to: msg.to,
+      value: msg.value,
+      chainId: msg.chainId,
+      data: msg.data,
+      gasLimit: msg.gasLimit,
+    };
+
+    const utx = msg.maxFeePerGas
+      ? {
+          ...utxBase,
+          maxFeePerGas: msg.maxFeePerGas,
+          maxPriorityFeePerGas: msg.maxPriorityFeePerGas,
+        }
+      : { ...utxBase, gasPrice: msg.gasPrice };
+
+    const signedTx = await phantom.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,
+  phantom: PhantomEvmProvider,
+  address: string
+): Promise<core.ETHSignedMessage | null> {
+  try {
+    if (!isHexString(msg.message)) throw new Error("data is not an hex string");
+    const signedMsg = await phantom.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,
+  phantom: PhantomEvmProvider,
+  address: string
+): Promise<core.ETHSignedMessage | null> {
+  try {
+    const signedMsg = await phantom.request?.({
+      method: "eth_signTypedData_v4",
+      params: [address, JSON.stringify(msg.typedData)],
+    });
+
+    return {
+      address: address,
+      signature: signedMsg,
+    } as ETHSignedMessage;
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+}
+
+export async function ethGetAddress(phantom: PhantomEvmProvider): Promise<string | null> {
+  if (!(phantom && phantom.request)) {
+    return null;
+  }
+  try {
+    const ethAccounts = await phantom.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 "./phantom";

package/src/phantom.test.ts

@@ -0,0 +1,179 @@
+import * as core from "@shapeshiftoss/hdwallet-core";
+
+import { PhantomHDWallet } from ".";
+import { PhantomUtxoProvider } from "./types";
+
+describe("PhantomHDWallet", () => {
+  let wallet: PhantomHDWallet;
+
+  beforeEach(() => {
+    wallet = new PhantomHDWallet(
+      core.untouchable("PhantomHDWallet:provider"),
+      core.untouchable("PhantomHDWallet:provider")
+    );
+  });
+
+  it("should match the metadata", async () => {
+    expect(wallet.getVendor()).toBe("Phantom");
+    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(wallet.supportsOfflineSigning()).toBe(false);
+    expect(wallet.supportsBip44Accounts()).toBe(false);
+    expect(wallet.supportsBroadcast()).toBe(true);
+  });
+
+  it("should test ethSignMessage", async () => {
+    wallet.evmProvider = {
+      _metamask: {
+        isUnlocked: () => true,
+      },
+      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": "O",
+        "signature": "Object {
+                \\"address\\": \\"0x73d0385F4d8E00C5e6504C6030F47BF6212736A8\\",
+                \\"signature\\": \\"0x05f51140905ffa33ffdc57f46b0b8d8fbb1d2a99f8cd843ca27893c01c31351c08b76d83dce412731c846e3b50649724415deb522d00950fbf4f2c1459c2b70b1b\\",
+              }",
+      }
+    `);
+  });
+
+  it("ethSignMessage returns null on error", async () => {
+    wallet.evmProvider = {
+      _metamask: {
+        isUnlocked: () => true,
+      },
+      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.evmProvider = {
+      _metamask: {
+        isUnlocked: () => true,
+      },
+      request: jest.fn().mockReturnValue(["0x73d0385F4d8E00C5e6504C6030F47BF6212736A8"]),
+    };
+
+    const address = await wallet.ethGetAddress();
+
+    expect(address).toEqual("0x73d0385F4d8E00C5e6504C6030F47BF6212736A8");
+  });
+  it("btcGetAddress returns a valid address", async () => {
+    wallet.bitcoinProvider = {
+      requestAccounts: jest.fn().mockReturnValue([
+        {
+          purpose: "payment",
+          address: "bc1q9sjm947kn2hz84syykmem7dshvevm8xm5dkrpg",
+        },
+      ]),
+    } as unknown as PhantomUtxoProvider;
+
+    const address = await wallet.btcGetAddress({
+      coin: "Bitcoin",
+    } as core.BTCGetAddress);
+
+    expect(address).toEqual("bc1q9sjm947kn2hz84syykmem7dshvevm8xm5dkrpg");
+  });
+
+  it("ethSendTx returns a valid hash", async () => {
+    wallet.evmProvider = {
+      _metamask: {
+        isUnlocked: () => true,
+      },
+      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.evmProvider.request).toHaveBeenCalled();
+    expect(hash).toMatchObject({ hash: "0x123" });
+  });
+  it("ethSendTx returns a valid hash if maxFeePerGas is present in msg", async () => {
+    wallet.evmProvider = {
+      _metamask: {
+        isUnlocked: () => true,
+      },
+      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.evmProvider.request).toHaveBeenCalled();
+    expect(hash).toMatchObject({ hash: "0x123" });
+  });
+  it("ethSendTx returns null on error", async () => {
+    wallet.evmProvider = {
+      _metamask: {
+        isUnlocked: () => true,
+      },
+      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.evmProvider.request).toHaveBeenCalled();
+    expect(hash).toBe(null);
+  });
+  it("ethVerifyMessage returns true for a valid signature", async () => {
+    expect(
+      await wallet.ethVerifyMessage({
+        address: "0x2068dD92B6690255553141Dfcf00dF308281f763",
+        message: "Hello World",
+        signature:
+          "0x61f1dda82e9c3800e960894396c9ce8164fd1526fccb136c71b88442405f7d09721725629915d10bc7cecfca2818fe76bc5816ed96a1b0cebee9b03b052980131b",
+      })
+    ).toEqual(true);
+  });
+});