@shapeshiftoss/hdwallet-phantom 1.55.10-mipdalpha.1 → 1.55.10

package/src/phantom.test.ts

@@ -1,13 +1,14 @@
 import * as core from "@shapeshiftoss/hdwallet-core";
 
 import { PhantomHDWallet } from ".";
-import { PhantomUtxoProvider } from "./types";
+import { PhantomSolanaProvider, PhantomUtxoProvider } from "./types";
 
 describe("PhantomHDWallet", () => {
   let wallet: PhantomHDWallet;
 
   beforeEach(() => {
     wallet = new PhantomHDWallet(
+      core.untouchable("PhantomHDWallet:provider"),
       core.untouchable("PhantomHDWallet:provider"),
       core.untouchable("PhantomHDWallet:provider")
     );
@@ -28,25 +29,105 @@ describe("PhantomHDWallet", () => {
     expect(wallet.supportsBroadcast()).toBe(true);
   });
 
-  it("should test ethSignMessage", async () => {
-    wallet.evmProvider = {
-      _metamask: {
-        isUnlocked: () => true,
-      },
-      request: jest.fn().mockReturnValue(
-        `Object {
+  describe("Ethereum", () => {
+    it("ethGetAddress returns a valid address", async () => {
+      wallet.evmProvider = {
+        _metamask: {
+          isUnlocked: () => true,
+        },
+        request: jest.fn().mockReturnValue(["0x73d0385F4d8E00C5e6504C6030F47BF6212736A8"]),
+      };
+
+      const address = await wallet.ethGetAddress({ addressNList: core.bip32ToAddressNList("m/44'/60'/0'/0/0") });
+
+      expect(address).toEqual("0x73d0385F4d8E00C5e6504C6030F47BF6212736A8");
+    });
+
+    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("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(`
+        ),
+      };
+      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 {
@@ -55,125 +136,67 @@ describe("PhantomHDWallet", () => {
               }",
       }
     `);
-  });
-
-  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",
+    it("ethSignMessage returns null on error", async () => {
+      wallet.evmProvider = {
+        _metamask: {
+          isUnlocked: () => true,
         },
-      ]),
-    } as unknown as PhantomUtxoProvider;
+        request: jest.fn().mockRejectedValue(new Error("An Error has occurred")),
+      };
 
-    const address = await wallet.btcGetAddress({
-      coin: "Bitcoin",
-    } as core.BTCGetAddress);
+      const msg = "0x737570657220736563726574206d657373616765"; // super secret message
+      const sig = await wallet.ethSignMessage({
+        addressNList: core.bip32ToAddressNList("m/44'/60'/0'/0/0"),
+        message: msg,
+      });
 
-    expect(address).toEqual("bc1q9sjm947kn2hz84syykmem7dshvevm8xm5dkrpg");
-  });
+      expect(sig).toBe(null);
+    });
 
-  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,
+    it("ethVerifyMessage returns true for a valid signature", async () => {
+      expect(
+        await wallet.ethVerifyMessage({
+          address: "0x2068dD92B6690255553141Dfcf00dF308281f763",
+          message: "Hello World",
+          signature:
+            "0x61f1dda82e9c3800e960894396c9ce8164fd1526fccb136c71b88442405f7d09721725629915d10bc7cecfca2818fe76bc5816ed96a1b0cebee9b03b052980131b",
+        })
+      ).toEqual(true);
     });
-    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,
+
+  describe("Bitcoin", () => {
+    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");
     });
-    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,
+
+  describe("Solana", () => {
+    it("solanaGetAddress returns a valid address", async () => {
+      wallet.solanaProvider = {
+        connect: jest.fn().mockReturnValue({
+          publicKey: "DsYwEVzeSNMkU5PVwjwtZ8EDRQxaR6paXfFAdhMQxmaV",
+        }),
+      } as unknown as PhantomSolanaProvider;
+
+      const address = await wallet.solanaGetAddress();
+
+      expect(address).toEqual("DsYwEVzeSNMkU5PVwjwtZ8EDRQxaR6paXfFAdhMQxmaV");
     });
-    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);
   });
 });

package/src/phantom.ts

@@ -7,15 +7,19 @@ import _ from "lodash";
 
 import * as btc from "./bitcoin";
 import * as eth from "./ethereum";
-import { PhantomEvmProvider, PhantomUtxoProvider } from "./types";
+import { solanaSendTx, solanaSignTx } from "./solana";
+import { PhantomEvmProvider, PhantomSolanaProvider, PhantomUtxoProvider } from "./types";
 
 export function isPhantom(wallet: core.HDWallet): wallet is PhantomHDWallet {
   return _.isObject(wallet) && (wallet as any)._isPhantom;
 }
 
-export class PhantomHDWalletInfo implements core.HDWalletInfo, core.BTCWalletInfo, core.ETHWalletInfo {
+export class PhantomHDWalletInfo
+  implements core.HDWalletInfo, core.BTCWalletInfo, core.ETHWalletInfo, core.SolanaWalletInfo
+{
   readonly _supportsBTCInfo = true;
   readonly _supportsETHInfo = true;
+  readonly _supportsSolanaInfo = true;
 
   evmProvider: PhantomEvmProvider;
 
@@ -73,6 +77,8 @@ export class PhantomHDWalletInfo implements core.HDWalletInfo, core.BTCWalletInf
       }
       case "ethereum":
         return core.describeETHPath(msg.path);
+      case "solana":
+        return core.solanaDescribePath(msg.path);
       default:
         throw new Error("Unsupported path");
     }
@@ -114,13 +120,14 @@ export class PhantomHDWalletInfo implements core.HDWalletInfo, core.BTCWalletInf
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   public ethNextAccountPath(msg: core.ETHAccountPath): core.ETHAccountPath | undefined {
-    throw new Error("Method not implemented");
+    console.error("Method not implemented");
+    return undefined;
   }
 
   /** Bitcoin */
 
   public async btcSupportsCoin(coin: core.Coin): Promise<boolean> {
-    return coin === "bitcoin";
+    return coin.toLowerCase() === "bitcoin";
   }
 
   public async btcSupportsScriptType(coin: string, scriptType?: core.BTCInputScriptType | undefined): Promise<boolean> {
@@ -147,13 +154,32 @@ export class PhantomHDWalletInfo implements core.HDWalletInfo, core.BTCWalletInf
     return btc.btcGetAccountPaths(msg);
   }
 
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public btcIsSameAccount(msg: core.BTCAccountPath[]): boolean {
+    throw new Error("Method not implemented.");
+  }
+
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   public btcNextAccountPath(msg: core.BTCAccountPath): core.BTCAccountPath | undefined {
     throw new Error("Method not implemented");
   }
+
+  /** Solana */
+
+  public solanaGetAccountPaths(msg: core.SolanaGetAccountPaths): Array<core.SolanaAccountPath> {
+    return core.solanaGetAccountPaths(msg);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public solanaNextAccountPath(msg: core.SolanaAccountPath): core.SolanaAccountPath | undefined {
+    throw new Error("Method not implemented");
+  }
 }
 
-export class PhantomHDWallet extends PhantomHDWalletInfo implements core.HDWallet, core.BTCWallet, core.ETHWallet {
+export class PhantomHDWallet
+  extends PhantomHDWalletInfo
+  implements core.HDWallet, core.BTCWallet, core.ETHWallet, core.SolanaWallet
+{
   readonly _supportsBTC = true;
   readonly _supportsETH = true;
   readonly _supportsEthSwitchChain = false;
@@ -167,20 +193,29 @@ export class PhantomHDWallet extends PhantomHDWalletInfo implements core.HDWalle
   readonly _supportsArbitrumNova = false;
   readonly _supportsBase = false;
   readonly _supportsBSC = false;
+  readonly _supportsSolana = true;
   readonly _isPhantom = true;
 
   evmProvider: PhantomEvmProvider;
   bitcoinProvider: PhantomUtxoProvider;
+  solanaProvider: PhantomSolanaProvider;
+
   ethAddress?: string | null;
 
-  constructor(evmProvider: PhantomEvmProvider, bitcoinProvider: PhantomUtxoProvider) {
+  constructor(
+    evmProvider: PhantomEvmProvider,
+    bitcoinProvider: PhantomUtxoProvider,
+    solanaProvider: PhantomSolanaProvider
+  ) {
     super(evmProvider);
+
     this.evmProvider = evmProvider;
     this.bitcoinProvider = bitcoinProvider;
+    this.solanaProvider = solanaProvider;
   }
 
   public async getDeviceID(): Promise<string> {
-    return "phantom:" + (await this.ethGetAddress());
+    return "phantom:" + (await this.ethGetAddress({ addressNList: [] }));
   }
 
   async getFeatures(): Promise<Record<string, any>> {
@@ -262,11 +297,14 @@ export class PhantomHDWallet extends PhantomHDWalletInfo implements core.HDWalle
 
   /** Ethereum */
 
-  public async ethGetAddress(): Promise<string | null> {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public async ethGetAddress(_msg: core.ETHGetAddress): Promise<string | null> {
     if (this.ethAddress) {
       return this.ethAddress;
     }
+
     const address = await eth.ethGetAddress(this.evmProvider);
+
     if (address) {
       this.ethAddress = address;
       return address;
@@ -278,21 +316,22 @@ export class PhantomHDWallet extends PhantomHDWalletInfo implements core.HDWalle
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   public async ethSignTx(msg: core.ETHSignTx): Promise<core.ETHSignedTx | null> {
-    throw new Error("Method not implemented");
+    console.error("Method not implemented");
+    return null;
   }
 
   public async ethSendTx(msg: core.ETHSignTx): Promise<core.ETHTxHash | null> {
-    const address = await this.ethGetAddress();
+    const address = await this.ethGetAddress({ addressNList: [] });
     return address ? eth.ethSendTx(msg, this.evmProvider, address) : null;
   }
 
   public async ethSignMessage(msg: core.ETHSignMessage): Promise<core.ETHSignedMessage | null> {
-    const address = await this.ethGetAddress();
+    const address = await this.ethGetAddress({ addressNList: [] });
     return address ? eth.ethSignMessage(msg, this.evmProvider, address) : null;
   }
 
   async ethSignTypedData(msg: core.ETHSignTypedData): Promise<core.ETHSignedTypedData | null> {
-    const address = await this.ethGetAddress();
+    const address = await this.ethGetAddress({ addressNList: [] });
     return address ? eth.ethSignTypedData(msg, this.evmProvider, address) : null;
   }
 
@@ -352,4 +391,21 @@ export class PhantomHDWallet extends PhantomHDWalletInfo implements core.HDWalle
     const signature = Base64.fromByteArray(core.fromHexString(msg.signature));
     return bitcoinMsg.verify(msg.message, msg.address, signature);
   }
+
+  /** Solana */
+
+  public async solanaGetAddress(): Promise<string | null> {
+    const { publicKey } = await this.solanaProvider.connect();
+    return publicKey.toString();
+  }
+
+  public async solanaSignTx(msg: core.SolanaSignTx): Promise<core.SolanaSignedTx | null> {
+    const address = await this.solanaGetAddress();
+    return address ? solanaSignTx(msg, this.solanaProvider, address) : null;
+  }
+
+  public async solanaSendTx(msg: core.SolanaSignTx): Promise<core.SolanaTxSignature | null> {
+    const address = await this.solanaGetAddress();
+    return address ? solanaSendTx(msg, this.solanaProvider, address) : null;
+  }
 }

package/src/solana.ts

@@ -0,0 +1,80 @@
+import * as core from "@shapeshiftoss/hdwallet-core";
+import {
+  ComputeBudgetProgram,
+  PublicKey,
+  SystemProgram,
+  TransactionInstruction,
+  TransactionMessage,
+  VersionedTransaction,
+} from "@solana/web3.js";
+
+import { PhantomSolanaProvider } from "./types";
+
+export type SolanaAccount = {
+  publicKey: PublicKey;
+};
+
+function toTransactionInstructions(instructions: core.SolanaTxInstruction[]): TransactionInstruction[] {
+  return instructions.map(
+    (instruction) =>
+      new TransactionInstruction({
+        keys: instruction.keys.map((key) => Object.assign(key, { pubkey: new PublicKey(key.pubkey) })),
+        programId: new PublicKey(instruction.programId),
+        data: instruction.data,
+      })
+  );
+}
+
+function buildTransaction(msg: core.SolanaSignTx, address: string): VersionedTransaction {
+  const instructions = toTransactionInstructions(msg.instructions ?? []);
+
+  const value = Number(msg.value);
+  if (!isNaN(value) && value > 0 && msg.to) {
+    instructions.push(
+      SystemProgram.transfer({
+        fromPubkey: new PublicKey(address),
+        toPubkey: new PublicKey(msg.to),
+        lamports: value,
+      })
+    );
+  }
+
+  if (msg.computeUnitLimit !== undefined) {
+    instructions.push(ComputeBudgetProgram.setComputeUnitLimit({ units: msg.computeUnitLimit }));
+  }
+
+  if (msg.computeUnitPrice !== undefined) {
+    instructions.push(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: msg.computeUnitPrice }));
+  }
+
+  const message = new TransactionMessage({
+    payerKey: new PublicKey(address),
+    instructions,
+    recentBlockhash: msg.blockHash,
+  }).compileToV0Message();
+
+  return new VersionedTransaction(message);
+}
+
+export async function solanaSignTx(
+  msg: core.SolanaSignTx,
+  provider: PhantomSolanaProvider,
+  address: string
+): Promise<core.SolanaSignedTx | null> {
+  const transaction = buildTransaction(msg, address);
+  const signedTransaction = await provider.signTransaction(transaction);
+  return {
+    serialized: Buffer.from(signedTransaction.serialize()).toString("base64"),
+    signatures: signedTransaction.signatures.map((signature) => Buffer.from(signature).toString("base64")),
+  };
+}
+
+export async function solanaSendTx(
+  msg: core.SolanaSignTx,
+  provider: PhantomSolanaProvider,
+  address: string
+): Promise<core.SolanaTxSignature | null> {
+  const transaction = buildTransaction(msg, address);
+  const { signature } = await provider.signAndSendTransaction(transaction);
+  return { signature };
+}

package/src/types.ts

@@ -1,6 +1,8 @@
+import { PublicKey, VersionedTransaction } from "@solana/web3.js";
 import { providers } from "ethers";
 
 import { BtcAccount } from "./bitcoin";
+import { SolanaAccount } from "./solana";
 
 export type PhantomEvmProvider = providers.ExternalProvider & {
   _metamask: {
@@ -21,3 +23,10 @@ export type PhantomUtxoProvider = providers.ExternalProvider & {
     options: { inputsToSign: { sigHash?: number | undefined; address: string; signingIndexes: number[] }[] }
   ): Promise<Uint8Array>;
 };
+
+export type PhantomSolanaProvider = providers.ExternalProvider & {
+  publicKey?: PublicKey;
+  connect(): Promise<SolanaAccount>;
+  signTransaction(transaction: VersionedTransaction): Promise<VersionedTransaction>;
+  signAndSendTransaction(transaction: VersionedTransaction): Promise<{ signature: any }>;
+};