@shapeshiftoss/hdwallet-coinbase 1.49.1-alpha.0

package/src/coinbase.ts

@@ -0,0 +1,383 @@
+import * as core from "@shapeshiftoss/hdwallet-core";
+import { AddEthereumChainParameter } from "@shapeshiftoss/hdwallet-core";
+import { ethErrors, serializeError } from "eth-rpc-errors";
+
+import * as eth from "./ethereum";
+
+export class CoinbaseHDWalletInfo implements core.HDWalletInfo, core.ETHWalletInfo {
+  readonly _supportsBTCInfo = false;
+  readonly _supportsETHInfo = true;
+  readonly _supportsCosmosInfo = false;
+  readonly _supportsBinanceInfo = false;
+  readonly _supportsRippleInfo = false;
+  readonly _supportsEosInfo = false;
+  readonly _supportsFioInfo = false;
+  readonly _supportsThorchainInfo = false;
+  readonly _supportsSecretInfo = false;
+  readonly _supportsKavaInfo = false;
+  readonly _supportsTerraInfo = false;
+
+  public getVendor(): string {
+    return "Coinbase";
+  }
+
+  public hasOnDevicePinEntry(): boolean {
+    return false;
+  }
+
+  public hasOnDevicePassphrase(): boolean {
+    return true;
+  }
+
+  public hasOnDeviceDisplay(): boolean {
+    return true;
+  }
+
+  public hasOnDeviceRecovery(): boolean {
+    return true;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public hasNativeShapeShift(srcCoin: core.Coin, dstCoin: core.Coin): boolean {
+    return false;
+  }
+
+  public supportsBip44Accounts(): boolean {
+    return false;
+  }
+
+  public supportsOfflineSigning(): boolean {
+    return false;
+  }
+
+  public supportsBroadcast(): boolean {
+    return true;
+  }
+
+  public describePath(msg: core.DescribePath): core.PathDescription {
+    switch (msg.coin) {
+      case "Ethereum":
+        // return eth.describeETHPath(msg.path);
+        return core.describeETHPath(msg.path);
+      default:
+        throw new Error("Unsupported path");
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public ethNextAccountPath(msg: core.ETHAccountPath): core.ETHAccountPath | undefined {
+    // TODO: What do we do here?
+    return undefined;
+  }
+
+  public async ethSupportsNetwork(chainId: number): Promise<boolean> {
+    return chainId === 1;
+  }
+
+  public async ethSupportsSecureTransfer(): Promise<boolean> {
+    return false;
+  }
+
+  public ethSupportsNativeShapeShift(): boolean {
+    return false;
+  }
+
+  public async ethSupportsEIP1559(): Promise<boolean> {
+    return true;
+  }
+
+  public ethGetAccountPaths(msg: core.ETHGetAccountPath): Array<core.ETHAccountPath> {
+    return eth.ethGetAccountPaths(msg);
+  }
+}
+
+export class CoinbaseHDWallet implements core.HDWallet, core.ETHWallet {
+  readonly _supportsETH = true;
+  readonly _supportsETHInfo = true;
+  readonly _supportsBTCInfo = false;
+  readonly _supportsBTC = false;
+  readonly _supportsCosmosInfo = false;
+  readonly _supportsCosmos = false;
+  readonly _supportsEthSwitchChain = true; // maybe?
+  readonly _supportsAvalanche = false;
+  readonly _supportsOptimism = false;
+  readonly _supportsBSC = false;
+  readonly _supportsPolygon = true;
+  readonly _supportsOsmosisInfo = false;
+  readonly _supportsOsmosis = false;
+  readonly _supportsBinanceInfo = false;
+  readonly _supportsBinance = false;
+  readonly _supportsDebugLink = false;
+  readonly _isPortis = false;
+  readonly _isMetaMask = false;
+  readonly _isCoinbase = true;
+  readonly _supportsRippleInfo = false;
+  readonly _supportsRipple = false;
+  readonly _supportsEosInfo = false;
+  readonly _supportsEos = false;
+  readonly _supportsFioInfo = false;
+  readonly _supportsFio = false;
+  readonly _supportsThorchainInfo = false;
+  readonly _supportsThorchain = false;
+  readonly _supportsSecretInfo = false;
+  readonly _supportsSecret = false;
+  readonly _supportsKava = false;
+  readonly _supportsKavaInfo = false;
+  readonly _supportsTerra = false;
+  readonly _supportsTerraInfo = false;
+
+  info: CoinbaseHDWalletInfo & core.HDWalletInfo;
+  ethAddress?: string | null;
+  provider: any;
+
+  constructor(provider: unknown) {
+    this.info = new CoinbaseHDWalletInfo();
+    this.provider = provider;
+  }
+
+  async getFeatures(): Promise<Record<string, any>> {
+    return {};
+  }
+
+  public async isLocked(): Promise<boolean> {
+    return !this.provider._coinbase.isUnlocked();
+  }
+
+  public getVendor(): string {
+    return "Coinbase";
+  }
+
+  public async getModel(): Promise<string> {
+    return "Coinbase";
+  }
+
+  public async getLabel(): Promise<string> {
+    return "Coinbase";
+  }
+
+  public async initialize(): Promise<void> {
+    // nothing to initialize
+  }
+
+  public hasOnDevicePinEntry(): boolean {
+    return this.info.hasOnDevicePinEntry();
+  }
+
+  public hasOnDevicePassphrase(): boolean {
+    return this.info.hasOnDevicePassphrase();
+  }
+
+  public hasOnDeviceDisplay(): boolean {
+    return this.info.hasOnDeviceDisplay();
+  }
+
+  public hasOnDeviceRecovery(): boolean {
+    return this.info.hasOnDeviceRecovery();
+  }
+
+  public hasNativeShapeShift(srcCoin: core.Coin, dstCoin: core.Coin): boolean {
+    return this.info.hasNativeShapeShift(srcCoin, dstCoin);
+  }
+
+  public supportsBip44Accounts(): boolean {
+    return this.info.supportsBip44Accounts();
+  }
+
+  public supportsOfflineSigning(): boolean {
+    return false;
+  }
+
+  public supportsBroadcast(): boolean {
+    return true;
+  }
+
+  public async clearSession(): Promise<void> {
+    // TODO: Can we lock Coinbase from here?
+  }
+
+  public async ping(msg: core.Ping): Promise<core.Pong> {
+    // no ping function for Coinbase, so just returning Core.Pong
+    return { msg: msg.msg };
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public async sendPin(pin: string): Promise<void> {
+    // no concept of pin in Coinbase
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public async sendPassphrase(passphrase: string): Promise<void> {
+    // cannot send passphrase to Coinbase. Could show the widget?
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public async sendCharacter(charater: string): Promise<void> {
+    // no concept of sendCharacter in Coinbase
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public async sendWord(word: string): Promise<void> {
+    // no concept of sendWord in Coinbase
+  }
+
+  public async cancel(): Promise<void> {
+    // no concept of cancel in Coinbase
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  public async wipe(): Promise<void> {}
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-unused-vars
+  public async reset(msg: core.ResetDevice): Promise<void> {}
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public async recover(msg: core.RecoverDevice): Promise<void> {
+    // no concept of recover in Coinbase
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public async loadDevice(msg: core.LoadDevice): Promise<void> {
+    // TODO: Does Coinbase allow this to be done programatically?
+  }
+
+  public describePath(msg: core.DescribePath): core.PathDescription {
+    return this.info.describePath(msg);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public async getPublicKeys(msg: Array<core.GetPublicKey>): Promise<Array<core.PublicKey | null>> {
+    // Ethereum public keys are not exposed by the RPC API
+    return [];
+  }
+
+  public async isInitialized(): Promise<boolean> {
+    return true;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  public async disconnect(): Promise<void> {}
+
+  public async ethSupportsNetwork(chainId = 1): Promise<boolean> {
+    return chainId === 1;
+  }
+
+  public async ethGetChainId(): Promise<number | null> {
+    try {
+      // chainId as hex string
+      const chainId: string = await this.provider.request({ method: "eth_chainId" });
+      return parseInt(chainId, 16);
+    } catch (e) {
+      console.error(e);
+      return null;
+    }
+  }
+
+  public async ethAddChain(params: AddEthereumChainParameter): Promise<void> {
+    // at this point, we know that we're in the context of a valid Coinbase provider
+    await this.provider.request({ method: "wallet_addEthereumChain", params: [params] });
+  }
+
+  public async ethSwitchChain(params: AddEthereumChainParameter): Promise<void> {
+    try {
+      // at this point, we know that we're in the context of a valid Coinbase provider
+      await this.provider.request({ method: "wallet_switchEthereumChain", params: [{ chainId: params.chainId }] });
+    } catch (e: any) {
+      const error = serializeError(e);
+      // https://docs.metamask.io/guide/ethereum-provider.html#errors
+      // Internal error, which in the case of wallet_switchEthereumChain call means the chain isn't currently added to the wallet
+      if (error.code === -32603) {
+        // We only support Avalanche C-Chain currently. It is supported natively in XDEFI, and unsupported in Tally, both with no capabilities to add a new chain
+        // TODO(gomes): Find a better home for these. When that's done, we'll want to call ethSwitchChain with (params: AddEthereumChainParameter) instead
+        try {
+          await this.ethAddChain(params);
+          return;
+        } catch (addChainE: any) {
+          const addChainError = serializeError(addChainE);
+
+          if (addChainError.code === 4001) {
+            throw ethErrors.provider.userRejectedRequest();
+          }
+
+          throw (addChainError.data as any).originalError as {
+            code: number;
+            message: string;
+            stack: string;
+          };
+        }
+      }
+
+      if (error.code === 4001) {
+        throw ethErrors.provider.userRejectedRequest();
+      }
+
+      throw (error.data as any).originalError as {
+        code: number;
+        message: string;
+        stack: string;
+      };
+    }
+  }
+
+  public async ethSupportsSecureTransfer(): Promise<boolean> {
+    return false;
+  }
+
+  public ethSupportsNativeShapeShift(): boolean {
+    return false;
+  }
+
+  public async ethSupportsEIP1559(): Promise<boolean> {
+    return true;
+  }
+
+  public ethGetAccountPaths(msg: core.ETHGetAccountPath): Array<core.ETHAccountPath> {
+    return eth.ethGetAccountPaths(msg);
+  }
+
+  public ethNextAccountPath(msg: core.ETHAccountPath): core.ETHAccountPath | undefined {
+    return this.info.ethNextAccountPath(msg);
+  }
+
+  // TODO: Respect msg.addressNList!
+  // 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.provider);
+    if (address) {
+      this.ethAddress = address;
+      return address;
+    } else {
+      this.ethAddress = null;
+      return null;
+    }
+  }
+
+  public async ethSignTx(msg: core.ETHSignTx): Promise<core.ETHSignedTx | null> {
+    const address = await this.ethGetAddress(this.provider);
+    return address ? eth.ethSignTx(msg, this.provider, address) : null;
+  }
+
+  public async ethSendTx(msg: core.ETHSignTx): Promise<core.ETHTxHash | null> {
+    const address = await this.ethGetAddress(this.provider);
+    return address ? eth.ethSendTx(msg, this.provider, address) : null;
+  }
+
+  public async ethSignMessage(msg: core.ETHSignMessage): Promise<core.ETHSignedMessage | null> {
+    const address = await this.ethGetAddress(this.provider);
+    return address ? eth.ethSignMessage(msg, this.provider, address) : null;
+  }
+
+  public async ethVerifyMessage(msg: core.ETHVerifyMessage): Promise<boolean | null> {
+    return eth.ethVerifyMessage(msg, this.provider);
+  }
+
+  public async getDeviceID(): Promise<string> {
+    return "coinbase:" + (await this.ethGetAddress(this.provider));
+  }
+
+  public async getFirmwareVersion(): Promise<string> {
+    return "coinbase";
+  }
+}

package/src/ethereum.ts

@@ -0,0 +1,105 @@
+import * as core from "@shapeshiftoss/hdwallet-core";
+import { ETHSignedMessage } from "@shapeshiftoss/hdwallet-core";
+import * as ethers from "ethers";
+
+export function describeETHPath(path: core.BIP32Path): core.PathDescription {
+  return core.describeETHPath(path);
+}
+
+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: "Coinbase",
+    },
+  ];
+}
+
+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;
+  }
+}
+
+// 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 Coinbase 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,
+      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;
+  }
+}
+
+// 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 Coinbase wallet!");
+  return null;
+}
+
+export async function ethSignMessage(
+  msg: core.ETHSignMessage,
+  ethereum: any,
+  address: string
+): Promise<core.ETHSignedMessage | null> {
+  try {
+    const buffer = ethers.utils.isBytes(msg.message)
+      ? Buffer.from(ethers.utils.arrayify(msg.message))
+      : Buffer.from(msg.message);
+    const signedMsg = await ethereum.request({
+      method: "personal_sign",
+      params: [buffer.toString("hex"), address],
+    });
+
+    return {
+      address: address,
+      signature: signedMsg,
+    } as ETHSignedMessage;
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+}

package/src/index.ts

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

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"],
+  "references": [{ "path": "../hdwallet-core" }]
+}