@shapeshiftoss/hdwallet-gridplus 1.62.4-gridplus.alpha.0

package/src/constants.ts

@@ -0,0 +1,52 @@
+import { UtxoAccountType } from "@shapeshiftoss/types";
+export { UtxoAccountType };
+
+export enum PublicKeyType {
+  xpub = "0488b21e",
+  ypub = "049d7cb2",
+  zpub = "04b24746",
+  dgub = "02facafd",
+  Ltub = "019da462",
+  Mtub = "01b26ef6",
+}
+
+export const accountTypeToVersion = (() => {
+  const Litecoin = {
+    [UtxoAccountType.P2pkh]: Buffer.from(PublicKeyType.Ltub, "hex"),
+    [UtxoAccountType.SegwitP2sh]: Buffer.from(PublicKeyType.Mtub, "hex"),
+    [UtxoAccountType.SegwitNative]: Buffer.from(PublicKeyType.zpub, "hex"),
+  };
+
+  const Dogecoin = {
+    [UtxoAccountType.P2pkh]: Buffer.from(PublicKeyType.dgub, "hex"),
+  };
+
+  const Bitcoin = {
+    [UtxoAccountType.P2pkh]: Buffer.from(PublicKeyType.xpub, "hex"),
+    [UtxoAccountType.SegwitP2sh]: Buffer.from(PublicKeyType.ypub, "hex"),
+    [UtxoAccountType.SegwitNative]: Buffer.from(PublicKeyType.zpub, "hex"),
+  };
+
+  return (coin: string, type: UtxoAccountType) => {
+    switch (coin) {
+      case "Litecoin":
+        return Litecoin[type];
+      case "Bitcoin":
+        return Bitcoin[type];
+      case "Dogecoin":
+        if (type !== UtxoAccountType.P2pkh) throw new Error("Unsupported account type");
+        return Dogecoin[type];
+      default:
+        return Bitcoin[type];
+    }
+  };
+})();
+
+export const convertVersions = ["Ltub", "xpub", "dgub"];
+
+export const UTXO_NETWORK_PARAMS: Record<string, { pubKeyHash: number; scriptHash: number; bech32?: string }> = {
+  Bitcoin: { pubKeyHash: 0x00, scriptHash: 0x05, bech32: "bc" },
+  Dogecoin: { pubKeyHash: 0x1e, scriptHash: 0x16 },
+  Litecoin: { pubKeyHash: 0x30, scriptHash: 0x32, bech32: "ltc" },
+  BitcoinCash: { pubKeyHash: 0x00, scriptHash: 0x05 },
+};

package/src/cosmos.ts

