@dfinity/hardware-wallet-cli 0.1.0

package/src/ledger/identity.ts

@@ -0,0 +1,255 @@
+import {
+  CallRequest,
+  Cbor,
+  HttpAgentRequest,
+  PublicKey,
+  ReadRequest,
+  Signature,
+  SignIdentity,
+} from "@dfinity/agent";
+import { Principal } from "@dfinity/principal";
+import LedgerApp, { LedgerError, ResponseSign } from "@zondax/ledger-icp";
+import { Secp256k1PublicKey } from "./secp256k1";
+
+// @ts-ignore (no types are available)
+import TransportWebHID, { Transport } from "@ledgerhq/hw-transport-webhid";
+import TransportNodeHidNoEvents from "@ledgerhq/hw-transport-node-hid-noevents";
+
+// Add polyfill for `window.fetch` for agent-js to work.
+// @ts-ignore (no types are available)
+import fetch from "node-fetch";
+global.fetch = fetch;
+
+/**
+ * Convert the HttpAgentRequest body into cbor which can be signed by the Ledger Hardware Wallet.
+ * @param request - body of the HttpAgentRequest
+ */
+function _prepareCborForLedger(
+  request: ReadRequest | CallRequest
+): ArrayBuffer {
+  return Cbor.encode({ content: request });
+}
+
+/**
+ * A Hardware Ledger Internet Computer Agent identity.
+ */
+export class LedgerIdentity extends SignIdentity {
+  // A flag to signal that the next transaction to be signed will be
+  // a "stake neuron" transaction.
+  private _neuronStakeFlag = false;
+
+  /**
+   * Create a LedgerIdentity using the Web USB transport.
+   * @param derivePath The derivation path.
+   */
+  public static async create(
+    derivePath = `m/44'/223'/0'/0/0`
+  ): Promise<LedgerIdentity> {
+    const [app, transport] = await this._connect();
+
+    try {
+      const publicKey = await this._fetchPublicKeyFromDevice(app, derivePath);
+      return new this(derivePath, publicKey);
+    } finally {
+      // Always close the transport.
+      transport.close();
+    }
+  }
+
+  private constructor(
+    public readonly derivePath: string,
+    private readonly _publicKey: Secp256k1PublicKey
+  ) {
+    super();
+  }
+
+  /**
+   * Connect to a ledger hardware wallet.
+   */
+  private static async _connect(): Promise<[LedgerApp, Transport]> {
+    async function getTransport() {
+      if (await TransportWebHID.isSupported()) {
+        // We're in a web browser.
+        return TransportWebHID.create();
+      } else if (await TransportNodeHidNoEvents.isSupported()) {
+        // Maybe we're in a CLI.
+        return TransportNodeHidNoEvents.create();
+      } else {
+        // Unknown environment.
+        throw Error();
+      }
+    }
+
+    try {
+      const transport = await getTransport();
+      const app = new LedgerApp(transport);
+      return [app, transport];
+    } catch (err) {
+      // @ts-ignore
+      if (err.id && err.id == "NoDeviceFound") {
+        throw "No Ledger device found. Is the wallet connected and unlocked?";
+      } else if (
+        // @ts-ignore
+        err.message &&
+        // @ts-ignore
+        err.message.includes("cannot open device with path")
+      ) {
+        throw "Cannot connect to Ledger device. Please close all other wallet applications (e.g. Ledger Live) and try again.";
+      } else {
+        // Unsupported browser. Data on browser compatibility is taken from https://caniuse.com/webhid
+        throw `Cannot connect to Ledger Wallet. Either you have other wallet applications open (e.g. Ledger Live), or your browser doesn't support WebHID, which is necessary to communicate with your Ledger hardware wallet.\n\nSupported browsers:\n* Chrome (Desktop) v89+\n* Edge v89+\n* Opera v76+\n\nError: ${err}`;
+      }
+    }
+  }
+
+  private static async _fetchPublicKeyFromDevice(
+    app: LedgerApp,
+    derivePath: string
+  ): Promise<Secp256k1PublicKey> {
+    const resp = await app.getAddressAndPubKey(derivePath);
+    // @ts-ignore
+    if (resp.returnCode == 28161) {
+      throw "Please open the Internet Computer app on your wallet and try again.";
+    } else if (resp.returnCode == LedgerError.TransactionRejected) {
+      throw "Ledger Wallet is locked. Unlock it and try again.";
+      // @ts-ignore
+    } else if (resp.returnCode == 65535) {
+      throw "Unable to fetch the public key. Please try again.";
+    }
+
+    // This type doesn't have the right fields in it, so we have to manually type it.
+    const principal = (resp as unknown as { principalText: string })
+      .principalText;
+    const publicKey = Secp256k1PublicKey.fromRaw(
+      new Uint8Array(resp.publicKey)
+    );
+
+    if (
+      principal !==
+      Principal.selfAuthenticating(new Uint8Array(publicKey.toDer())).toText()
+    ) {
+      throw new Error(
+        "Principal returned by device does not match public key."
+      );
+    }
+
+    return publicKey;
+  }
+
+  /**
+   * Required by Ledger.com that the user should be able to press a Button in UI
+   * and verify the address/pubkey are the same as on the device screen.
+   */
+  public async showAddressAndPubKeyOnDevice(): Promise<void> {
+    this._executeWithApp(async (app: LedgerApp) => {
+      await app.showAddressAndPubKey(this.derivePath);
+    });
+  }
+
+  /**
+   * @returns The verion of the `Internet Computer' app installed on the Ledger device.
+   */
+  public async getVersion(): Promise<Version> {
+    return this._executeWithApp(async (app: LedgerApp) => {
+      const res = await app.getVersion();
+      return {
+        major: res.major,
+        minor: res.minor,
+        patch: res.patch,
+      };
+    });
+  }
+
+  public getPublicKey(): PublicKey {
+    return this._publicKey;
+  }
+
+  public async sign(blob: ArrayBuffer): Promise<Signature> {
+    console.log("About to sign");
+    console.log(Buffer.from(blob).toString("hex"));
+    return await this._executeWithApp(async (app: LedgerApp) => {
+      const resp: ResponseSign = await app.sign(
+        this.derivePath,
+        Buffer.from(blob),
+        this._neuronStakeFlag ? 1 : 0
+      );
+
+      // Remove the "neuron stake" flag, since we already signed the transaction.
+      this._neuronStakeFlag = false;
+
+      const signatureRS = resp.signatureRS;
+      if (!signatureRS) {
+        throw new Error(
+          `A ledger error happened during signature:\n` +
+            `Code: ${resp.returnCode}\n` +
+            `Message: ${JSON.stringify(resp.errorMessage)}\n`
+        );
+      }
+
+      if (signatureRS?.byteLength !== 64) {
+        throw new Error(
+          `Signature must be 64 bytes long (is ${signatureRS.length})`
+        );
+      }
+
+      return bufferToArrayBuffer(signatureRS) as Signature;
+    });
+  }
+
+  /**
+   * Signals that the upcoming transaction to be signed will be a "stake neuron" transaction.
+   */
+  public flagUpcomingStakeNeuron(): void {
+    this._neuronStakeFlag = true;
+  }
+
+  public async transformRequest(request: HttpAgentRequest): Promise<unknown> {
+    const { body, ...fields } = request;
+    const signature = await this.sign(_prepareCborForLedger(body));
+    return {
+      ...fields,
+      body: {
+        content: body,
+        sender_pubkey: this._publicKey.toDer(),
+        sender_sig: signature,
+      },
+    };
+  }
+
+  private async _executeWithApp<T>(
+    func: (app: LedgerApp) => Promise<T>
+  ): Promise<T> {
+    const [app, transport] = await LedgerIdentity._connect();
+
+    try {
+      // Verify that the public key of the device matches the public key of this identity.
+      const devicePublicKey = await LedgerIdentity._fetchPublicKeyFromDevice(
+        app,
+        this.derivePath
+      );
+      if (JSON.stringify(devicePublicKey) !== JSON.stringify(this._publicKey)) {
+        throw new Error(
+          "Found unexpected public key. Are you sure you're using the right wallet?"
+        );
+      }
+
+      // Run the provided function.
+      return await func(app);
+    } finally {
+      transport.close();
+    }
+  }
+}
+
+interface Version {
+  major: number;
+  minor: number;
+  patch: number;
+}
+
+function bufferToArrayBuffer(buffer: Buffer): ArrayBuffer {
+  return buffer.buffer.slice(
+    buffer.byteOffset,
+    buffer.byteOffset + buffer.byteLength
+  );
+}

