ecash-lib 2.1.0 → 3.0.0

package/src/token/slp.ts

@@ -7,7 +7,7 @@ import { strToBytes } from '../io/str.js';
 import { Op, pushBytesOp } from '../op.js';
 import { OP_PUSHDATA1, OP_RETURN } from '../opcode.js';
 import { Script } from '../script.js';
-import { Amount, BURN, GENESIS, GenesisInfo, MINT, SEND } from './common.js';
+import { BURN, GENESIS, GenesisInfo, MINT, SEND } from './common.js';
 
 /** LOKAD ID for SLP */
 export const SLP_LOKAD_ID = strToBytes('SLP\0');
@@ -25,7 +25,7 @@ export const SLP_NFT1_GROUP = 0x81;
 export function slpGenesis(
     tokenType: number,
     genesisInfo: GenesisInfo,
-    initialQuantity: Amount,
+    initialQuantity: bigint,
     mintBatonOutIdx?: number,
 ): Script {
     verifyTokenType(tokenType);
@@ -53,7 +53,7 @@ export function slpGenesis(
             data.push(new Uint8Array());
         }
     }
-    data.push(slpAmount(initialQuantity));
+    data.push(slpAtoms(initialQuantity));
     return Script.fromOps([OP_RETURN as Op].concat(data.map(pushdataOpSlp)));
 }
 
@@ -64,7 +64,7 @@ export function slpGenesis(
 export function slpMint(
     tokenId: string,
     tokenType: number,
-    additionalQuantity: Amount,
+    additionalAtoms: bigint,
     mintBatonOutIdx?: number,
 ): Script {
     verifyTokenType(tokenType);
@@ -80,7 +80,7 @@ export function slpMint(
                 mintBatonOutIdx !== undefined ? [mintBatonOutIdx] : [],
             ),
         ),
-        pushdataOpSlp(slpAmount(additionalQuantity)),
+        pushdataOpSlp(slpAtoms(additionalAtoms)),
     ]);
 }
 