@@ -0,0 +1,132 @@
+import { pointCompress } from "@bitcoinerlab/secp256k1";
+import type { StdTx } from "@cosmjs/amino";
+import type { DirectSignResponse, OfflineDirectSigner } from "@cosmjs/proto-signing";
+import type { SignerData } from "@cosmjs/stargate";
+import * as core from "@shapeshiftoss/hdwallet-core";
+import * as bech32 from "bech32";
+import type { SignDoc } from "cosmjs-types/cosmos/tx/v1beta1/tx";
+import CryptoJS from "crypto-js";
+import { Client, Constants } from "gridplus-sdk";
+import PLazy from "p-lazy";
+
+const protoTxBuilder = PLazy.from(() => import("@shapeshiftoss/proto-tx-builder"));
+const cosmJsProtoSigning = PLazy.from(() => import("@cosmjs/proto-signing"));
+
+export const bech32ify = (address: ArrayLike<number>, prefix: string): string => {
+  const words = bech32.toWords(address);
+  return bech32.encode(prefix, words);
+};
+
+export const createCosmosAddress = (publicKey: string, prefix: string): string => {
+  const message = CryptoJS.SHA256(CryptoJS.enc.Hex.parse(publicKey));
+  const hash = CryptoJS.RIPEMD160(message as CryptoJS.lib.WordArray).toString();
+  const address = Buffer.from(hash, `hex`);
+  return bech32ify(address, prefix);
+};
+
+export async function cosmosGetAddress(client: Client, msg: core.CosmosGetAddress): Promise<string | null> {
+  // Get secp256k1 pubkey using GridPlus client instance
+  // Use FULL path - Cosmos uses standard BIP44: m/44'/118'/0'/0/0 (5 levels)
+  const addresses = await client.getAddresses({
+    startPath: msg.addressNList,
+    n: 1,
+    flag: Constants.GET_ADDR_FLAGS.SECP256K1_PUB,
+  });
+
+  if (!addresses.length) {
+    throw new Error("No address returned from device");
+  }
+
+  // GridPlus SDK returns uncompressed 65-byte pubkeys, but Cosmos needs compressed 33-byte pubkeys
+  const pubkeyBuffer = Buffer.isBuffer(addresses[0]) ? addresses[0] : Buffer.from(addresses[0], "hex");
+  const compressedPubkey = pointCompress(pubkeyBuffer, true);
+  const compressedHex = Buffer.from(compressedPubkey).toString("hex");
+  const cosmosAddress = createCosmosAddress(compressedHex, "cosmos");
+
+  return cosmosAddress;
+}
+
+export async function cosmosSignTx(client: Client, msg: core.CosmosSignTx): Promise<core.CosmosSignedTx | null> {
+  // Get the address for this path
+  const address = await cosmosGetAddress(client, { addressNList: msg.addressNList });
+  if (!address) throw new Error("Failed to get Cosmos address");
+
+  // Get the public key using client instance
+  const pubkeys = await client.getAddresses({
+    startPath: msg.addressNList,
+    n: 1,
+    flag: Constants.GET_ADDR_FLAGS.SECP256K1_PUB,
+  });
+
+  if (!pubkeys.length) {
+    throw new Error("No public key returned from device");
+  }
+
+  // GridPlus SDK returns uncompressed 65-byte pubkeys, but Cosmos needs compressed 33-byte pubkeys
+  const pubkeyBuffer = Buffer.isBuffer(pubkeys[0]) ? pubkeys[0] : Buffer.from(pubkeys[0], "hex");
+  const compressedPubkey = pointCompress(pubkeyBuffer, true);
+  const pubkey = Buffer.from(compressedPubkey);
+
+  // Create a signer adapter for GridPlus with Direct signing (Proto)
+  const signer: OfflineDirectSigner = {
+    getAccounts: async () => [
+      {
+        address,
+        pubkey,
+        algo: "secp256k1" as const,
+      },
+    ],
+    signDirect: async (signerAddress: string, signDoc: SignDoc): Promise<DirectSignResponse> => {
+      if (signerAddress !== address) {
+        throw new Error("Signer address mismatch");
+      }
+
+      // Use CosmJS to create the sign bytes from the SignDoc
+      const signBytes = (await cosmJsProtoSigning).makeSignBytes(signDoc);
+
+      // Sign using GridPlus SDK general signing
+      // Pass unhashed signBytes and let device hash with SHA256
+      const signData = {
+        data: {
+          payload: signBytes,
+          curveType: Constants.SIGNING.CURVES.SECP256K1,
+          hashType: Constants.SIGNING.HASHES.SHA256,
+          encodingType: Constants.SIGNING.ENCODINGS.NONE,
+          signerPath: msg.addressNList,
+        },
+      };
+
+      const signedResult = await client.sign(signData);
+
+      if (!signedResult?.sig) {
+        throw new Error("No signature returned from device");
+      }
+
+      const { r, s } = signedResult.sig;
+      const rHex = Buffer.isBuffer(r) ? r : Buffer.from(r);
+      const sHex = Buffer.isBuffer(s) ? s : Buffer.from(s);
+
+      // Combine r and s for signature
+      const signature = Buffer.concat([rHex, sHex]);
+
+      return {
+        signed: signDoc,
+        signature: {
+          pub_key: {
+            type: "tendermint/PubKeySecp256k1",
+            value: pubkey.toString("base64"),
+          },
+          signature: signature.toString("base64"),
+        },
+      };
+    },
+  };
+
+  const signerData: SignerData = {
+    sequence: Number(msg.sequence),
+    accountNumber: Number(msg.account_number),
+    chainId: msg.chain_id,
+  };
+
+  return (await protoTxBuilder).sign(address, msg.tx as StdTx, signer, signerData, "cosmos");
+}

