Merge pull request #38 from BitGo/BG-41154-sync-bitcoinjs

chore: abstract away number to TNumber

Author: brandonblack

src/block.d.ts

@@ -1,18 +1,18 @@
 /// <reference types="node" />
 import { Transaction } from './transaction';
-export declare class Block {
-    static fromBuffer(buffer: Buffer): Block;
-    static fromHex(hex: string): Block;
+export declare class Block<TNumber extends number | bigint = number> {
+    static fromBuffer<TNumber extends number | bigint = number>(buffer: Buffer, amountType?: 'number' | 'bigint'): Block<TNumber>;
+    static fromHex<TNumber extends number | bigint = number>(hex: string, amountType?: 'number' | 'bigint'): Block<TNumber>;
     static calculateTarget(bits: number): Buffer;
-    static calculateMerkleRoot(transactions: Transaction[], forWitness?: boolean): Buffer;
+    static calculateMerkleRoot<TNumber extends number | bigint = number>(transactions: Array<Transaction<TNumber>>, forWitness?: boolean): Buffer;
     version: number;
     prevHash?: Buffer;
     merkleRoot?: Buffer;
     timestamp: number;
     witnessCommit?: Buffer;
     bits: number;
     nonce: number;
-    transactions?: Transaction[];
+    transactions?: Array<Transaction<TNumber>>;
     getWitnessCommit(): Buffer | null;
     hasWitnessCommit(): boolean;
     hasWitness(): boolean;

src/block.js

@@ -24,7 +24,7 @@ class Block {
     this.nonce = 0;
     this.transactions = undefined;
   }
-  static fromBuffer(buffer) {
+  static fromBuffer(buffer, amountType = 'number') {
     if (buffer.length < 80) throw new Error('Buffer too small (< 80 bytes)');
     const bufferReader = new bufferutils_1.BufferReader(buffer);
     const block = new Block();
@@ -39,6 +39,7 @@ class Block {
       const tx = transaction_1.Transaction.fromBuffer(
         bufferReader.buffer.slice(bufferReader.offset),
         true,
+        amountType,
       );
       bufferReader.offset += tx.byteLength();
       return tx;
@@ -54,8 +55,8 @@ class Block {
     if (witnessCommit) block.witnessCommit = witnessCommit;
     return block;
   }
-  static fromHex(hex) {
-    return Block.fromBuffer(Buffer.from(hex, 'hex'));
+  static fromHex(hex, amountType = 'number') {
+    return Block.fromBuffer(Buffer.from(hex, 'hex'), amountType);
   }
   static calculateTarget(bits) {
     const exponent = ((bits & 0xff000000) >> 24) - 3;

src/bufferutils.d.ts

@@ -1,8 +1,9 @@
 /// <reference types="node" />
 import * as varuint from 'varuint-bitcoin';
 export { varuint };
+export declare function readUInt64BigIntLE(buffer: Buffer, offset: number): bigint;
 export declare function readUInt64LE(buffer: Buffer, offset: number): number;
-export declare function writeUInt64LE(buffer: Buffer, value: number, offset: number): number;
+export declare function writeUInt64LE(buffer: Buffer, value: number | bigint, offset: number): number;
 export declare function reverseBuffer(buffer: Buffer): Buffer;
 export declare function cloneBuffer(buffer: Buffer): Buffer;
 /**
@@ -16,7 +17,7 @@ export declare class BufferWriter {
     writeUInt8(i: number): void;
     writeInt32(i: number): void;
     writeUInt32(i: number): void;
-    writeUInt64(i: number): void;
+    writeUInt64(i: number | bigint): void;
     writeVarInt(i: number): void;
     writeSlice(slice: Buffer): void;
     writeVarSlice(slice: Buffer): void;
@@ -34,6 +35,7 @@ export declare class BufferReader {
     readInt32(): number;
     readUInt32(): number;
     readUInt64(): number;
+    readUInt64BigInt(): bigint;
     readVarInt(): number;
     readSlice(n: number): Buffer;
     readVarSlice(): Buffer;

src/bufferutils.js

@@ -1,32 +1,40 @@
 'use strict';
 Object.defineProperty(exports, '__esModule', { value: true });
-exports.BufferReader = exports.BufferWriter = exports.cloneBuffer = exports.reverseBuffer = exports.writeUInt64LE = exports.readUInt64LE = exports.varuint = void 0;
+exports.BufferReader = exports.BufferWriter = exports.cloneBuffer = exports.reverseBuffer = exports.writeUInt64LE = exports.readUInt64LE = exports.readUInt64BigIntLE = exports.varuint = void 0;
 const types = require('./types');
 const { typeforce } = types;
 const varuint = require('varuint-bitcoin');
 exports.varuint = varuint;
 // https://github.com/feross/buffer/blob/master/index.js#L1127
 function verifuint(value, max) {
-  if (typeof value !== 'number')
-    throw new Error('cannot write a non-number as a number');
+  if (typeof value !== 'number' && typeof value !== 'bigint')
+    throw new Error('cannot write a non-number as a number or bigint');
   if (value < 0)
     throw new Error('specified a negative value for writing an unsigned value');
   if (value > max) throw new Error('RangeError: value out of range');
-  if (Math.floor(value) !== value)
+  if (typeof value === 'number' && Math.floor(value) !== value)
+    // bigint is enforced int
     throw new Error('value has a fractional component');
 }
+function readUInt64BigIntLE(buffer, offset) {
+  return buffer.readBigUInt64LE(offset);
+}
+exports.readUInt64BigIntLE = readUInt64BigIntLE;
 function readUInt64LE(buffer, offset) {
-  const a = buffer.readUInt32LE(offset);
-  let b = buffer.readUInt32LE(offset + 4);
-  b *= 0x100000000;
-  verifuint(b + a, 0x001fffffffffffff);
-  return b + a;
+  const result = readUInt64BigIntLE(buffer, offset);
+  verifuint(result, 0x001fffffffffffff);
+  return Number(result);
 }
 exports.readUInt64LE = readUInt64LE;
 function writeUInt64LE(buffer, value, offset) {
-  verifuint(value, 0x001fffffffffffff);
-  buffer.writeInt32LE(value & -1, offset);
-  buffer.writeUInt32LE(Math.floor(value / 0x100000000), offset + 4);
+  if (typeof value === 'number') {
+    verifuint(value, 0x001fffffffffffff);
+  } else if (typeof value === 'bigint') {
+    verifuint(value, BigInt('0xffffffffffffffff'));
+  } else {
+    throw new Error('value must be a number or bigint');
+  }
+  buffer.writeBigUInt64LE(BigInt(value), offset);
   return offset + 8;
 }
 exports.writeUInt64LE = writeUInt64LE;
@@ -128,6 +136,11 @@ class BufferReader {
     this.offset += 8;
     return result;
   }
+  readUInt64BigInt() {
+    const result = readUInt64BigIntLE(this.buffer, this.offset);
+    this.offset += 8;
+    return result;
+  }
   readVarInt() {
     const vi = varuint.decode(this.buffer, this.offset);
     this.offset += varuint.decode.bytes;

src/transaction.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
-export interface Output {
+export interface Output<TNumber extends number | bigint = number> {
     script: Buffer;
-    value: number;
+    value: TNumber;
 }
 export interface Input {
     hash: Buffer;
@@ -10,7 +10,7 @@ export interface Input {
     sequence: number;
     witness: Buffer[];
 }
-export declare class Transaction {
+export declare class Transaction<TNumber extends number | bigint = number> {
     static readonly DEFAULT_SEQUENCE = 4294967295;
     static readonly SIGHASH_DEFAULT = 0;
     static readonly SIGHASH_ALL = 1;
@@ -21,21 +21,21 @@ export declare class Transaction {
     static readonly SIGHASH_INPUT_MASK = 128;
     static readonly ADVANCED_TRANSACTION_MARKER = 0;
     static readonly ADVANCED_TRANSACTION_FLAG = 1;
-    static fromBuffer(buffer: Buffer, _NO_STRICT?: boolean): Transaction;
-    static fromHex(hex: string): Transaction;
+    static fromBuffer<TNumber extends number | bigint = number>(buffer: Buffer, _NO_STRICT?: boolean, amountType?: 'number' | 'bigint'): Transaction<TNumber>;
+    static fromHex<TNumber extends number | bigint = number>(hex: string, amountType?: 'number' | 'bigint'): Transaction<TNumber>;
     static isCoinbaseHash(buffer: Buffer): boolean;
     version: number;
     locktime: number;
     ins: Input[];
-    outs: Output[];
+    outs: Array<Output<TNumber>>;
     isCoinbase(): boolean;
     addInput(hash: Buffer, index: number, sequence?: number, scriptSig?: Buffer): number;
-    addOutput(scriptPubKey: Buffer, value: number): number;
+    addOutput(scriptPubKey: Buffer, value: TNumber): number;
     hasWitnesses(): boolean;
     weight(): number;
     virtualSize(): number;
     byteLength(_ALLOW_WITNESS?: boolean): number;
-    clone(): Transaction;
+    clone(): Transaction<TNumber>;
     /**
      * Hash transaction for signing a specific input.
      *
@@ -45,8 +45,8 @@ export declare class Transaction {
      * This hash can then be used to sign the provided transaction input.
      */
     hashForSignature(inIndex: number, prevOutScript: Buffer, hashType: number): Buffer;
-    hashForWitnessV1(inIndex: number, prevOutScripts: Buffer[], values: number[], hashType: number, leafHash?: Buffer, annex?: Buffer): Buffer;
-    hashForWitnessV0(inIndex: number, prevOutScript: Buffer, value: number, hashType: number): Buffer;
+    hashForWitnessV1(inIndex: number, prevOutScripts: Buffer[], values: TNumber[], hashType: number, leafHash?: Buffer, annex?: Buffer): Buffer;
+    hashForWitnessV0(inIndex: number, prevOutScript: Buffer, value: TNumber, hashType: number): Buffer;
     getHash(forWitness?: boolean): Buffer;
     getId(): string;
     toBuffer(buffer?: Buffer, initialOffset?: number): Buffer;

src/transaction.js

@@ -45,7 +45,7 @@ class Transaction {
     this.ins = [];
     this.outs = [];
   }
-  static fromBuffer(buffer, _NO_STRICT) {
+  static fromBuffer(buffer, _NO_STRICT, amountType = 'number') {
     const bufferReader = new bufferutils_1.BufferReader(buffer);
     const tx = new Transaction();
     tx.version = bufferReader.readInt32();
@@ -73,7 +73,10 @@ class Transaction {
     const voutLen = bufferReader.readVarInt();
     for (let i = 0; i < voutLen; ++i) {
       tx.outs.push({
-        value: bufferReader.readUInt64(),
+        value:
+          amountType === 'number'
+            ? bufferReader.readUInt64()
+            : bufferReader.readUInt64BigInt(),
         script: bufferReader.readVarSlice(),
       });
     }
@@ -91,8 +94,8 @@ class Transaction {
       throw new Error('Transaction has unexpected data');
     return tx;
   }
-  static fromHex(hex) {
-    return Transaction.fromBuffer(Buffer.from(hex, 'hex'), false);
+  static fromHex(hex, amountType = 'number') {
+    return Transaction.fromBuffer(Buffer.from(hex, 'hex'), false, amountType);
   }
   static isCoinbaseHash(buffer) {
     typeforce(types.Hash256bit, buffer);

src/types.d.ts

@@ -7,7 +7,7 @@ export declare namespace BIP32Path {
     var toJSON: () => string;
 }
 export declare function Signer(obj: any): boolean;
-export declare function Satoshi(value: number): boolean;
+export declare function Satoshi(value: number | bigint): boolean;
 export declare const ECPoint: any;
 export declare const Network: any;
 export interface XOnlyPointAddTweakResult {

src/types.js

@@ -48,8 +48,12 @@ function Signer(obj) {
 }
 exports.Signer = Signer;
 const SATOSHI_MAX = 21 * 1e14;
+const BIG_SATOSHI_MAX = BigInt('1000000000000000000');
 function Satoshi(value) {
-  return exports.typeforce.UInt53(value) && value <= SATOSHI_MAX;
+  return (
+    (exports.typeforce.UInt53(value) && value <= SATOSHI_MAX) ||
+    (typeof value === 'bigint' && value >= 0 && value <= BIG_SATOSHI_MAX)
+  );
 }
 exports.Satoshi = Satoshi;
 // external dependent types

test/bufferutils.spec.ts

@@ -32,6 +32,19 @@ describe('bufferutils', () => {
     });
   });
 
+  describe('readUInt64BigIntLE', () => {
+    const checkValid = (f: { dec: string | number; hex: string }): void => {
+      it('decodes ' + f.hex, () => {
+        const buffer = Buffer.from(f.hex, 'hex');
+        const num = bufferutils.readUInt64BigIntLE(buffer, 0);
+
+        assert.strictEqual(num, BigInt(f.dec));
+      });
+    };
+    fixtures.valid.forEach(checkValid);
+    fixtures.validBigInt.forEach(checkValid);
+  });
+
   describe('writeUInt64LE', () => {
     fixtures.valid.forEach(f => {
       it('encodes ' + f.dec, () => {
@@ -53,6 +66,29 @@ describe('bufferutils', () => {
     });
   });
 
+  describe('writeUInt64BigIntLE', () => {
+    const checkValid = (f: { dec: string | number; hex: string }): void => {
+      it('encodes ' + f.dec, () => {
+        const buffer = Buffer.alloc(8, 0);
+
+        bufferutils.writeUInt64LE(buffer, BigInt(f.dec), 0);
+        assert.strictEqual(buffer.toString('hex'), f.hex);
+      });
+    };
+    fixtures.valid.forEach(checkValid);
+    fixtures.validBigInt.forEach(checkValid);
+
+    fixtures.invalid.writeUInt64BigIntLE.forEach(f => {
+      it('throws on ' + f.description, () => {
+        const buffer = Buffer.alloc(8, 0);
+
+        assert.throws(() => {
+          bufferutils.writeUInt64LE(buffer, BigInt(f.dec), 0);
+        }, new RegExp(f.exception));
+      });
+    });
+  });
+
   describe('BufferWriter', () => {
     function testBuffer(
       bufferWriter: BufferWriter,

test/fixtures/bufferutils.json

@@ -57,6 +57,20 @@
       "hex": "ffffffffffff1f00"
     }
   ],
+  "validBigInt": [
+    {
+      "dec": "9223372036854775808",
+      "hex": "0000000000000080"
+    },
+    {
+      "dec": "1000000000000000000",
+      "hex": "000064a7b3b6e00d"
+    },
+    {
+      "dec": "18446744073709551615",
+      "hex": "ffffffffffffffff"
+    }
+  ],
   "invalid": {
     "readUInt64LE": [
       {
@@ -97,6 +111,26 @@
         "hex": "",
         "dec": 0.1
       }
+    ],
+    "writeUInt64BigIntLE": [
+      {
+        "description": "n === 2^64",
+        "exception": "RangeError: value out of range",
+        "hex": "000000000000000001",
+        "dec": "18446744073709551616"
+      },
+      {
+        "description": "n > 2^64",
+        "exception": "RangeError: value out of range",
+        "hex": "ff0000000000000001",
+        "dec": "18446744073709551871"
+      },
+      {
+        "description": "n < 0",
+        "exception": "specified a negative value for writing an unsigned value",
+        "hex": "",
+        "dec": "-1"
+      }
     ]
   }
 }