Enforce bigint for all script numbers and bch amounts

- Use `bigint` rather than `number` for all instances of "script numbers"
  (e.g. function arguments) and satoshi amounts`
- Replace `contract.getRedeemScriptHex()` with `contract.bytecode`
- Update UTXO selection to use bigint (multiplied by 1e6 for "decimal points")

Author: rkalis

packages/cashscript/src/Argument.ts

@@ -10,7 +10,7 @@ import {
 import { TypeError } from './Errors.js';
 import SignatureTemplate from './SignatureTemplate.js';
 
-export type Argument = number | bigint | boolean | string | Uint8Array | SignatureTemplate;
+export type Argument = bigint | boolean | string | Uint8Array | SignatureTemplate;
 
 export function encodeArgument(
   argument: Argument,
@@ -26,7 +26,7 @@ export function encodeArgument(
   }
 
   if (type === PrimitiveType.INT) {
-    if (typeof argument !== 'number' && typeof argument !== 'bigint') {
+    if (typeof argument !== 'bigint') {
       throw new TypeError(typeof argument, type);
     }
     return encodeInt(argument);

packages/cashscript/src/Contract.ts

@@ -22,6 +22,7 @@ import { ElectrumNetworkProvider } from './network/index.js';
 export class Contract {
   name: string;
   address: string;
+  bytecode: string;
   bytesize: number;
   opcount: number;
 
@@ -74,23 +75,20 @@ export class Contract {
 
     this.name = artifact.contractName;
     this.address = scriptToAddress(this.redeemScript, this.provider.network);
+    this.bytecode = binToHex(scriptToBytecode(this.redeemScript));
     this.bytesize = calculateBytesize(this.redeemScript);
     this.opcount = countOpcodes(this.redeemScript);
   }
 
-  async getBalance(): Promise<number> {
+  async getBalance(): Promise<bigint> {
     const utxos = await this.getUtxos();
-    return utxos.reduce((acc, utxo) => acc + utxo.satoshis, 0);
+    return utxos.reduce((acc, utxo) => acc + utxo.satoshis, BigInt(0));
   }
 
   async getUtxos(): Promise<Utxo[]> {
     return this.provider.getUtxos(this.address);
   }
 
-  getRedeemScriptHex(): string {
-    return binToHex(scriptToBytecode(this.redeemScript));
-  }
-
   private createFunction(abiFunction: AbiFunction, selector?: number): ContractFunction {
     return (...args: Argument[]) => {
       if (abiFunction.inputs.length !== args.length) {

packages/cashscript/src/Errors.ts

@@ -8,7 +8,7 @@ export class TypeError extends Error {
 }
 
 export class OutputSatoshisTooSmallError extends Error {
-  constructor(satoshis: number) {
+  constructor(satoshis: bigint) {
     super(`Tried to add an output with ${satoshis} satoshis, which is less than the DUST limit (${DUST_LIMIT})`);
   }
 }

packages/cashscript/src/Transaction.ts

@@ -36,6 +36,7 @@ import {
   addressToLockScript,
   createSighashPreimage,
   validateRecipient,
+  utxoComparator,
 } from './utils.js';
 import { P2SH_OUTPUT_SIZE, DUST_LIMIT } from './constants.js';
 import NetworkProvider from './network/NetworkProvider.js';
@@ -49,9 +50,9 @@ export class Transaction {
 
   private sequence = 0xfffffffe;
   private locktime: number;
-  private hardcodedFee: number;
-  private feePerByte = 1.0;
-  private minChange = DUST_LIMIT;
+  private feePerByte: number = 1.0;
+  private hardcodedFee: bigint;
+  private minChange: bigint = DUST_LIMIT;
 
   constructor(
     private address: string,
@@ -90,11 +91,11 @@ export class Transaction {
     return this;
   }
 
-  to(to: string, amount: number): this;
+  to(to: string, amount: bigint): this;
   to(outputs: Recipient[]): this;
 
-  to(toOrOutputs: string | Recipient[], amount?: number): this {
-    if (typeof toOrOutputs === 'string' && typeof amount === 'number') {
+  to(toOrOutputs: string | Recipient[], amount?: bigint): this {
+    if (typeof toOrOutputs === 'string' && typeof amount === 'bigint') {
       return this.to([{ to: toOrOutputs, amount }]);
     }
 
@@ -122,7 +123,7 @@ export class Transaction {
     return this;
   }
 
-  withHardcodedFee(hardcodedFee: number): this {
+  withHardcodedFee(hardcodedFee: bigint): this {
     this.hardcodedFee = hardcodedFee;
     return this;
   }
@@ -132,13 +133,13 @@ export class Transaction {
     return this;
   }
 
-  withMinChange(minChange: number): this {
+  withMinChange(minChange: bigint): this {
     this.minChange = minChange;
     return this;
   }
 
   withoutChange(): this {
-    return this.withMinChange(Number.MAX_VALUE);
+    return this.withMinChange(BigInt(Number.MAX_VALUE));
   }
 
   async build(): Promise<string> {
@@ -160,7 +161,7 @@ export class Transaction {
         ? addressToLockScript(output.to)
         : output.to;
 
-      const satoshis = bigIntToBinUint64LE(BigInt(output.amount));
+      const satoshis = bigIntToBinUint64LE(output.amount);
 
       return { lockingBytecode, satoshis };
     });
@@ -294,35 +295,38 @@ export class Transaction {
     // Add one extra byte per input to over-estimate tx-in count
     const inputSize = getInputSize(placeholderScript) + 1;
 
+    // Note that we use the addPrecision function to add "decimal points" to BigInt numbers
+
     // Calculate amount to send and base fee (excluding additional fees per UTXO)
-    const amount = this.outputs.reduce((acc, output) => acc + output.amount, 0);
-    let fee = this.hardcodedFee ?? getTxSizeWithoutInputs(this.outputs) * this.feePerByte;
+    let amount = addPrecision(this.outputs.reduce((acc, output) => acc + output.amount, BigInt(0)));
+    let fee = addPrecision(this.hardcodedFee ?? getTxSizeWithoutInputs(this.outputs) * this.feePerByte);
 
     // Select and gather UTXOs and calculate fees and available funds
-    let satsAvailable = 0;
+    let satsAvailable = BigInt(0);
     if (this.inputs.length > 0) {
-      // If inputs are already defined, the user provided the UTXOs
-      // and we perform no further UTXO selection
-      if (!this.hardcodedFee) fee += this.inputs.length * inputSize * this.feePerByte;
-      satsAvailable = this.inputs.reduce((acc, input) => acc + input.satoshis, 0);
+      // If inputs are already defined, the user provided the UTXOs and we perform no further UTXO selection
+      if (!this.hardcodedFee) fee += addPrecision(this.inputs.length * inputSize * this.feePerByte);
+      satsAvailable = addPrecision(this.inputs.reduce((acc, input) => acc + input.satoshis, BigInt(0)));
     } else {
       // If inputs are not defined yet, we retrieve the contract's UTXOs and perform selection
       const utxos = await this.provider.getUtxos(this.address);
 
       // We sort the UTXOs mainly so there is consistent behaviour between network providers
       // even if they report UTXOs in a different order
-      utxos.sort((a, b) => b.satoshis - a.satoshis);
+      utxos.sort(utxoComparator).reverse();
 
       for (const utxo of utxos) {
         this.inputs.push(utxo);
-        satsAvailable += utxo.satoshis;
-        if (!this.hardcodedFee) fee += inputSize * this.feePerByte;
+        satsAvailable += addPrecision(utxo.satoshis);
+        if (!this.hardcodedFee) fee += addPrecision(inputSize * this.feePerByte);
         if (satsAvailable > amount + fee) break;
       }
     }
 
-    // Fee per byte can be a decimal number, but we need the total fee to be an integer
-    fee = Math.ceil(fee);
+    // Remove "decimal points" from BigInt numbers (rounding up for fee, down for others)
+    satsAvailable = removePrecisionFloor(satsAvailable);
+    amount = removePrecisionFloor(amount);
+    fee = removePrecisionCeil(fee);
 
     // Calculate change and check available funds
     let change = satsAvailable - amount - fee;
@@ -331,9 +335,9 @@ export class Transaction {
       throw new Error(`Insufficient funds: available (${satsAvailable}) < needed (${amount + fee}).`);
     }
 
-    // Account for the fee of a change output
+    // Account for the fee of adding a change output
     if (!this.hardcodedFee) {
-      change -= P2SH_OUTPUT_SIZE;
+      change -= BigInt(P2SH_OUTPUT_SIZE * this.feePerByte);
     }
 
     // Add a change output if applicable
@@ -342,3 +346,25 @@ export class Transaction {
     }
   }
 }
+
+// Note: the below is a very simple implementation of a "decimal point" system for BigInt numbers
+// It is safe to use for UTXO fee calculations due to its low numbers, but should not be used for other purposes
+// Also note that multiplication and division between two "decimal" bigints is not supported
+
+// High precision may not work with some 'number' inputs, so we set the default to 6 "decimal places"
+const addPrecision = (amount: number | bigint, precision: number = 6): bigint => {
+  if (typeof amount === 'number') {
+    return BigInt(Math.ceil(amount * 10 ** precision));
+  }
+
+  return amount * BigInt(10 ** precision);
+};
+
+const removePrecisionFloor = (amount: bigint, precision: number = 6): bigint => (
+  amount / (BigInt(10) ** BigInt(precision))
+);
+
+const removePrecisionCeil = (amount: bigint, precision: number = 6): bigint => {
+  const multiplier = BigInt(10) ** BigInt(precision);
+  return (amount + multiplier - BigInt(1)) / multiplier;
+};

packages/cashscript/src/constants.ts

@@ -1,4 +1,4 @@
-export const DUST_LIMIT = 546;
+export const DUST_LIMIT = BigInt(546);
 export const P2PKH_OUTPUT_SIZE = 34;
 export const P2SH_OUTPUT_SIZE = 32;
 export const VERSION_SIZE = 4;

packages/cashscript/src/index.ts

@@ -16,7 +16,6 @@ export {
 export * from './Errors.js';
 export {
   NetworkProvider,
-  BitboxNetworkProvider,
   BitcoinRpcNetworkProvider,
   ElectrumNetworkProvider,
   FullStackNetworkProvider,

packages/cashscript/src/interfaces.ts

@@ -4,7 +4,7 @@ import type SignatureTemplate from './SignatureTemplate.js';
 export interface Utxo {
   txid: string;
   vout: number;
-  satoshis: number;
+  satoshis: bigint;
 }
 
 export interface SignableUtxo extends Utxo {
@@ -17,12 +17,12 @@ export function isSignableUtxo(utxo: Utxo): utxo is SignableUtxo {
 
 export interface Recipient {
   to: string;
-  amount: number;
+  amount: bigint;
 }
 
 export interface Output {
   to: string | Uint8Array;
-  amount: number;
+  amount: bigint;
 }
 
 export enum SignatureAlgorithm {

packages/cashscript/src/network/BitboxNetworkProvider.ts

@@ -20,7 +20,7 @@ export default class BitcoinRpcNetworkProvider implements NetworkProvider {
     const utxos = result.map((utxo) => ({
       txid: utxo.txid,
       vout: utxo.vout,
-      satoshis: utxo.amount * 1e8,
+      satoshis: BigInt(utxo.amount * 1e8),
     }));
 
     return utxos;

packages/cashscript/src/network/BitcoinRpcNetworkProvider.ts

@@ -61,16 +61,14 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
     const utxos = result.map((utxo) => ({
       txid: utxo.tx_hash,
       vout: utxo.tx_pos,
-      satoshis: utxo.value,
-      height: utxo.height,
+      satoshis: BigInt(utxo.value),
     }));
 
     return utxos;
   }
 
   async getBlockHeight(): Promise<number> {
     const { height } = await this.performRequest('blockchain.headers.subscribe') as BlockHeader;
-
     return height;
   }
 

packages/cashscript/src/network/ElectrumNetworkProvider.ts

@@ -21,8 +21,7 @@ export default class FullStackNetworkProvider implements NetworkProvider {
     const utxos = (result.utxos ?? []).map((utxo: ElectrumUtxo) => ({
       txid: utxo.tx_hash,
       vout: utxo.tx_pos,
-      satoshis: utxo.value,
-      height: utxo.height,
+      satoshis: BigInt(utxo.value),
     }));
 
     return utxos;
@@ -33,7 +32,7 @@ export default class FullStackNetworkProvider implements NetworkProvider {
   }
 
   async getRawTransaction(txid: string): Promise<string> {
-    return this.bchjs.RawTransactions.getRawTransaction(txid) as Promise<string>;
+    return this.bchjs.RawTransactions.getRawTransaction(txid);
   }
 
   async sendRawTransaction(txHex: string): Promise<string> {

packages/cashscript/src/network/FullStackNetworkProvider.ts

@@ -1,5 +1,4 @@
 export { default as NetworkProvider } from './NetworkProvider.js';
-export { default as BitboxNetworkProvider } from './BitboxNetworkProvider.js';
 export { default as BitcoinRpcNetworkProvider } from './BitcoinRpcNetworkProvider.js';
 export { default as ElectrumNetworkProvider } from './ElectrumNetworkProvider.js';
 export { default as FullStackNetworkProvider } from './FullStackNetworkProvider.js';