@shapeshiftoss/hdwallet-gridplus 1.62.10-alpha.3 → 1.62.10

package/src/ethereum.ts

@@ -1,8 +1,8 @@
 import { Common, Hardfork } from "@ethereumjs/common";
-import { RLP } from "@ethereumjs/rlp";
-import { TransactionFactory, TransactionType, TypedTxData } from "@ethereumjs/tx";
+import { TransactionFactory, 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,23 +23,37 @@ export async function ethSignTx(client: Client, msg: core.ETHSignTx): Promise<co
     nonce: msg.nonce,
     gasLimit: msg.gasLimit,
     chainId: msg.chainId,
-    type: isEIP1559 ? TransactionType.FeeMarketEIP1559 : TransactionType.Legacy,
-    maxFeePerGas: msg.maxFeePerGas,
-    maxPriorityFeePerGas: msg.maxPriorityFeePerGas,
-    gasPrice: msg.gasPrice,
+    // 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,
+        }),
   };
 
-  const common = Common.custom({ chainId: msg.chainId }, { hardfork: Hardfork.London });
+  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 unsignedTx = TransactionFactory.fromTxData(txData, { common });
 
-  const payload = isEIP1559 ? unsignedTx.getMessageToSign() : RLP.encode(unsignedTx.getMessageToSign());
+  // 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 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: undefined };
+      return { def: null };
     }
     return Utils.fetchCalldataDecoder(msg.data, msg.to, msg.chainId, supportsDecoderRecursion);
   })();
@@ -53,7 +67,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 ? Buffer.from(def) : undefined,
+      decoder: def,
     },
   });
 
@@ -65,7 +79,29 @@ 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)");
 
-  const signedTx = TransactionFactory.fromTxData({ ...txData, r, s, v }, { common });
+  // 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 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,8 @@ import * as eth from "./ethereum";
 import * as mayachain from "./mayachain";
 import * as solana from "./solana";
 import * as thorchain from "./thorchain";
-
-const ZERO_BUFFER = Buffer.alloc(32);
+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 +273,12 @@ export class GridPlusHDWallet
   extends GridPlusWalletInfo
   implements
     core.HDWallet,
-    core.BTCWallet,
-    core.CosmosWallet,
     core.ETHWallet,
-    core.MayachainWallet,
     core.SolanaWallet,
