@shapeshiftoss/hdwallet-gridplus 1.62.9 → 1.62.10-alpha.1

package/src/ethereum.ts

@@ -1,8 +1,8 @@
 import { Common, Hardfork } from "@ethereumjs/common";
-import { TransactionFactory, TypedTxData } from "@ethereumjs/tx";
+import { RLP } from "@ethereumjs/rlp";
+import { TransactionFactory, TransactionType, TypedTxData } 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> {
   const address = (await client.getAddresses({ startPath: msg.addressNList, n: 1 }))[0];
@@ -23,37 +23,23 @@ export async function ethSignTx(client: Client, msg: core.ETHSignTx): Promise<co
     nonce: msg.nonce,
     gasLimit: msg.gasLimit,
     chainId: msg.chainId,
-    // Add explicit type field for TransactionFactory to correctly detect transaction type
-    type: isEIP1559 ? 2 : 0,
-    ...(isEIP1559
-      ? {
-          maxFeePerGas: msg.maxFeePerGas,
-          maxPriorityFeePerGas: msg.maxPriorityFeePerGas,
-        }
-      : {
-          gasPrice: msg.gasPrice,
-        }),
+    type: isEIP1559 ? TransactionType.FeeMarketEIP1559 : TransactionType.Legacy,
+    maxFeePerGas: msg.maxFeePerGas,
+    maxPriorityFeePerGas: msg.maxPriorityFeePerGas,
+    gasPrice: msg.gasPrice,
   };
 
-  const common = isEIP1559
-    ? Common.custom({ chainId: msg.chainId }, { hardfork: Hardfork.London })
-    : Common.custom({ chainId: msg.chainId });
-
-  // Use TransactionFactory with explicit type field (Kevin's approach)
+  const common = Common.custom({ chainId: msg.chainId }, { hardfork: Hardfork.London });
   const unsignedTx = TransactionFactory.fromTxData(txData, { common });
 
-  // Handle payload encoding based on transaction type
-  // Legacy transactions return an array that needs RLP encoding
-  // EIP-1559 transactions return a pre-encoded buffer
-  const rawPayload = unsignedTx.getMessageToSign();
-  const payload = Array.isArray(rawPayload) ? encode(rawPayload) : rawPayload;
+  const payload = isEIP1559 ? unsignedTx.getMessageToSign() : RLP.encode(unsignedTx.getMessageToSign());
 
   const fwVersion = client.getFwVersion();
   const supportsDecoderRecursion = fwVersion.major > 0 || fwVersion.minor >= 16;
 
   const decoderResult = await (() => {
     if (!msg.data || (msg.data.startsWith("0x") && Buffer.from(msg.data.slice(2), "hex").length < 4)) {
-      return { def: null };
+      return { def: undefined };
     }
     return Utils.fetchCalldataDecoder(msg.data, msg.to, msg.chainId, supportsDecoderRecursion);
   })();
@@ -67,7 +53,7 @@ export async function ethSignTx(client: Client, msg: core.ETHSignTx): Promise<co
       hashType: Constants.SIGNING.HASHES.KECCAK256,
       encodingType: Constants.SIGNING.ENCODINGS.EVM,
       signerPath: msg.addressNList,
-      decoder: def,
+      decoder: def ? Buffer.from(def) : undefined,
     },
   });
 
@@ -79,29 +65,7 @@ export async function ethSignTx(client: Client, msg: core.ETHSignTx): Promise<co
   if (!Buffer.isBuffer(s)) throw new Error("Invalid signature (s)");
   if (!Buffer.isBuffer(v)) throw new Error("Invalid signature (v)");
 
-  // Reconstruct signed transaction using TransactionFactory with explicit type field
-  const signedTxData = {
-    to: msg.to,
-    value: msg.value,
-    data: msg.data,
-    nonce: msg.nonce,
-    gasLimit: msg.gasLimit,
-    chainId: msg.chainId,
-    type: isEIP1559 ? 2 : 0,
-    r,
-    s,
-    v,
-    ...(isEIP1559
-      ? {
-          maxFeePerGas: msg.maxFeePerGas,
-          maxPriorityFeePerGas: msg.maxPriorityFeePerGas,
-        }
-      : {
-          gasPrice: msg.gasPrice,
-        }),
-  };
-
-  const signedTx = TransactionFactory.fromTxData(signedTxData, { common });
+  const signedTx = TransactionFactory.fromTxData({ ...txData, r, s, v }, { common });
   const serialized = `0x${Buffer.from(signedTx.serialize()).toString("hex")}`;
 
   return { r: `0x${r.toString("hex")}`, s: `0x${s.toString("hex")}`, v: v.readUIntBE(0, v.length), serialized };