@@ -90,10 +90,10 @@ export function slpMint(
  **/
 export function slpMintVault(
     tokenId: string,
-    additionalQuantities: Amount[],
+    additionalAtomsArray: bigint[],
 ): Script {
     verifyTokenId(tokenId);
-    verifySendAmounts(additionalQuantities);
+    verifySendAtomsArray(additionalAtomsArray);
     return Script.fromOps(
         [
             OP_RETURN,
@@ -102,7 +102,7 @@ export function slpMintVault(
             pushdataOpSlp(MINT),
             pushdataOpSlp(fromHex(tokenId)),
         ].concat(
-            additionalQuantities.map(qty => pushdataOpSlp(slpAmount(qty))),
+            additionalAtomsArray.map(atoms => pushdataOpSlp(slpAtoms(atoms))),
         ),
     );
 }
@@ -113,11 +113,11 @@ export function slpMintVault(
 export function slpSend(
     tokenId: string,
     tokenType: number,
-    sendAmounts: Amount[],
+    sendAtomsArray: bigint[],
 ): Script {
     verifyTokenType(tokenType);
     verifyTokenId(tokenId);
-    verifySendAmounts(sendAmounts);
+    verifySendAtomsArray(sendAtomsArray);
     return Script.fromOps(
         [
             OP_RETURN,
@@ -125,7 +125,7 @@ export function slpSend(
             pushdataOpSlp(new Uint8Array([tokenType])),
             pushdataOpSlp(SEND),
             pushdataOpSlp(fromHex(tokenId)),
-        ].concat(sendAmounts.map(qty => pushdataOpSlp(slpAmount(qty)))),
+        ].concat(sendAtomsArray.map(atoms => pushdataOpSlp(slpAtoms(atoms)))),
     );
 }
 
@@ -136,7 +136,7 @@ export function slpSend(
 export function slpBurn(
     tokenId: string,
     tokenType: number,
-    burnAmount: Amount,
+    burnAtoms: bigint,
 ): Script {
     verifyTokenType(tokenType);
     verifyTokenId(tokenId);
@@ -146,7 +146,7 @@ export function slpBurn(
         pushdataOpSlp(new Uint8Array([tokenType])),
         pushdataOpSlp(BURN),
         pushdataOpSlp(fromHex(tokenId)),
-        pushdataOpSlp(slpAmount(burnAmount)),
+        pushdataOpSlp(slpAtoms(burnAtoms)),
     ]);
 }
 
@@ -170,13 +170,13 @@ function verifyTokenId(tokenId: string) {
     }
 }
 
-function verifySendAmounts(sendAmounts: Amount[]) {
-    if (sendAmounts.length == 0) {
-        throw new Error('Send amount cannot be empty');
+function verifySendAtomsArray(sendAtomsArray: bigint[]) {
+    if (sendAtomsArray.length == 0) {
+        throw new Error('sendAtomsArray cannot be empty');
     }
-    if (sendAmounts.length > 19) {
+    if (sendAtomsArray.length > 19) {
         throw new Error(
-            `Cannot use more than 19 amounts, but got ${sendAmounts.length}`,
+            `Cannot use more than 19 amounts, but got ${sendAtomsArray.length}`,
         );
     }
 }
@@ -197,16 +197,16 @@ function pushdataOpSlp(pushdata: Uint8Array): Op {
     return pushBytesOp(pushdata);
 }
 
-export function slpAmount(amount: Amount): Uint8Array {
-    if (amount < 0 || BigInt(amount) > 0xffffffffffffffffn) {
-        throw new Error(`Amount out of range: ${amount}`);
+export function slpAtoms(atoms: bigint): Uint8Array {
+    if (atoms < 0n || atoms > 0xffffffffffffffffn) {
+        throw new Error(`Atoms out of range: ${atoms}`);
     }
-    const amountBytes = new Uint8Array(8);
+    const atomsBytes = new Uint8Array(8);
     const view = new DataView(
-        amountBytes.buffer,
-        amountBytes.byteOffset,
-        amountBytes.byteLength,
+        atomsBytes.buffer,
+        atomsBytes.byteOffset,
+        atomsBytes.byteLength,
     );
-    view.setBigUint64(0, BigInt(amount), /*little endian=*/ false);
-    return amountBytes;
+    view.setBigUint64(0, atoms, /*little endian=*/ false);
+    return atomsBytes;
 }

package/src/tx.ts

@@ -49,7 +49,7 @@ export interface TxInput {
 /** CTxOut, creating a new output. */
 export interface TxOutput {
     /** Value in satoshis of the output (1 XEC = 100 satoshis) */
-    value: number | bigint;
+    sats: bigint;
     /** Script locking the output */
     script: Script;
 }
@@ -57,7 +57,7 @@ export interface TxOutput {
 /** All the data required to sign an input (using BIP143). */
 export interface SignData {
     /** Value of the output being spent */
-    value: number | bigint;
+    sats: bigint;
     /** Script of the output being spent (not for P2SH) */
     outputScript?: Script;
     /**
@@ -120,10 +120,10 @@ export class Tx {
 }
 
 export function readTxOutput(bytes: Bytes): TxOutput {
-    const value = bytes.readU64();
+    const sats = bytes.readU64();
     const script = Script.readWithSize(bytes);
     return {
-        value,
+        sats,
         script,
     };
 }
@@ -147,7 +147,7 @@ export function writeTxInput(input: TxInput, writer: Writer): void {
 
 /** Write a TxOutput to a Writer */
 export function writeTxOutput(output: TxOutput, writer: Writer): void {
-    writer.putU64(output.value);
+    writer.putU64(output.sats);
     output.script.writeWithSize(writer);
 }
 
@@ -164,7 +164,7 @@ export function copyTxInput(input: TxInput): TxInput {
         script: input.script?.copy(),
         sequence: input.sequence,
         signData: input.signData && {
-            value: input.signData.value,
+            sats: input.signData.sats,
             outputScript: input.signData.outputScript?.copy(),
             redeemScript: input.signData.redeemScript?.copy(),
         },
@@ -174,7 +174,7 @@ export function copyTxInput(input: TxInput): TxInput {
 /** Create a deep copy of the TxOutput */
 export function copyTxOutput(output: TxOutput): TxOutput {
     return {
-        value: output.value,
+        sats: output.sats,
         script: output.script.copy(),
     };
 }

package/src/txBuilder.ts

@@ -84,7 +84,7 @@ export class TxBuilder {
             if (input.input.signData === undefined) {
                 return undefined;
             }
-            inputSum += BigInt(input.input.signData.value);
+            inputSum += BigInt(input.input.signData.sats);
         }
         return inputSum;
     }
@@ -108,11 +108,11 @@ export class TxBuilder {
                 }
                 leftoverIdx = idx;
                 outputs[idx] = {
-                    value: 0, // placeholder
+                    sats: 0n, // placeholder
                     script: builderOutput.copy(),
                 };
             } else {
-                fixedOutputSum += BigInt(builderOutput.value);
+                fixedOutputSum += BigInt(builderOutput.sats);
                 outputs[idx] = copyTxOutput(builderOutput);
             }
         }
@@ -122,8 +122,8 @@ export class TxBuilder {
     /** Sign the tx built by this builder and return a Tx */
     public sign(params?: {
         ecc?: Ecc;
-        feePerKb?: number;
-        dustLimit?: number;
+        feePerKb?: bigint;
+        dustSats?: bigint;
     }): Tx {
         const ecc = params?.ecc ?? new Ecc();
         const { fixedOutputSum, leftoverIdx, outputs } = this.prepareOutputs();
@@ -147,7 +147,7 @@ export class TxBuilder {
             const inputSum = this.inputSum();
             if (inputSum === undefined) {
                 throw new Error(
-                    'Using a leftover output requires setting SignData.value for all inputs',
+                    'Using a leftover output requires setting SignData.sats for all inputs',
                 );
             }
             if (params?.feePerKb === undefined) {
@@ -155,12 +155,12 @@ export class TxBuilder {
                     'Using a leftover output requires setting feePerKb',
                 );
             }
-            if (!Number.isInteger(params.feePerKb)) {
-                throw new Error('feePerKb must be an integer');
+            if (typeof params.feePerKb !== 'bigint') {
+                throw new Error('feePerKb must be a bigint');
             }
-            if (params?.dustLimit === undefined) {
+            if (params?.dustSats === undefined) {
                 throw new Error(
-                    'Using a leftover output requires setting dustLimit',
+                    'Using a leftover output requires setting dustSats',
                 );
             }
             const dummyUnsignedTx = UnsignedTx.dummyFromTx(
@@ -175,8 +175,8 @@ export class TxBuilder {
             updateSignatories(new EccDummy(), dummyUnsignedTx);
             let txSize = dummyUnsignedTx.tx.serSize();
             let txFee = calcTxFee(txSize, params.feePerKb);
-            const leftoverValue = inputSum - (fixedOutputSum + txFee);
-            if (leftoverValue < params.dustLimit) {
+            const leftoverSats = inputSum - (fixedOutputSum + txFee);
+            if (leftoverSats < params.dustSats) {
                 // inputs cannot pay for a dust leftover -> remove & recalc
                 outputs.splice(leftoverIdx, 1);
                 dummyUnsignedTx.tx.outputs = outputs;
@@ -185,11 +185,11 @@ export class TxBuilder {
                 txSize = dummyUnsignedTx.tx.serSize();
                 txFee = calcTxFee(txSize, params.feePerKb);
             } else {
-                outputs[leftoverIdx].value = leftoverValue;
+                outputs[leftoverIdx].sats = leftoverSats;
             }
             if (inputSum < fixedOutputSum + txFee) {
                 throw new Error(
-                    `Insufficient input value (${inputSum}): Can only pay for ${
+                    `Insufficient input sats (${inputSum}): Can only pay for ${
                         inputSum - fixedOutputSum
                     } fees, but ${txFee} required`,
                 );
@@ -210,7 +210,7 @@ export class TxBuilder {
 
 /** Calculate the required tx fee for the given txSize and feePerKb,
  *  rounding up */
-export function calcTxFee(txSize: number, feePerKb: number): bigint {
+export function calcTxFee(txSize: number, feePerKb: bigint): bigint {
     return (BigInt(txSize) * BigInt(feePerKb) + 999n) / 1000n;
 }
 

package/src/unsignedTx.ts

@@ -146,7 +146,7 @@ function writeLegacyPreimage(
             idx != inputIdx
         ) {
             // Do not lock-in the txout payee at other indices as txin
-            writeTxOutput({ value: 0, script: new Script() }, writer);
+            writeTxOutput({ sats: 0n, script: new Script() }, writer);
         } else {
             writeTxOutput(tx.outputs[idx], writer);
         }
@@ -288,7 +288,7 @@ export class UnsignedTxInput {
             }
             writeOutPoint(input.prevOut, writer);
             scriptCode.writeWithSize(writer);
-            writer.putU64(signData.value);
+            writer.putU64(signData.sats);
             writer.putU32(input.sequence ?? DEFAULT_SEQUENCE);
             writer.putBytes(hashOutputs);
             writer.putU32(tx.locktime);