-    core.ThorchainWallet
+    core.BTCWallet,
+    core.CosmosWallet,
+    core.ThorchainWallet,
+    core.MayachainWallet
 {
   readonly _supportsArbitrum = true;
   readonly _supportsArbitrumNova = false;
@@ -298,80 +298,117 @@ export class GridPlusHDWallet
 
   readonly _isGridPlus = true;
 
-  client: Client | undefined;
+  private activeWalletId?: string;
+
+  transport: GridPlusTransport;
+  client?: Client;
 
-  constructor(client: Client) {
+  constructor(transport: GridPlusTransport) {
     super();
-    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();
+    this.transport = transport;
   }
 
-  async getFeatures(): Promise<Record<string, any>> {
-    if (!this.client) throw new Error("Device not connected");
+  public setActiveWalletId(walletId: string): void {
+    this.activeWalletId = walletId;
+  }
 
+  async getFeatures(): Promise<Record<string, any>> {
     return {
       vendor: "GridPlus",
-      deviceId: this.client.getDeviceId(),
+      deviceId: this.transport.deviceId,
       model: "Lattice1",
     };
   }
 
-  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 isLocked(): Promise<boolean> {
+    return !this.transport.isConnected();
   }
 
-  async getModel(): Promise<string> {
-    return "Lattice1";
+  public async clearSession(): Promise<void> {
+    if (!this.client) return;
+    await this.transport.disconnect();
+    this.client = undefined;
   }
 
-  async getLabel(): Promise<string> {
-    return "GridPlus Lattice1";
+  public async isInitialized(): Promise<boolean> {
+    return !!this.client;
   }
 
-  async isInitialized(): Promise<boolean> {
-    return Boolean(this.client);
-  }
+  public async initialize(): Promise<void> {
+    // Get the GridPlus client from transport after successful pairing
+    this.client = this.transport.getClient();
 
-  async isLocked(): Promise<boolean> {
-    return false;
+    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");
+    }
   }
 
-  async ping(msg: core.Ping): Promise<core.Pong> {
+  public async ping(msg: core.Ping): Promise<core.Pong> {
     return { msg: msg.msg };
   }
 
-  async disconnect(): Promise<void> {
-    this.client = undefined;
+  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
   }
 
-  async getActiveWalletId(): Promise<string | undefined> {
-    if (!this.client) throw new Error("Device not connected");
+  public async wipe(): Promise<void> {
+    throw new Error("GridPlus does not support wiping");
+  }
 
-    const { external, internal } = await this.client.fetchActiveWallet();
+  public async reset(): Promise<void> {
+    await this.clearSession();
+    await this.initialize();
+  }
+
+  public async recover(): Promise<void> {
+    throw new Error("GridPlus does not support recovery mode");
+  }
+
+  public async loadDevice(): Promise<void> {
+    throw new Error("GridPlus does not support device loading");
+  }
+
+  public describePath(): core.PathDescription {
+    return {
+      verbose: "GridPlus does not support path descriptions yet",
+      coin: "Unknown",
+      isKnown: false,
+    };
+  }
+
+  public async getModel(): Promise<string> {
+    return "Lattice1";
+  }
 
-    if (!external.uid.equals(ZERO_BUFFER)) return external.uid.toString("hex");
-    if (!internal.uid.equals(ZERO_BUFFER)) return internal.uid.toString("hex");
+  public async getLabel(): Promise<string> {
+    return "GridPlus Lattice1";
+  }
+
+  public 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 getDeviceID(): Promise<string> {
+    return this.activeWalletId || (await this.transport.getDeviceID());
   }
 
-  async getPublicKeys(msg: Array<core.GetPublicKey>): Promise<Array<core.PublicKey | null>> {
+  public 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> = [];
@@ -380,18 +417,18 @@ export class GridPlusHDWallet
       const { addressNList, curve, coin, scriptType } = getPublicKey;
 
       try {
-        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}`);
-          }
-        })();
+        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 addresses = await this.client!.getAddresses({
           startPath: addressNList,
@@ -399,15 +436,17 @@ 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 = scriptType ? core.scriptTypeToAccountType[scriptType] : undefined;
-          xpub = core.convertXpubVersion(xpub, accountType, coin);
+          const accountType = scriptTypeToAccountType(scriptType);
+          xpub = convertXpubVersion(xpub, accountType, coin);
         }
 
         publicKeys.push({ xpub });
@@ -419,45 +458,53 @@ export class GridPlusHDWallet
     return publicKeys;
   }
 
-  async btcGetAddress(msg: core.BTCGetAddress): Promise<string | null> {
+  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> {
     if (!this.client) throw new Error("Device not connected");
     return btc.btcGetAddress(this.client!, msg);
   }
 
-  async btcSignTx(msg: core.BTCSignTx): Promise<core.BTCSignedTx | null> {
+  public async btcSignTx(msg: core.BTCSignTx): Promise<core.BTCSignedTx | null> {
     if (!this.client) throw new Error("Device not connected");
     return btc.btcSignTx(this.client, msg);
   }
 
-  async btcSignMessage(): Promise<core.BTCSignedMessage | null> {
+  public async btcSignMessage(): Promise<core.BTCSignedMessage | null> {
     throw new Error("GridPlus BTC message signing not yet implemented");
   }
 
-  async btcVerifyMessage(): Promise<boolean | null> {
+  public async btcVerifyMessage(): Promise<boolean | null> {
     throw new Error("GridPlus BTC message verification not yet implemented");
   }
 
-  async ethGetAddress(msg: core.ETHGetAddress): Promise<core.Address | null> {
+  public async ethGetAddress(msg: core.ETHGetAddress): Promise<core.Address | null> {
     if (!this.client) throw new Error("Device not connected");
     return eth.ethGetAddress(this.client, msg);
   }
 
-  async ethSignTx(msg: core.ETHSignTx): Promise<core.ETHSignedTx> {
+  public async ethSignTx(msg: core.ETHSignTx): Promise<core.ETHSignedTx> {
     if (!this.client) throw new Error("Device not connected");
     return eth.ethSignTx(this.client, msg);
   }
 
-  async ethSignTypedData(msg: core.ETHSignTypedData): Promise<core.ETHSignedTypedData> {
+  public async ethSignTypedData(msg: core.ETHSignTypedData): Promise<core.ETHSignedTypedData> {
     if (!this.client) throw new Error("Device not connected");
     return eth.ethSignTypedData(this.client, msg);
   }
 
-  async ethSignMessage(msg: core.ETHSignMessage): Promise<core.ETHSignedMessage> {
+  public async ethSignMessage(msg: core.ETHSignMessage): Promise<core.ETHSignedMessage> {
     if (!this.client) throw new Error("Device not connected");
     return eth.ethSignMessage(this.client, msg);
   }
 
-  async ethVerifyMessage(): Promise<boolean> {
+  public async ethVerifyMessage(): Promise<boolean> {
     throw new Error("GridPlus ETH message verification not implemented yet");
   }
 
@@ -473,42 +520,42 @@ export class GridPlusHDWallet
     }
   }
 
-  async solanaGetAddress(msg: core.SolanaGetAddress): Promise<string | null> {
+  public async solanaGetAddress(msg: core.SolanaGetAddress): Promise<string | null> {
     this.assertSolanaFwSupport();
     return solana.solanaGetAddress(this.client, msg);
   }
 
-  async solanaSignTx(msg: core.SolanaSignTx): Promise<core.SolanaSignedTx | null> {
+  public async solanaSignTx(msg: core.SolanaSignTx): Promise<core.SolanaSignedTx | null> {
     this.assertSolanaFwSupport();
     return solana.solanaSignTx(this.client, msg);
   }
 
-  async cosmosGetAddress(msg: core.CosmosGetAddress): Promise<string | null> {
+  public async cosmosGetAddress(msg: core.CosmosGetAddress): Promise<string | null> {
     if (!this.client) throw new Error("Device not connected");
     return cosmos.cosmosGetAddress(this.client, msg);
   }
 
-  async cosmosSignTx(msg: core.CosmosSignTx): Promise<core.CosmosSignedTx | null> {
+  public async cosmosSignTx(msg: core.CosmosSignTx): Promise<core.CosmosSignedTx | null> {
     if (!this.client) throw new Error("Device not connected");
     return cosmos.cosmosSignTx(this.client, msg);
   }
 
-  async thorchainGetAddress(msg: core.ThorchainGetAddress): Promise<string | null> {
+  public async thorchainGetAddress(msg: core.ThorchainGetAddress): Promise<string | null> {
     if (!this.client) throw new Error("Device not connected");
     return thorchain.thorchainGetAddress(this.client, msg);
   }
 
-  async thorchainSignTx(msg: core.ThorchainSignTx): Promise<core.ThorchainSignedTx | null> {
+  public async thorchainSignTx(msg: core.ThorchainSignTx): Promise<core.ThorchainSignedTx | null> {
     if (!this.client) throw new Error("Device not connected");
     return thorchain.thorchainSignTx(this.client, msg);
   }
 
-  async mayachainGetAddress(msg: core.MayachainGetAddress): Promise<string | null> {
+  public async mayachainGetAddress(msg: core.MayachainGetAddress): Promise<string | null> {
     if (!this.client) throw new Error("Device not connected");
     return mayachain.mayachainGetAddress(this.client, msg);
   }
 
-  async mayachainSignTx(msg: core.MayachainSignTx): Promise<core.MayachainSignedTx | null> {
+  public 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,2 +1,3 @@
 export * from "./adapter";
 export { GridPlusHDWallet, GridPlusWalletInfo, isGridPlus } from "./gridplus";
+export * from "./transport";

package/src/transport.ts

@@ -0,0 +1,131 @@
+import * as core from "@shapeshiftoss/hdwallet-core";
+import { randomBytes } from "crypto";
+import { Client } from "gridplus-sdk";
+
+export type GridPlusTransportConfig = {
+  deviceId: string;
+  password?: string;
+};
+
+export class GridPlusTransport extends core.Transport {
+  public deviceId?: string;
+  public password?: string;
+  public connected: boolean = false;
+  private client?: Client;
+  // Session identifier used to track reconnections. When present, we can skip
+  // passing deviceId to SDK setup() which avoids triggering the pairing screen
+  // on the device and enables faster reconnection from localStorage.
+  private sessionId?: string;
+
+  constructor(config: GridPlusTransportConfig) {
+    super(new core.Keyring());
+    this.deviceId = config.deviceId;
+    this.password = config.password;
+  }
+
+  public getDeviceID(): Promise<string> {
+    return Promise.resolve(this.deviceId || "");
+  }
+
+  public async connect(): Promise<void> {
+    if (!this.deviceId) {
+      throw new Error("Device ID is required to connect to GridPlus");
+    }
+
+    const { isPaired } = await this.setup(this.deviceId, this.password);
+
+    if (!isPaired) {
+      throw new Error("Device is not paired");
+    }
+  }
+
+  public async connectGridPlus(deviceId: string, password?: string): Promise<void> {
+    this.deviceId = deviceId;
+    this.password = password || "shapeshift-default";
+    await this.connect();
+  }
+
+  public async disconnect(): Promise<void> {
+    this.connected = false;
+    this.deviceId = undefined;
+    this.password = undefined;
+  }
+
+  public isConnected(): boolean {
+    return this.connected;
+  }
+
+  public async setup(
+    deviceId: string,
+    password?: string,
+    existingSessionId?: string
+  ): Promise<{ isPaired: boolean; sessionId: string }> {
+    this.deviceId = deviceId;
+    this.password = password || "shapeshift-default";
+
+    // Use existing sessionId if provided, otherwise generate new one
+    if (existingSessionId) {
+      this.sessionId = existingSessionId;
+    } else if (!this.sessionId) {
+      this.sessionId = randomBytes(32).toString("hex");
+    }
+
+    // Create Client instance directly (Frame pattern) - no localStorage!
+    // This ensures we always get fresh activeWallets from device
+    if (!this.client) {
+      this.client = new Client({
+        name: "ShapeShift",
+        baseUrl: "https://signing.gridpl.us",
+        privKey: Buffer.from(this.sessionId, "hex"),
+        retryCount: 3,
+        timeout: 60000,
+        skipRetryOnWrongWallet: true,
+      });
+
+      try {
+        // Connect to device - returns true if paired, false if needs pairing
+        const isPaired = await this.client.connect(deviceId);
+        this.connected = true;
+        return { isPaired, sessionId: this.sessionId };
+      } catch (error) {
+        // Handle "Device Locked" error - treat as unpaired
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.toLowerCase().includes("device locked")) {
+          this.connected = true;
+          return { isPaired: false, sessionId: this.sessionId };
+        }
+
+        throw error;
+      }
+    } else {
+      // Client already exists, reset active wallets to clear stale state before reconnecting
+      // This is critical when switching between SafeCards - ensures fresh wallet state from device
+      this.client.resetActiveWallets();
+      const isPaired = await this.client.connect(deviceId);
+      this.connected = true;
+      return { isPaired, sessionId: this.sessionId };
+    }
+  }
+
+  public async pair(pairingCode: string): Promise<boolean> {
+    if (!this.client) {
+      throw new Error("Client not initialized. Call setup() first.");
+    }
+
+    const result = await this.client.pair(pairingCode);
+    this.connected = !!result;
+    return !!result;
+  }
+
+  public getClient(): Client | undefined {
+    return this.client;
+  }
+
+  public getSessionId(): string | undefined {
+    return this.sessionId;
+  }
+
+  public async call(): Promise<any> {
+    throw new Error("GridPlus transport call not implemented");
+  }
+}