Splitting up txs.ts into different stages based on purpose

.gitignore

@@ -67,3 +67,4 @@ typings/
 # dotenv environment variables file
 .env
 
+package-lock.json

__tests__/chain.test.ts

@@ -8,8 +8,10 @@ import { fundTx, getAllTX } from '../lib/net';
 
 import { extractInfo } from '../lib/chain';
 
-import TXList from '../lib/TXList';
-import { genCommitTx, genLockTx, genUnlockTx } from '../lib/txs';
+import  TXList  from '../lib/TXList';
+import { genCommitTx }  from '../lib/tx-commit.ts';
+import { genLockTx } from '../lib/tx-lock.ts';
+import { genUnlockTx } from '../lib/tx-unlock.ts';
 
 describe('chain state', () => {
     it('finds the one current name', async () => {

__tests__/txs.test.ts

@@ -8,14 +8,28 @@ import {
 } from 'bcoin';
 
 import {
-    genRedeemScript,
-    genLockTx,
-    genUnlockTx,
-    genCommitTx,
-    genCommitRedeemScript,
     serializeCommitData,
     deserializeCommitData,
 } from '../lib/txs';
+
+import {
+    genUnlockTx,
+} from '../lib/tx-unlock';
+
+import {
+    genLockTx,
+} from '../lib/tx-lock';
+
+import {
+    genCommitTx,
+} from '../lib/tx-commit';
+
+
+import {
+    genRedeemScript,
+    genCommitRedeemScript,
+} from '../lib/tx-generate';
+
 import {
     BadUserPublicKeyError,
     BadServicePublicKeyError,

__tests__/verify.test.ts

@@ -1,15 +1,18 @@
 import { verifyLockTX, verifyCommitTX } from '../lib/verify';
 import {
-    genRedeemScript,
     genP2shAddr,
-    genLockTx,
     getLockTxName,
     getLockTxPubKey,
     getLockTxTime,
-    genCommitTx,
     serializeCommitData,
     deserializeCommitData,
 } from '../lib/txs';
+import{
+    genRedeemScript,
+    genCommitRedeemScript, 
+} from '../lib/tx-generate';
+import { genCommitTx } from '../lib/tx-commit';
+import { genLockTx } from '../lib/tx-lock';
 import {
     keyring as KeyRing,
     coin as Coin,

lib/tx-commit.ts

@@ -0,0 +1,124 @@
+import{
+    script as Script,
+    address as Address,
+    output as Output,
+    mtx as MTX,
+    coin as Coin,
+    tx as TX,
+    keyring as KeyRing,
+    crypto,
+} from 'bcoin';
+
+import{
+    genCommitRedeemScript, 
+} from './tx-generate';
+
+import{
+    genP2shAddr,
+} from './txs.ts';
+
+import { verifyLockTX, isURISafe, verifyCommitTX } from './verify';
+
+import randomBytes = require('randombytes');
+
+/**
+ * Generate a commit transaction.
+ * @param coins Array of coins to fund the transaction.
+ * @param name Name for name/key pair.
+ * @param locktime Absolute locktime
+ * @param commitFee Commit fee, in satoshis.
+ * @param registerFee Registration fee, in satoshis.
+ * @param escrowFee Escrow fee, in satoshis.
+ * @param feeRate Fee rate, in satoshis/kilobyte.
+ * @param userRing The user's key ring.
+ * @param servicePubKey Service public key.
+ */
+function genCommitTx(coins: Coin[],
+                     name: string,
+                     locktime: number,
+                     commitFee: number,
+                     registerFee: number,
+                     escrowFee: number,
+                     feeRate: number,
+                     userRing: KeyRing,
+                     servicePubKey: Buffer): TX {
+    //
+    // Validate name and the service public key
+    if (name.length > 64) {
+        throw new Error('Name is too long');
+    }
+
+    if (!isURISafe(name)) {
+        throw new Error('Invalid character(s) in name');
+    }
+
+    if (!crypto.secp256k1.publicKeyVerify(servicePubKey)) {
+        throw new Error('Invalid service public key');
+    }
+
+    // Generate a P2SH address from a redeem script, using a random nonce
+    const nonce = randomBytes(32);
+    const redeemScript = genCommitRedeemScript(userRing.getPublicKey(), nonce, name, locktime);
+    const p2shAddr = genP2shAddr(redeemScript);
+
+    // Generate service address from service public key
+    const servicePKH = crypto.hash160(servicePubKey);
+    const serviceAddr = Address.fromPubkeyhash(servicePKH);
+
+    const lockTx = new MTX();
+
+    // Compute total value of coins
+    const total = coins.reduce((acc, cur) => acc + cur.value, 0);
+
+    for (const coin of coins) {
+        lockTx.addCoin(coin);
+    }
+
+    // Compute change amount
+    const changeVal = total - (commitFee + registerFee + escrowFee) - (4 * feeRate);
+
+    // Add nonce OP_RETURN as output 0
+    const pubkeyDataScript = Script.fromNulldata(nonce);
+    lockTx.addOutput(Output.fromScript(pubkeyDataScript, 0));
+
+    // Add service upfront fee as output 1
+    lockTx.addOutput({
+        address: serviceAddr,
+        value: commitFee,
+    });
+
+    // Add locked fee as output 2
+    // Locks up the fee to register, the fee to be put in escrow, and enough for a 4kb tx at current rates
+    lockTx.addOutput({
+        address: p2shAddr,
+        value: registerFee + escrowFee + 4 * feeRate,
+    });
+
+    // Add change output as 3
+    lockTx.addOutput({
+        address: userRing.getAddress(),
+        value: changeVal,
+    });
+
+    // Add coins as inputs
+    for (let i = 0; i < coins.length; ++i) {
+        const coin = coins[i];
+        lockTx.scriptInput(i, coin, userRing);
+    }
+
+    // Each signature is 72 bytes long
+    const virtSize = lockTx.getVirtualSize() + coins.length * 72;
+    lockTx.subtractIndex(3, Math.ceil(virtSize / 1000 * feeRate));
+
+    // Sign the coins
+    for (let i = 0; i < coins.length; ++i) {
+        const coin = coins[i];
+        lockTx.signInput(i, coin, userRing, Script.hashType.ALL);
+    }
+
+    return lockTx.toTX();
+
+}
+export {
+    genCommitTx
+};

lib/tx-generate.ts

@@ -0,0 +1,112 @@
+import {
+	script as Script,
+	crypto
+} from 'bcoin';
+
+import {
+    BadUserPublicKeyError,
+    BadServicePublicKeyError,
+} from './errors';
+
+import {
+    serializeCommitData,
+} from './txs';
+
+/**
+ * Generate a redeem script, removing a name/key pair from the blockchain.
+ * Validates `userPubkey` and `servicePubkey`.
+ *
+ * @param userPubkey The user's public key.
+ * @param servicePubkey The service's public key.
+ * @param alocktime An absolute lock time, in blocks.
+ */
+function genRedeemScript(userPubkey: Buffer, servicePubkey: Buffer, alocktime: number): Script {
+    // Validate user public key
+    if (!crypto.secp256k1.publicKeyVerify(userPubkey)) {
+        throw new BadUserPublicKeyError();
+    }
+
+    // Validate service public key
+    if (!crypto.secp256k1.publicKeyVerify(servicePubkey)) {
+        throw new BadServicePublicKeyError();
+    }
+
+    const script = new Script(null);
+
+    script.pushSym('OP_IF');
+
+    //
+    // If spending as user, execute this branch
+
+    // Verify that 0 <= current block size - commit block size
+    script.pushInt(0);
+    script.pushSym('OP_CHECKSEQUENCEVERIFY');
+    script.pushSym('OP_DROP');
+
+    // Check the provided user signature
+    script.pushData(userPubkey);
+    script.pushSym('OP_CHECKSIG');
+
+    script.pushSym('OP_ELSE');
+
+    //
+    // Otherwise, if spending as service, execute this branch
+
+    // Verify that alocktime <= current block size
+    script.pushInt(alocktime);
+    script.pushSym('OP_CHECKLOCKTIMEVERIFY');
+    script.pushSym('OP_DROP');
+
+    // Check the provided service signature
+    script.pushData(servicePubkey);
+    script.pushSym('OP_CHECKSIG');
+
+    script.pushSym('OP_ENDIF');
+
+    script.compile();
+
+    return script;
+}
+
+/**
+ * Generate a commit redeem script.
+ * @param userPubkey The user's public key.
+ * @param nonce A 256-bit buffer representing a nonce.
+ * @param name A name of at most 64 characters composed of URL-safe characters.
+ * @param locktime An absolute lock time, in blocks.
+ */
+function genCommitRedeemScript(userPubkey: Buffer, nonce: Buffer, name: string, locktime: number): Script {
+    // Validate user public key
+    if (!crypto.secp256k1.publicKeyVerify(userPubkey)) {
+        throw new BadUserPublicKeyError();
+    }
+
+    const script = new Script();
+
+    // Verify that at least six blocks have passed since commit
+    script.pushInt(6);
+    script.pushSym('OP_CHECKSEQUENCEVERIFY');
+    script.pushSym('OP_DROP');
+
+    //
+    // Hash [256-bit nonce + 2-byte locktime (BE) + 1-byte length of name + name]
+    // and check against parameters.
+    script.pushSym('OP_HASH256');
+
+    const hashData = serializeCommitData(nonce, locktime, name);
+    const hash = crypto.hash256(hashData);
+    script.pushData(hash);
+    script.pushSym('OP_EQUALVERIFY');
+
+    // Check user signature
+    script.pushData(userPubkey);
+    script.pushSym('OP_CHECKSIG');
+
+    script.compile();
+    return script;
+}
+
+export {
+    genRedeemScript,
+    genCommitRedeemScript,
+};