package/src/gridplus.ts

@@ -8,8 +8,6 @@ import * as eth from "./ethereum";
 import * as mayachain from "./mayachain";
 import * as solana from "./solana";
 import * as thorchain from "./thorchain";
-import { GridPlusTransport } from "./transport";
-import { convertXpubVersion, scriptTypeToAccountType } from "./utils";
 
 export function isGridPlus(wallet: core.HDWallet): wallet is GridPlusHDWallet {
   return isObject(wallet) && (wallet as any)._isGridPlus;
@@ -273,12 +271,12 @@ export class GridPlusHDWallet
   extends GridPlusWalletInfo
   implements
     core.HDWallet,
-    core.ETHWallet,
-    core.SolanaWallet,
     core.BTCWallet,
     core.CosmosWallet,
-    core.ThorchainWallet,
-    core.MayachainWallet
+    core.ETHWallet,
+    core.MayachainWallet,
+    core.SolanaWallet,
+    core.ThorchainWallet
 {
   readonly _supportsArbitrum = true;
   readonly _supportsArbitrumNova = false;
@@ -298,117 +296,77 @@ export class GridPlusHDWallet
 
   readonly _isGridPlus = true;
 
-  private activeWalletId?: string;
+  client: Client | undefined;
 
-  transport: GridPlusTransport;
-  client?: Client;
-
-  constructor(transport: GridPlusTransport) {
+  constructor(client: Client) {
     super();
-    this.transport = transport;
-  }
-
-  public setActiveWalletId(walletId: string): void {
-    this.activeWalletId = walletId;
+    this.client = client;
+  }
+
+  async cancel(): Promise<void> {}
+  async clearSession(): Promise<void> {}
+  async initialize(): Promise<void> {}
+  async loadDevice(): Promise<void> {}
+  async recover(): Promise<void> {}
+  async reset(): Promise<void> {}
+  async sendCharacter(): Promise<void> {}
+  async sendPassphrase(): Promise<void> {}
+  async sendPin(): Promise<void> {}
+  async sendWord(): Promise<void> {}
+  async wipe(): Promise<void> {}
+
+  async getDeviceID(): Promise<string> {
+    if (!this.client) throw new Error("Device not connected");
+    return this.client.getDeviceId();
   }
 
   async getFeatures(): Promise<Record<string, any>> {
+    if (!this.client) throw new Error("Device not connected");
+
     return {
       vendor: "GridPlus",
-      deviceId: this.transport.deviceId,
+      deviceId: this.client.getDeviceId(),
       model: "Lattice1",
     };
   }
 
-  public async isLocked(): Promise<boolean> {
-    return !this.transport.isConnected();
-  }
-
-  public async clearSession(): Promise<void> {
-    if (!this.client) return;
-    await this.transport.disconnect();
-    this.client = undefined;
-  }
-
-  public async isInitialized(): Promise<boolean> {
-    return !!this.client;
-  }
-
-  public async initialize(): Promise<void> {
-    // Get the GridPlus client from transport after successful pairing
-    this.client = this.transport.getClient();
-
-    if (!this.client) {
-      throw new Error("GridPlus client not available - device may not be paired");
-    }
-
-    // Validate that the client has the expected methods
-    if (typeof this.client.getAddresses !== "function") {
-      throw new Error("GridPlus client missing required getAddresses method");
-    }
-  }
-
-  public async ping(msg: core.Ping): Promise<core.Pong> {
-    return { msg: msg.msg };
-  }
-
-  public async sendPin(): Promise<void> {}
-
-  public async sendPassphrase(): Promise<void> {}
-
-  public async sendCharacter(): Promise<void> {}
-
-  public async sendWord(): Promise<void> {}
-
-  public async cancel(): Promise<void> {
-    // GridPlus has no pending device interactions to cancel
-    // Wallet persists in keyring - do not disconnect
-  }
-
-  public async wipe(): Promise<void> {
-    throw new Error("GridPlus does not support wiping");
+  async getFirmwareVersion(): Promise<string> {
+    if (!this.client) throw new Error("Device not connected");
+    const { major, minor, fix } = this.client.getFwVersion();
+    return `${major}.${minor}.${fix}`;
   }
 
-  public async reset(): Promise<void> {
-    await this.clearSession();
-    await this.initialize();
+  async getModel(): Promise<string> {
+    return "Lattice1";
   }
 
-  public async recover(): Promise<void> {
-    throw new Error("GridPlus does not support recovery mode");
+  async getLabel(): Promise<string> {
+    return "GridPlus Lattice1";
   }
 
-  public async loadDevice(): Promise<void> {
-    throw new Error("GridPlus does not support device loading");
+  async isInitialized(): Promise<boolean> {
+    return Boolean(this.client);
   }
 
-  public describePath(): core.PathDescription {
-    return {
-      verbose: "GridPlus does not support path descriptions yet",
-      coin: "Unknown",
-      isKnown: false,
-    };
+  async isLocked(): Promise<boolean> {
+    if (!this.client) throw new Error("Device not connected");
+    return false;
   }
 
-  public async getModel(): Promise<string> {
-    return "Lattice1";
+  async ping(msg: core.Ping): Promise<core.Pong> {
+    return { msg: msg.msg };
   }
 
-  public async getLabel(): Promise<string> {
-    return "GridPlus Lattice1";
+  async disconnect(): Promise<void> {
+    this.client = undefined;
   }
 
-  public async getFirmwareVersion(): Promise<string> {
+  getSessionId(): string | undefined {
     if (!this.client) throw new Error("Device not connected");
-    const { major, minor, fix } = this.client.getFwVersion();
-    return `${major}.${minor}.${fix}`;
-  }
-
-  public async getDeviceID(): Promise<string> {
-    return this.activeWalletId || (await this.transport.getDeviceID());
+    return JSON.parse(this.client.getStateData())["privKey"];
   }
 
-  public async getPublicKeys(msg: Array<core.GetPublicKey>): Promise<Array<core.PublicKey | null>> {
+  async getPublicKeys(msg: Array<core.GetPublicKey>): Promise<Array<core.PublicKey | null>> {
     if (!this.client) throw new Error("Device not connected");
 
     const publicKeys: Array<core.PublicKey | null> = [];
@@ -417,18 +375,18 @@ export class GridPlusHDWallet
       const { addressNList, curve, coin, scriptType } = getPublicKey;
 
       try {
-        let flag: number;
-
-        // Determine the appropriate flag based on curve type
-        if (curve === "secp256k1") {
-          // For UTXO chains (Bitcoin, Dogecoin), we need the xpub
-          flag = Constants.GET_ADDR_FLAGS.SECP256K1_XPUB;
-        } else if (curve === "ed25519") {
-          // For Solana/ed25519 chains, we need the public key
-          flag = Constants.GET_ADDR_FLAGS.ED25519_PUB;
-        } else {
-          throw new Error(`Unsupported curve: ${curve}`);
-        }
+        const flag = (() => {
+          switch (curve) {
+            // For UTXO chains (Bitcoin, Dogecoin), we need the xpub
+            case "secp256k1":
+              return Constants.GET_ADDR_FLAGS.SECP256K1_XPUB;
+            // For Solana/ed25519 chains, we need the public key
+            case "ed25519":
+              return Constants.GET_ADDR_FLAGS.ED25519_PUB;
+            default:
+              throw new Error(`Unsupported curve: ${curve}`);
+          }
+        })();
 
         const addresses = await this.client!.getAddresses({
           startPath: addressNList,
@@ -436,17 +394,15 @@ export class GridPlusHDWallet
           flag,
         });
 
-        if (!addresses.length) {
-          throw new Error("No public key returned from device");
-        }
+        if (!addresses.length) throw new Error("No public key returned from device");
 
         // addresses[0] contains either xpub string (for SECP256K1_XPUB) or pubkey hex (for ED25519_PUB)
         let xpub = typeof addresses[0] === "string" ? addresses[0] : Buffer.from(addresses[0]).toString("hex");
 
         // Convert xpub format for Dogecoin/Litecoin (GridPlus returns Bitcoin xpub format)
         if (coin && curve === "secp256k1") {
-          const accountType = scriptTypeToAccountType(scriptType);
-          xpub = convertXpubVersion(xpub, accountType, coin);
+          const accountType = scriptType ? core.scriptTypeToAccountType[scriptType] : undefined;
+          xpub = core.convertXpubVersion(xpub, accountType, coin);
         }
 
         publicKeys.push({ xpub });
@@ -458,53 +414,45 @@ export class GridPlusHDWallet
     return publicKeys;
   }
 
-  public getSessionId(): string | undefined {
-    return this.transport.getSessionId();
-  }
-
-  public async disconnect(): Promise<void> {
-    await this.clearSession();
-  }
-
-  public async btcGetAddress(msg: core.BTCGetAddress): Promise<string | null> {
+  async btcGetAddress(msg: core.BTCGetAddress): Promise<string | null> {
     if (!this.client) throw new Error("Device not connected");
     return btc.btcGetAddress(this.client!, msg);
   }
 
-  public async btcSignTx(msg: core.BTCSignTx): Promise<core.BTCSignedTx | null> {
+  async btcSignTx(msg: core.BTCSignTx): Promise<core.BTCSignedTx | null> {
     if (!this.client) throw new Error("Device not connected");
     return btc.btcSignTx(this.client, msg);
   }
 
-  public async btcSignMessage(): Promise<core.BTCSignedMessage | null> {
+  async btcSignMessage(): Promise<core.BTCSignedMessage | null> {
     throw new Error("GridPlus BTC message signing not yet implemented");
   }
 
-  public async btcVerifyMessage(): Promise<boolean | null> {
+  async btcVerifyMessage(): Promise<boolean | null> {
     throw new Error("GridPlus BTC message verification not yet implemented");
   }
 
-  public async ethGetAddress(msg: core.ETHGetAddress): Promise<core.Address | null> {
+  async ethGetAddress(msg: core.ETHGetAddress): Promise<core.Address | null> {
     if (!this.client) throw new Error("Device not connected");
     return eth.ethGetAddress(this.client, msg);
   }
 
-  public async ethSignTx(msg: core.ETHSignTx): Promise<core.ETHSignedTx> {
+  async ethSignTx(msg: core.ETHSignTx): Promise<core.ETHSignedTx> {
     if (!this.client) throw new Error("Device not connected");
     return eth.ethSignTx(this.client, msg);
   }
 
-  public async ethSignTypedData(msg: core.ETHSignTypedData): Promise<core.ETHSignedTypedData> {
+  async ethSignTypedData(msg: core.ETHSignTypedData): Promise<core.ETHSignedTypedData> {
     if (!this.client) throw new Error("Device not connected");
     return eth.ethSignTypedData(this.client, msg);
   }
 
-  public async ethSignMessage(msg: core.ETHSignMessage): Promise<core.ETHSignedMessage> {
+  async ethSignMessage(msg: core.ETHSignMessage): Promise<core.ETHSignedMessage> {
     if (!this.client) throw new Error("Device not connected");
     return eth.ethSignMessage(this.client, msg);
   }
 
-  public async ethVerifyMessage(): Promise<boolean> {
+  async ethVerifyMessage(): Promise<boolean> {
     throw new Error("GridPlus ETH message verification not implemented yet");
   }
 
@@ -520,42 +468,42 @@ export class GridPlusHDWallet
     }
   }
 
-  public async solanaGetAddress(msg: core.SolanaGetAddress): Promise<string | null> {
+  async solanaGetAddress(msg: core.SolanaGetAddress): Promise<string | null> {
     this.assertSolanaFwSupport();
     return solana.solanaGetAddress(this.client, msg);
   }
 
-  public async solanaSignTx(msg: core.SolanaSignTx): Promise<core.SolanaSignedTx | null> {
+  async solanaSignTx(msg: core.SolanaSignTx): Promise<core.SolanaSignedTx | null> {
     this.assertSolanaFwSupport();
     return solana.solanaSignTx(this.client, msg);
   }
 
-  public async cosmosGetAddress(msg: core.CosmosGetAddress): Promise<string | null> {
+  async cosmosGetAddress(msg: core.CosmosGetAddress): Promise<string | null> {
     if (!this.client) throw new Error("Device not connected");
     return cosmos.cosmosGetAddress(this.client, msg);
   }
 
-  public async cosmosSignTx(msg: core.CosmosSignTx): Promise<core.CosmosSignedTx | null> {
+  async cosmosSignTx(msg: core.CosmosSignTx): Promise<core.CosmosSignedTx | null> {
     if (!this.client) throw new Error("Device not connected");
     return cosmos.cosmosSignTx(this.client, msg);
   }
 
-  public async thorchainGetAddress(msg: core.ThorchainGetAddress): Promise<string | null> {
+  async thorchainGetAddress(msg: core.ThorchainGetAddress): Promise<string | null> {
     if (!this.client) throw new Error("Device not connected");
     return thorchain.thorchainGetAddress(this.client, msg);
   }
 
-  public async thorchainSignTx(msg: core.ThorchainSignTx): Promise<core.ThorchainSignedTx | null> {
+  async thorchainSignTx(msg: core.ThorchainSignTx): Promise<core.ThorchainSignedTx | null> {
     if (!this.client) throw new Error("Device not connected");
     return thorchain.thorchainSignTx(this.client, msg);
   }
 
-  public async mayachainGetAddress(msg: core.MayachainGetAddress): Promise<string | null> {
+  async mayachainGetAddress(msg: core.MayachainGetAddress): Promise<string | null> {
     if (!this.client) throw new Error("Device not connected");
     return mayachain.mayachainGetAddress(this.client, msg);
   }
 
-  public async mayachainSignTx(msg: core.MayachainSignTx): Promise<core.MayachainSignedTx | null> {
+  async mayachainSignTx(msg: core.MayachainSignTx): Promise<core.MayachainSignedTx | null> {
     if (!this.client) throw new Error("Device not connected");
     return mayachain.mayachainSignTx(this.client, msg);
   }

package/src/index.ts

@@ -1,3 +1,2 @@
 export * from "./adapter";
 export { GridPlusHDWallet, GridPlusWalletInfo, isGridPlus } from "./gridplus";
-export * from "./transport";

package/src/utils.ts

@@ -1,14 +1,11 @@
 import { pointCompress } from "@bitcoinerlab/secp256k1";
-import * as core from "@shapeshiftoss/hdwallet-core";
 import * as bech32 from "bech32";
-import { decode as bs58Decode, encode as bs58Encode } from "bs58check";
+import * as bs58 from "bs58check";
 import CryptoJS from "crypto-js";
 
-import { accountTypeToVersion, convertVersions, UTXO_NETWORK_PARAMS, UtxoAccountType } from "./constants";
-
 export const getCompressedPubkey = (pubkey: string | Buffer): Buffer => {
   // Extended public key (xpub/ypub/zpub)
-  if (typeof pubkey === "string") return bs58Decode(pubkey).subarray(45, 78);
+  if (typeof pubkey === "string") return bs58.decode(pubkey).subarray(45, 78);
 
   // Already compressed public key (33 bytes)
   if (pubkey.length === 33) return pubkey;
@@ -27,98 +24,3 @@ export const createBech32Address = (pubkey: string | Buffer, prefix: string): st
   const words = bech32.toWords(address);
   return bech32.encode(prefix, words);
 };
-
-/**
- * Convert xpub version bytes for different coins (e.g., xpub → dgub for Dogecoin)
- * GridPlus returns Bitcoin-format xpubs, but some coins like Dogecoin need different prefixes
- */
-export function convertXpubVersion(xpub: string, accountType: UtxoAccountType | undefined, coin: string): string {
-  if (!accountType) return xpub;
-  if (!convertVersions.includes(xpub.substring(0, 4))) {
-    return xpub;
-  }
-
-  const payload = bs58Decode(xpub);
-  const version = payload.slice(0, 4);
-  const desiredVersion = accountTypeToVersion(coin, accountType);
-  if (version.compare(desiredVersion) !== 0) {
-    const key = payload.slice(4);
-    return bs58Encode(Buffer.concat([desiredVersion, key]));
-  }
-  return xpub;
-}
-
-export function scriptTypeToAccountType(scriptType: core.BTCInputScriptType | undefined): UtxoAccountType | undefined {
-  switch (scriptType) {
-    case core.BTCInputScriptType.SpendAddress:
-      return UtxoAccountType.P2pkh;
-    case core.BTCInputScriptType.SpendWitness:
-      return UtxoAccountType.SegwitNative;
-    case core.BTCInputScriptType.SpendP2SHWitness:
-      return UtxoAccountType.SegwitP2sh;
-    default:
-      return undefined;
-  }
-}
-
-/**
- * Derive a UTXO address from a compressed public key
- * @param pubkeyHex - Compressed public key as hex string (33 bytes, starting with 02 or 03)
- * @param coin - Coin name (Bitcoin, Dogecoin, Litecoin, etc.)
- * @param scriptType - Script type (p2pkh, p2wpkh, p2sh-p2wpkh)
- * @returns The derived address
- */
-export function deriveAddressFromPubkey(
-  pubkeyHex: string,
-  coin: string,
-  scriptType: core.BTCInputScriptType = core.BTCInputScriptType.SpendAddress
-): string {
-  const network = UTXO_NETWORK_PARAMS[coin] || UTXO_NETWORK_PARAMS.Bitcoin;
-  const pubkeyBuffer = Buffer.from(pubkeyHex, "hex");
-
-  if (pubkeyBuffer.length !== 33) {
-    throw new Error(`Invalid compressed public key length: ${pubkeyBuffer.length} bytes`);
-  }
-
-  // Hash160 = RIPEMD160(SHA256(pubkey))
-  const sha256Hash = CryptoJS.SHA256(CryptoJS.enc.Hex.parse(pubkeyHex));
-  const hash160 = CryptoJS.RIPEMD160(sha256Hash).toString();
-  const hash160Buffer = Buffer.from(hash160, "hex");
-
-  switch (scriptType) {
-    case core.BTCInputScriptType.SpendAddress: {
-      // P2PKH: <pubKeyHash version byte> + hash160 + checksum
-      const payload = Buffer.concat([Buffer.from([network.pubKeyHash]), hash160Buffer]);
-      return bs58Encode(payload);
-    }
-
-    case core.BTCInputScriptType.SpendWitness: {
-      // P2WPKH (bech32): witness version 0 + hash160
-      if (!network.bech32) {
-        throw new Error(`Bech32 not supported for ${coin}`);
-      }
-      const words = bech32.toWords(hash160Buffer);
-      words.unshift(0); // witness version 0
-      return bech32.encode(network.bech32, words);
-    }
-
-    case core.BTCInputScriptType.SpendP2SHWitness: {
-      // P2SH-P2WPKH: scriptHash of witness program
-      // Witness program: OP_0 (0x00) + length (0x14) + hash160
-      const witnessProgram = Buffer.concat([Buffer.from([0x00, 0x14]), hash160Buffer]);
-
-      // Hash160 of witness program
-      const wpHex = witnessProgram.toString("hex");
-      const wpSha256 = CryptoJS.SHA256(CryptoJS.enc.Hex.parse(wpHex));
-      const wpHash160 = CryptoJS.RIPEMD160(wpSha256).toString();
-      const wpHash160Buffer = Buffer.from(wpHash160, "hex");
-
-      // Encode with scriptHash version byte
-      const payload = Buffer.concat([Buffer.from([network.scriptHash]), wpHash160Buffer]);
-      return bs58Encode(payload);
-    }
-
-    default:
-      throw new Error(`Unsupported script type: ${scriptType}`);
-  }
-}

package/tsconfig.json

@@ -1,8 +1,9 @@
 {
   "extends": "../../tsconfig.json",
   "compilerOptions": {
+    "rootDir": "src",
     "outDir": "dist",
-    "rootDir": "src"
+    "tsBuildInfoFile": "./dist/tsconfig.tsbuildinfo",
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"],