@ledgerhq/psbtv2 0.1.0

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@ledgerhq/psbtv2",
+  "version": "0.1.0",
+  "description": "Partially Signed Bitcoin Transaction version 2 (BIP370) implementation",
+  "keywords": [
+    "Ledger",
+    "Bitcoin",
+    "PSBT",
+    "BIP370",
+    "BIP174"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LedgerHQ/ledger-live.git"
+  },
+  "bugs": {
+    "url": "https://github.com/LedgerHQ/ledger-live/issues"
+  },
+  "homepage": "https://github.com/LedgerHQ/ledger-live/tree/develop/libs/psbtv2",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "lib/index.js",
+  "module": "lib-es/index.js",
+  "types": "lib/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "lib/*": [
+        "lib/*"
+      ],
+      "lib-es/*": [
+        "lib-es/*"
+      ],
+      "*": [
+        "lib/*"
+      ]
+    }
+  },
+  "exports": {
+    "./lib/*": "./lib/*.js",
+    "./lib-es/*": "./lib-es/*.js",
+    "./*": {
+      "require": "./lib/*.js",
+      "default": "./lib-es/*.js"
+    },
+    ".": {
+      "require": "./lib/index.js",
+      "default": "./lib-es/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "bitcoinjs-lib": "^5.2.0",
+    "varuint-bitcoin": "1.1.2"
+  },
+  "devDependencies": {
+    "@types/jest": "30.0.0",
+    "@types/node": "^22.10.10",
+    "@swc/core": "1.15.8",
+    "@swc/jest": "0.2.39",
+    "jest": "30.2.0",
+    "rimraf": "^4.4.1",
+    "typescript": "^5.4.3"
+  },
+  "scripts": {
+    "clean": "rimraf lib lib-es",
+    "build": "tsc && tsc -m esnext --moduleResolution bundler --outDir lib-es",
+    "prewatch": "pnpm build",
+    "watch": "tsc --watch",
+    "watch:es": "tsc --watch -m esnext --moduleResolution bundler --outDir lib-es",
+    "lint": "eslint ./src --no-error-on-unmatched-pattern --ext .ts,.tsx --cache",
+    "lint:fix": "pnpm lint --fix",
+    "test": "jest",
+    "coverage": "jest --coverage",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/buffertools.test.ts

@@ -0,0 +1,116 @@
+import { BufferReader, BufferWriter, unsafeFrom64bitLE, unsafeTo64bitLE } from "./buffertools";
+
+describe("buffertools", () => {
+  describe("unsafeTo64bitLE", () => {
+    it("should roundtrip values within safe range", () => {
+      const value = Number.MAX_SAFE_INTEGER - 1;
+      const buf = unsafeTo64bitLE(value);
+      expect(buf).toHaveLength(8);
+      const back = unsafeFrom64bitLE(buf);
+      expect(back).toBe(value);
+    });
+
+    it("should throw for numbers greater than MAX_SAFE_INT", () => {
+      const above = Number.MAX_SAFE_INTEGER + 1;
+      expect(() => unsafeTo64bitLE(above)).toThrow("Can't convert numbers > MAX_SAFE_INT");
+    });
+  });
+
+  describe("unsafeFrom64bitLE", () => {
+    it("should throw if buffer length is not 8", () => {
+      expect(() => unsafeFrom64bitLE(Buffer.alloc(4))).toThrow("Expected Buffer of length 8");
+    });
+
+    it("should throw if highest byte is non-zero", () => {
+      const buf = Buffer.alloc(8, 0);
+      buf[7] = 1;
+      expect(() => unsafeFrom64bitLE(buf)).toThrow("Can't encode numbers > MAX_SAFE_INT");
+    });
+
+    it("should throw if second-highest byte exceeds 0x1f", () => {
+      const buf = Buffer.alloc(8, 0);
+      buf[6] = 0x20;
+      expect(() => unsafeFrom64bitLE(buf)).toThrow("Can't encode numbers > MAX_SAFE_INT");
+    });
+  });
+
+  describe("BufferReader", () => {
+    it("should throw when readSlice goes out of bounds", () => {
+      const reader = new BufferReader(Buffer.alloc(2));
+      reader.readSlice(2);
+      expect(() => reader.readSlice(1)).toThrow("Cannot read slice out of bounds");
+    });
+
+    it("should read and write vectors correctly with BufferWriter", () => {
+      const writer = new BufferWriter();
+      const elements = [Buffer.from("aa", "hex"), Buffer.from("bbbb", "hex")];
+
+      writer.writeVarInt(elements.length);
+      for (const el of elements) {
+        writer.writeVarSlice(el);
+      }
+
+      const buf = writer.buffer();
+      const reader = new BufferReader(buf);
+      const vector = reader.readVector();
+
+      expect(vector).toHaveLength(elements.length);
+      expect(vector[0]).toEqual(elements[0]);
+      expect(vector[1]).toEqual(elements[1]);
+    });
+
+    it("should support basic integer and slice read/write helpers", () => {
+      const writer = new BufferWriter();
+
+      writer.writeUInt8(0x12);
+      writer.writeInt32(-42);
+      writer.writeUInt32(0xdeadbeef);
+      writer.writeUInt64(123456789);
+      writer.writeVarInt(3);
+      writer.writeSlice(Buffer.from("abcd", "hex"));
+      writer.writeVarSlice(Buffer.from("ef", "hex"));
+
+      const buf = writer.buffer();
+      const reader = new BufferReader(buf);
+
+      expect(reader.readUInt8()).toBe(0x12);
+      expect(reader.readInt32()).toBe(-42);
+      expect(reader.readUInt32()).toBe(0xdeadbeef);
+      expect(reader.readUInt64()).toBe(123456789);
+
+      const vi = reader.readVarInt();
+      expect(vi).toBe(3);
+
+      const slice = reader.readSlice(2);
+      expect(slice.toString("hex")).toBe("abcd");
+
+      const varSlice = reader.readVarSlice();
+      expect(varSlice.toString("hex")).toBe("ef");
+    });
+  });
+
+  // Copied from the old test suite
+  function run(n: number, expectedHex: string) {
+    const w = new BufferWriter();
+    w.writeUInt64(n);
+    expect(w.buffer()).toEqual(Buffer.from(expectedHex, "hex"));
+    const r = new BufferReader(w.buffer());
+    expect(r.readUInt64()).toEqual(n);
+  }
+
+  test("Test 64 bit numbers", () => {
+    run(0, "0000000000000000");
+    run(1, "0100000000000000");
+    run(0xffffffff, "ffffffff00000000");
+    run(0x0100000000, "0000000001000000");
+    run(0x010203040506, "0605040302010000");
+    run(Number.MAX_SAFE_INTEGER, "FFFFFFFFFFFF1F00");
+  });
+
+  test("Too big 64 bit number", () => {
+    const w = new BufferWriter();
+    expect(() => w.writeUInt64(Number.MAX_SAFE_INTEGER + 1)).toThrow();
+    const r = new BufferReader(Buffer.from("FFFFFFFFFFFF2000", "hex"));
+    expect(() => r.readUInt64()).toThrow();
+  });
+});

package/src/buffertools.ts

@@ -0,0 +1,137 @@
+import varuint from "varuint-bitcoin";
+
+export function unsafeTo64bitLE(n: number): Buffer {
+  // we want to represent the input as a 8-bytes array
+  if (n > Number.MAX_SAFE_INTEGER) {
+    throw new Error("Can't convert numbers > MAX_SAFE_INT");
+  }
+  const byteArray = Buffer.alloc(8, 0);
+  for (let index = 0; index < byteArray.length; index++) {
+    const byte = n & 0xff;
+    byteArray[index] = byte;
+    n = (n - byte) / 256;
+  }
+  return byteArray;
+}
+
+export function unsafeFrom64bitLE(byteArray: Buffer): number {
+  let value = 0;
+  if (byteArray.length != 8) {
+    throw new Error("Expected Buffer of length 8");
+  }
+  if (byteArray[7] != 0) {
+    throw new Error("Can't encode numbers > MAX_SAFE_INT");
+  }
+  if (byteArray[6] > 0x1f) {
+    throw new Error("Can't encode numbers > MAX_SAFE_INT");
+  }
+  for (let i = byteArray.length - 1; i >= 0; i--) {
+    value = value * 256 + byteArray[i];
+  }
+  return value;
+}
+
+export class BufferWriter {
+  private readonly bufs: Buffer[] = [];
+
+  write(alloc: number, fn: (b: Buffer) => void): void {
+    const b = Buffer.alloc(alloc);
+    fn(b);
+    this.bufs.push(b);
+  }
+
+  writeUInt8(i: number): void {
+    this.write(1, b => b.writeUInt8(i, 0));
+  }
+
+  writeInt32(i: number): void {
+    this.write(4, b => b.writeInt32LE(i, 0));
+  }
+
+  writeUInt32(i: number): void {
+    this.write(4, b => b.writeUInt32LE(i, 0));
+  }
+
+  writeUInt64(i: number): void {
+    const bytes = unsafeTo64bitLE(i);
+    this.writeSlice(bytes);
+  }
+
+  writeVarInt(i: number): void {
+    this.bufs.push(varuint.encode(i));
+  }
+
+  writeSlice(slice: Buffer): void {
+    this.bufs.push(Buffer.from(slice));
+  }
+
+  writeVarSlice(slice: Buffer): void {
+    this.writeVarInt(slice.length);
+    this.writeSlice(slice);
+  }
+
+  buffer(): Buffer {
+    return Buffer.concat(this.bufs);
+  }
+}
+
+export class BufferReader {
+  constructor(
+    public buffer: Buffer,
+    public offset: number = 0,
+  ) {}
+
+  available(): number {
+    return this.buffer.length - this.offset;
+  }
+
+  readUInt8(): number {
+    const result = this.buffer.readUInt8(this.offset);
+    this.offset++;
+    return result;
+  }
+
+  readInt32(): number {
+    const result = this.buffer.readInt32LE(this.offset);
+    this.offset += 4;
+    return result;
+  }
+
+  readUInt32(): number {
+    const result = this.buffer.readUInt32LE(this.offset);
+    this.offset += 4;
+    return result;
+  }
+
+  readUInt64(): number {
+    const buf = this.readSlice(8);
+    const n = unsafeFrom64bitLE(buf);
+    return n;
+  }
+
+  readVarInt(): number {
+    const vi = varuint.decode(this.buffer, this.offset);
+    this.offset += varuint.decode.bytes;
+    return vi;
+  }
+
+  readSlice(n: number): Buffer {
+    if (this.buffer.length < this.offset + n) {
+      throw new Error("Cannot read slice out of bounds");
+    }
+    const result = this.buffer.slice(this.offset, this.offset + n);
+    this.offset += n;
+    return result;
+  }
+
+  readVarSlice(): Buffer {
+    return this.readSlice(this.readVarInt());
+  }
+
+  readVector(): Buffer[] {
+    const count = this.readVarInt();
+    const vector: Buffer[] = [];
+    for (let i = 0; i < count; i++) vector.push(this.readVarSlice());
+    return vector;
+  }
+}