package/src/ethereum.ts

@@ -0,0 +1,305 @@
+import Common from "@ethereumjs/common";
+import { FeeMarketEIP1559Transaction, Transaction } from "@ethereumjs/tx";
+import * as core from "@shapeshiftoss/hdwallet-core";
+import { Client, Constants, Utils } from "gridplus-sdk";
+import { encode } from "rlp";
+
+export async function ethGetAddress(client: Client, msg: core.ETHGetAddress): Promise<core.Address | null> {
+  // Extract address index from EVM path: m/44'/60'/0'/0/X
+  // addressNList = [44', 60', 0', 0, X]
+  const addressIndex = msg.addressNList[4] || 0;
+  const startPath = [...msg.addressNList.slice(0, 4), addressIndex];
+
+  // TODO: testing only for @kaladinlight, revert me
+  // EXPERIMENTAL: Test different flags to see what GridPlus SDK returns
+  // Try SECP256K1_XPUB flag alongside default (no flag)
+  const addressesWithXpubFlag = await client.getAddresses({
+    startPath,
+    n: 1,
+    flag: Constants.GET_ADDR_FLAGS.SECP256K1_XPUB,
+  });
+
+  // Fetch only the requested address using client instance (current working method)
+  const addresses = await client.getAddresses({
+    startPath,
+    n: 1,
+  });
+
+  if (!addresses.length) {
+    throw new Error("No address returned from device");
+  }
+
+  const rawAddress = addresses[0];
+  const rawAddressWithXpubFlag = addressesWithXpubFlag[0];
+
+  let address: string;
+
+  // Handle response format (could be Buffer or string)
+  if (Buffer.isBuffer(rawAddress)) {
+    // Device returns raw address bytes without 0x prefix - add it for EVM compatibility
+    address = "0x" + rawAddress.toString("hex");
+  } else {
+    address = rawAddress.toString();
+  }
+
+  // Device may return address without 0x prefix - ensure it's present for EVM compatibility
+  if (!address.startsWith("0x")) {
+    address = "0x" + address;
+  }
+
+  // Validate Ethereum address format (should be 42 chars with 0x prefix)
+  if (address.length !== 42) {
+    throw new Error(`Invalid Ethereum address length: ${address}`);
+  }
+
+  // EXPERIMENTAL LOGGING: Compare what different flags return
+  console.log("=== GridPlus ethGetAddress Flag Comparison ===");
+  console.log("Path:", startPath);
+  console.log("No flag result:", {
+    type: Buffer.isBuffer(rawAddress) ? "Buffer" : typeof rawAddress,
+    raw: rawAddress,
+    asHex: Buffer.isBuffer(rawAddress) ? rawAddress.toString("hex") : rawAddress,
+  });
+  console.log("SECP256K1_XPUB flag result:", {
+    type: Buffer.isBuffer(rawAddressWithXpubFlag) ? "Buffer" : typeof rawAddressWithXpubFlag,
+    raw: rawAddressWithXpubFlag,
+    asString: Buffer.isBuffer(rawAddressWithXpubFlag) ? rawAddressWithXpubFlag.toString("hex") : rawAddressWithXpubFlag,
+  });
+  console.log("Final derived address:", address.toLowerCase());
+  console.log("==============================================");
+
+  // core.Address for ETH is just a string type `0x${string}`
+  return address.toLowerCase() as core.Address;
+}
+
+export async function ethSignTx(client: Client, msg: core.ETHSignTx): Promise<core.ETHSignedTx> {
+  const unsignedTxBase = {
+    to: msg.to,
+    value: msg.value,
+    data: msg.data,
+    nonce: msg.nonce,
+    gasLimit: msg.gasLimit,
+    chainId: msg.chainId,
+  };
+
+  const common = msg.maxFeePerGas
+    ? Common.custom({ chainId: msg.chainId }, { hardfork: "london" })
+    : Common.custom({ chainId: msg.chainId });
+  const unsignedTx = msg.maxFeePerGas
+    ? FeeMarketEIP1559Transaction.fromTxData(
+        {
+          ...unsignedTxBase,
+          maxFeePerGas: msg.maxFeePerGas,
+          maxPriorityFeePerGas: msg.maxPriorityFeePerGas,
+        },
+        { common }
+      )
+    : Transaction.fromTxData({ ...unsignedTxBase, gasPrice: msg.gasPrice }, { common });
+
+  const payload = msg.maxFeePerGas ? unsignedTx.getMessageToSign(false) : encode(unsignedTx.getMessageToSign(false));
+
+  const callDataDecoder = msg.to ? await Utils.fetchCalldataDecoder(msg.data, msg.to, msg.chainId) : undefined;
+
+  const signingData = {
+    data: {
+      payload,
+      curveType: Constants.SIGNING.CURVES.SECP256K1,
+      hashType: Constants.SIGNING.HASHES.KECCAK256,
+      encodingType: Constants.SIGNING.ENCODINGS.EVM,
+      signerPath: msg.addressNList,
+      decoder: callDataDecoder?.def,
+    },
+  };
+
+  const signedResult = await client.sign(signingData);
+
+  if (!signedResult?.sig) {
+    throw new Error("No signature returned from device");
+  }
+
+  const { r, s, v } = signedResult.sig;
+
+  const rHex = "0x" + (Buffer.isBuffer(r) ? r.toString("hex") : core.toHexString(r));
+  const sHex = "0x" + (Buffer.isBuffer(s) ? s.toString("hex") : core.toHexString(s));
+  const vHex = "0x" + (Buffer.isBuffer(v) ? v.toString("hex") : core.toHexString(v));
+
+  const signedTx = msg.maxFeePerGas
+    ? FeeMarketEIP1559Transaction.fromTxData(
+        {
+          ...unsignedTxBase,
+          maxFeePerGas: msg.maxFeePerGas,
+          maxPriorityFeePerGas: msg.maxPriorityFeePerGas,
+          r: rHex,
+          s: sHex,
+          v: vHex,
+        },
+        { common }
+      )
+    : Transaction.fromTxData(
+        {
+          ...unsignedTxBase,
+          gasPrice: msg.gasPrice,
+          r: rHex,
+          s: sHex,
+          v: vHex,
+        },
+        { common }
+      );
+
+  const finalSerializedTx = `0x${signedTx.serialize().toString("hex")}`;
+  const vRaw = Buffer.isBuffer(v) ? v.readUInt8(0) : v;
+
+  const result = {
+    r: rHex,
+    s: sHex,
+    v: vRaw,
+    serialized: finalSerializedTx,
+  };
+
+  return result;
+}
+
+export async function ethSignTypedData(client: Client, msg: core.ETHSignTypedData): Promise<core.ETHSignedTypedData> {
+  const fwConstants = client.getFwConstants();
+  if (!fwConstants.eip712Supported) {
+    throw new Error("EIP-712 signing not supported by firmware version");
+  }
+
+  const addressResult = await ethGetAddress(client, {
+    addressNList: msg.addressNList,
+    showDisplay: false,
+  });
+
+  const signingOptions = {
+    currency: "ETH_MSG",
+    data: {
+      protocol: "eip712",
+      payload: msg.typedData,
+      signerPath: msg.addressNList,
+    },
+  };
+
+  // GridPlus SDK types don't properly support ETH_MSG currency, but runtime does
+  const signedResult = await client.sign(signingOptions as Parameters<typeof client.sign>[0]);
+
+  if (!signedResult?.sig) {
+    throw new Error("No signature returned from device");
+  }
+
+  // Type assertion needed because GridPlus SDK incorrectly types ETH_MSG signatures
+  const { r, s, v } = signedResult.sig as { r: string | Buffer; s: string | Buffer; v: number | Buffer };
+
+  let rHex: string;
+  let sHex: string;
+
+  if (Buffer.isBuffer(r)) {
+    rHex = "0x" + r.toString("hex");
+  } else if (typeof r === "string") {
+    if (r.startsWith("0x")) {
+      rHex = r;
+    } else {
+      rHex = "0x" + r;
+    }
+  } else {
+    throw new Error(`Unexpected r format: ${typeof r}`);
+  }
+
+  if (Buffer.isBuffer(s)) {
+    sHex = "0x" + s.toString("hex");
+  } else if (typeof s === "string") {
+    if (s.startsWith("0x")) {
+      sHex = s;
+    } else {
+      sHex = "0x" + s;
+    }
+  } else {
+    throw new Error(`Unexpected s format: ${typeof s}`);
+  }
+
+  const vBuf = Buffer.isBuffer(v) ? v : typeof v === "number" ? Buffer.from([v]) : Buffer.from(v);
+  const vValue = vBuf.readUInt8(0);
+  const vHex = "0x" + vValue.toString(16);
+
+  const signature = rHex + sHex.slice(2) + vHex.slice(2);
+
+  return {
+    address: addressResult!,
+    signature: signature,
+  };
+}
+
+export async function ethSignMessage(client: Client, msg: core.ETHSignMessage): Promise<core.ETHSignedMessage> {
+  if (typeof client.sign !== "function") {
+    throw new Error("GridPlus client missing required sign method");
+  }
+
+  const addressResult = await ethGetAddress(client, {
+    addressNList: msg.addressNList,
+    showDisplay: false,
+  });
+
+  let hexMessage: string;
+  if (msg.message.startsWith("0x")) {
+    hexMessage = msg.message;
+  } else {
+    const buffer = Buffer.from(msg.message, "utf8");
+    hexMessage = "0x" + buffer.toString("hex");
+  }
+
+  const signingOptions = {
+    currency: "ETH_MSG",
+    data: {
+      protocol: "signPersonal",
+      payload: hexMessage,
+      signerPath: msg.addressNList,
+    },
+  };
+
+  // GridPlus SDK types don't properly support ETH_MSG currency, but runtime does
+  const signedResult = await client.sign(signingOptions as Parameters<typeof client.sign>[0]);
+
+  if (!signedResult?.sig) {
+    throw new Error("No signature returned from device");
+  }
+
+  // Type assertion needed because GridPlus SDK incorrectly types ETH_MSG signatures
+  const { r, s, v } = signedResult.sig as { r: string | Buffer; s: string | Buffer; v: number | Buffer };
+
+  let rHex: string;
+  let sHex: string;
+
+  if (Buffer.isBuffer(r)) {
+    rHex = "0x" + r.toString("hex");
+  } else if (typeof r === "string") {
+    if (r.startsWith("0x")) {
+      rHex = r;
+    } else {
+      rHex = "0x" + r;
+    }
+  } else {
+    throw new Error(`Unexpected r format: ${typeof r}`);
+  }
+
+  if (Buffer.isBuffer(s)) {
+    sHex = "0x" + s.toString("hex");
+  } else if (typeof s === "string") {
+    if (s.startsWith("0x")) {
+      sHex = s;
+    } else {
+      sHex = "0x" + s;
+    }
+  } else {
+    throw new Error(`Unexpected s format: ${typeof s}`);
+  }
+
+  const vBuf = Buffer.isBuffer(v) ? v : typeof v === "number" ? Buffer.from([v]) : Buffer.from(v);
+  const vValue = vBuf.readUInt8(0);
+  const vHex = "0x" + vValue.toString(16);
+
+  const signature = rHex + sHex.slice(2) + vHex.slice(2);
+
+  return {
+    address: addressResult!,
+    signature: signature,
+  };
+}