@swapkit/wallet-hardware 5.0.0 → 6.0.0

package/src/ledger/clients/cosmos.ts

@@ -1,85 +1,214 @@
+import type { StdSignDoc } from "@cosmjs/amino";
+import type { SignerCosmos } from "@ledgerhq/device-signer-kit-cosmos";
+import type LegacyCosmosApp from "@ledgerhq/hw-app-cosmos";
 import type Transport from "@ledgerhq/hw-transport";
+import { hex } from "@scure/base";
 import {
   type DerivationPathArray,
   derivationPathToString,
   NetworkDerivationPath,
   SwapKitError,
 } from "@swapkit/helpers";
-import { CosmosLedgerInterface } from "../interfaces/CosmosLedgerInterface";
+import type { OfflineAminoSigner } from "@swapkit/toolboxes/cosmos";
 
-export class CosmosLedger extends CosmosLedgerInterface {
-  private pubKey: string | null = null;
+import type { LedgerDMKSession } from "../helpers/dmk";
+import { createLedgerSessionSigner } from "../helpers/dmk";
+import {
+  executeLedgerDeviceAction,
+  type LedgerDeviceActionStateHandler,
+  toLedgerDeviceError,
+  ZONDAX_USER_REFUSED_STATUS_WORDS,
+} from "../helpers/executeDeviceAction";
+import { toLowSSignature } from "../helpers/lowS";
+
+interface CosmosLedgerParams {
+  derivationPath?: DerivationPathArray | string;
+  dmkSession?: LedgerDMKSession;
+  onDeviceActionState?: LedgerDeviceActionStateHandler;
+  transport?: Transport;
+}
+
+interface CosmosAddressAndPublicKey {
+  address: string;
+  publicKey: string;
+}
 
-  derivationPath: string;
+function normalizeCosmosPath(path: DerivationPathArray | string) {
+  const normalized = (typeof path === "string" ? path : derivationPathToString(path))
+    .replace(/^m\//, "")
+    .replace(/^\/+/, "");
 
-  constructor(derivationPath: DerivationPathArray = NetworkDerivationPath.GAIA, transport?: Transport) {
-    super(transport);
-    this.chain = "cosmos";
-    this.derivationPath = derivationPathToString(derivationPath);
+  if (!/^44'\/118'\/\d+'\/(0|1)\/\d+$/.test(normalized)) {
+    throw new SwapKitError("wallet_ledger_invalid_params", {
+      path: normalized,
+      reason: "Expected a five-level Cosmos derivation path with coin type 118",
+    });
   }
 
-  connect = async () => {
-    await this.checkOrCreateTransportAndLedger(true);
-    const { publicKey, address } = await this.getAddressAndPubKey();
+  return normalized;
+}
 
-    this.pubKey = Buffer.from(publicKey, "hex").toString("base64");
+// cosmjs is CJS and `require`s ESM-only `@scure/base`; loading it lazily keeps Bun from rejecting that
+// require when the module graph also contains the ESM-only `@swapkit/*` packages.
+async function normalizeCosmosSignature(signature: Uint8Array) {
+  const { Secp256k1Signature } = await import("@cosmjs/crypto");
+  try {
+    return toLowSSignature(
+      signature.length === 64
+        ? Secp256k1Signature.fromFixedLength(signature).toFixedLength()
+        : Secp256k1Signature.fromDer(signature).toFixedLength(),
+    );
+  } catch (error) {
+    throw new SwapKitError("wallet_ledger_invalid_response", error);
+  }
+}
 
-    return address;
-  };
+export class CosmosLedger {
+  readonly chain = "cosmos";
+  readonly derivationPath: string;
+  private readonly onDeviceActionState?: LedgerDeviceActionStateHandler;
+  private readonly transport?: Transport;
+  private legacyAppPromise?: Promise<LegacyCosmosApp>;
+  private pubKey: string | null = null;
+  private readonly getSessionSigner: () => Promise<SignerCosmos>;
+
+  constructor({
+    derivationPath = NetworkDerivationPath.GAIA,
+    dmkSession,
+    onDeviceActionState,
+    transport,
+  }: CosmosLedgerParams = {}) {
+    this.derivationPath = normalizeCosmosPath(derivationPath);
+    this.getSessionSigner = createLedgerSessionSigner({
+      build: async (session) => {
+        const { SignerCosmosBuilder } = await import("@ledgerhq/device-signer-kit-cosmos");
+        return new SignerCosmosBuilder(session).build();
+      },
+      dmkSession,
+    });
+    this.onDeviceActionState = onDeviceActionState;
+    this.transport = transport;
+  }
 
-  getAddressAndPubKey = async () => {
-    await this.checkOrCreateTransportAndLedger(true);
+  private getSigner() {
+    if (this.transport) {
+      throw new SwapKitError("wallet_ledger_invalid_params", {
+        reason: "A Device Signer Kit operation is unavailable when a legacy transport is supplied",
+      });
+    }
 
-    const response = await this.ledgerApp.getAddress(this.derivationPath, this.chain);
+    return this.getSessionSigner();
+  }
 
-    return response;
-  };
+  private getLegacyApp() {
+    if (!this.transport) {
+      throw new SwapKitError("wallet_ledger_invalid_params", { reason: "Legacy Cosmos transport is unavailable" });
+    }
 
-  signTransaction = async (rawTx: string, sequence = "0") => {
-    await this.checkOrCreateTransportAndLedger(true);
+    this.legacyAppPromise ??= import("@ledgerhq/hw-app-cosmos").then(
+      ({ default: CosmosApp }) => new CosmosApp(this.transport as Transport),
+    );
+    return this.legacyAppPromise;
+  }
 
-    const { return_code, error_message, signature } = await this.ledgerApp.sign(this.derivationPath, rawTx);
+  // An injected LedgerJS transport rejects with hw-transport and hw-app-cosmos errors; map them as the signer kit
+  // path below does.
+  private async runLegacyOperation<Output>(operation: (app: LegacyCosmosApp) => Promise<Output>) {
+    const app = await this.getLegacyApp();
+    try {
+      return await operation(app);
+    } catch (error) {
+      throw toLedgerDeviceError(error, { userRefusedStatusWords: ZONDAX_USER_REFUSED_STATUS_WORDS });
+    }
+  }
 
-    if (!this.pubKey) throw new SwapKitError("wallet_ledger_pubkey_not_found");
+  private async signBytes(message: Uint8Array) {
+    if (this.transport) {
+      const response = await this.runLegacyOperation((app) =>
+        app.sign(this.derivationPath, new TextDecoder().decode(message)),
+      );
+      if (response.return_code !== 0x9000 || !response.signature) {
+        throw new SwapKitError("wallet_ledger_invalid_response", { returnCode: response.return_code });
+      }
+      return normalizeCosmosSignature(response.signature);
+    }
 
-    this.validateResponse(return_code, error_message);
+    const signer = await this.getSigner();
+    const signature = await executeLedgerDeviceAction({
+      action: () => signer.signTransaction(this.derivationPath, this.chain, message),
+      onDeviceActionState: this.onDeviceActionState,
+      userRefusedStatusWords: ZONDAX_USER_REFUSED_STATUS_WORDS,
+    });
+    return normalizeCosmosSignature(signature);
+  }
 
-    return [{ pub_key: { type: "tendermint/PubKeySecp256k1", value: this.pubKey }, sequence, signature }];
-  };
+  async connect() {
+    if (this.transport) await this.getLegacyApp();
+    else await this.getSigner();
 
-  signAmino = async (signerAddress: string, signDoc: any): Promise<any> => {
-    await this.checkOrCreateTransportAndLedger(true);
+    const { address, publicKey } = await this.getAddressAndPubKey();
+    this.pubKey = Buffer.from(publicKey, "hex").toString("base64");
+    return address;
+  }
 
-    const accounts = await this.getAccounts();
-    const accountIndex = accounts.findIndex((account) => account.address === signerAddress);
+  async disconnect() {}
 
-    if (accountIndex === -1) {
-      throw new SwapKitError("wallet_ledger_address_not_found", { address: signerAddress });
+  async getAddressAndPubKey(): Promise<CosmosAddressAndPublicKey> {
+    if (this.transport) {
+      return this.runLegacyOperation((app) => app.getAddress(this.derivationPath, this.chain));
     }
 
-    const importedAmino = await import("@cosmjs/amino");
-    const encodeSecp256k1Signature =
-      importedAmino.encodeSecp256k1Signature ?? importedAmino.default?.encodeSecp256k1Signature;
-    const serializeSignDoc = importedAmino.serializeSignDoc ?? importedAmino.default?.serializeSignDoc;
-    const importedCrypto = await import("@cosmjs/crypto");
-    const Secp256k1Signature = importedCrypto.Secp256k1Signature ?? importedCrypto.default?.Secp256k1Signature;
+    const signer = await this.getSigner();
+    const { address, publicKey } = await executeLedgerDeviceAction({
+      action: () => signer.getAddress(this.derivationPath, this.chain),
+      onDeviceActionState: this.onDeviceActionState,
+      userRefusedStatusWords: ZONDAX_USER_REFUSED_STATUS_WORDS,
+    });
+    return { address, publicKey: hex.encode(publicKey) };
+  }
 
-    const message = serializeSignDoc(signDoc);
-    const signature = await this.ledgerApp.sign(this.derivationPath, message);
+  async showAddressAndPubKey(): Promise<CosmosAddressAndPublicKey> {
+    if (this.transport) {
+      return this.runLegacyOperation((app) => app.getAddress(this.derivationPath, this.chain, true));
+    }
 
-    this.validateResponse(signature.return_code, signature.error_message);
+    const signer = await this.getSigner();
+    const { address, publicKey } = await executeLedgerDeviceAction({
+      action: () => signer.getAddress(this.derivationPath, this.chain, { checkOnDevice: true }),
+      onDeviceActionState: this.onDeviceActionState,
+      userRefusedStatusWords: ZONDAX_USER_REFUSED_STATUS_WORDS,
+    });
+    return { address, publicKey: hex.encode(publicKey) };
+  }
 
-    const secpSignature = Secp256k1Signature.fromDer(signature.signature).toFixedLength();
+  async signTransaction(rawTx: string | Uint8Array, sequence = "0") {
+    const signature = await this.signBytes(typeof rawTx === "string" ? new TextEncoder().encode(rawTx) : rawTx);
+    if (!this.pubKey) {
+      const { publicKey } = await this.getAddressAndPubKey();
+      this.pubKey = Buffer.from(publicKey, "hex").toString("base64");
+    }
 
-    return { signature: encodeSecp256k1Signature(accounts[0].pubkey, secpSignature), signed: signDoc };
-  };
+    return [{ pub_key: { type: "tendermint/PubKeySecp256k1", value: this.pubKey }, sequence, signature }];
+  }
 
-  getAccounts = async () => {
-    await this.checkOrCreateTransportAndLedger(true);
+  // Typed against the toolbox signer contract so CosmosLedger satisfies `createSigningStargateClient`.
+  async signAmino(
+    signerAddress: string,
+    signDoc: Parameters<OfflineAminoSigner["signAmino"]>[1],
+  ): ReturnType<OfflineAminoSigner["signAmino"]> {
+    const accounts = await this.getAccounts();
+    const account = accounts.find(({ address }) => address === signerAddress);
+    if (!account) {
+      throw new SwapKitError("wallet_ledger_address_not_found", { address: signerAddress });
+    }
+
+    const { encodeSecp256k1Signature, serializeSignDoc } = await import("@cosmjs/amino");
+    const signature = await this.signBytes(serializeSignDoc(signDoc as StdSignDoc));
+    return { signature: encodeSecp256k1Signature(account.pubkey, signature), signed: signDoc };
+  }
 
-    const addressAndPubKey = await this.getAddressAndPubKey();
-    return [
-      { address: addressAndPubKey.address, algo: "secp256k1", pubkey: Buffer.from(addressAndPubKey.publicKey, "hex") },
-    ] as any[];
-  };
+  async getAccounts() {
+    const { address, publicKey } = await this.getAddressAndPubKey();
+    return [{ address, algo: "secp256k1" as const, pubkey: hex.decode(publicKey) }];
+  }
 }