package/src/ledger/secp256k1.ts

@@ -0,0 +1,96 @@
+import { DerEncodedPublicKey, PublicKey } from "@dfinity/agent";
+
+function equals(b1: ArrayBuffer, b2: ArrayBuffer): boolean {
+  if (b1.byteLength !== b2.byteLength) {
+    return false;
+  }
+
+  const u1 = new Uint8Array(b1);
+  const u2 = new Uint8Array(b2);
+  for (let i = 0; i < u1.length; i++) {
+    if (u1[i] !== u2[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// This implementation is adjusted from the Ed25519PublicKey.
+// The RAW_KEY_LENGTH and DER_PREFIX are modified accordingly
+export class Secp256k1PublicKey implements PublicKey {
+  public static fromRaw(rawKey: ArrayBuffer): Secp256k1PublicKey {
+    return new Secp256k1PublicKey(rawKey);
+  }
+
+  public static fromDer(derKey: DerEncodedPublicKey): Secp256k1PublicKey {
+    return new Secp256k1PublicKey(this.derDecode(derKey));
+  }
+
+  // The length of secp256k1 public keys is always 65 bytes.
+  private static RAW_KEY_LENGTH = 65;
+
+  // Adding this prefix to a raw public key is sufficient to DER-encode it.
+  // prettier-ignore
+  private static DER_PREFIX = Uint8Array.from([
+    0x30, 0x56, // SEQUENCE
+    0x30, 0x10, // SEQUENCE
+    0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, // OID ECDSA
+    0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x0a, // OID secp256k1
+    0x03, 0x42, // BIT STRING
+    0x00, // no padding
+  ]);
+
+  private static derEncode(publicKey: ArrayBuffer): DerEncodedPublicKey {
+    if (publicKey.byteLength !== Secp256k1PublicKey.RAW_KEY_LENGTH) {
+      const bl = publicKey.byteLength;
+      throw new TypeError(
+        `secp256k1 public key must be ${Secp256k1PublicKey.RAW_KEY_LENGTH} bytes long (is ${bl})`
+      );
+    }
+
+    const derPublicKey = Uint8Array.from([
+      ...Secp256k1PublicKey.DER_PREFIX,
+      ...new Uint8Array(publicKey),
+    ]);
+
+    return derPublicKey.buffer as DerEncodedPublicKey;
+  }
+
+  private static derDecode(key: DerEncodedPublicKey): ArrayBuffer {
+    const expectedLength =
+      Secp256k1PublicKey.DER_PREFIX.length + Secp256k1PublicKey.RAW_KEY_LENGTH;
+    if (key.byteLength !== expectedLength) {
+      const bl = key.byteLength;
+      throw new TypeError(
+        `secp256k1 DER-encoded public key must be ${expectedLength} bytes long (is ${bl})`
+      );
+    }
+
+    const rawKey = key.slice(0, Secp256k1PublicKey.DER_PREFIX.length);
+    if (!equals(this.derEncode(rawKey), key)) {
+      throw new TypeError(
+        "secp256k1 DER-encoded public key is invalid. A valid secp256k1 DER-encoded public key " +
+          `must have the following prefix: ${Secp256k1PublicKey.DER_PREFIX}`
+      );
+    }
+
+    return rawKey;
+  }
+
+  private readonly rawKey: ArrayBuffer;
+  private readonly derKey: DerEncodedPublicKey;
+
+  // `fromRaw` and `fromDer` should be used for instantiation, not this constructor.
+  private constructor(key: ArrayBuffer) {
+    this.rawKey = key;
+    this.derKey = Secp256k1PublicKey.derEncode(key);
+  }
+
+  public toDer(): DerEncodedPublicKey {
+    return this.derKey;
+  }
+
+  public toRaw(): ArrayBuffer {
+    return this.rawKey;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "commonjs",
+    "allowJs": true,
+    "outDir": "./build",
+    "strict": true,
+    "baseUrl": "./",
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  },
+  "include": ["index.ts", "./src"]
+}