@bsv/sdk 1.2.14 → 1.2.15

package/docs/transaction.md

@@ -1524,6 +1524,7 @@ export default class Transaction {
     constructor(version: number = 1, inputs: TransactionInput[] = [], outputs: TransactionOutput[] = [], lockTime: number = 0, metadata: Record<string, any> = {}, merklePath?: MerklePath) 
     addInput(input: TransactionInput): void 
     addOutput(output: TransactionOutput): void 
+    addP2PKHOutput(address: number[] | string, satoshis?: number): void 
     updateMetadata(metadata: Record<string, any>): void 
     async fee(modelOrFee: FeeModel | number = new SatoshisPerKilobyte(10), changeDistribution: "equal" | "random" = "equal"): Promise<void> 
     getFee(): number 
@@ -1583,6 +1584,21 @@ Argument Details
 + **output**
   + The TransactionOutput object to add to the transaction.
 
+#### Method addP2PKHOutput
+
+Adds a new P2PKH output to the transaction.
+
+```ts
+addP2PKHOutput(address: number[] | string, satoshis?: number): void 
+```
+
+Argument Details
+
++ **address**
+  + The P2PKH address of the output.
++ **satoshis**
+  + The number of satoshis to send to the address - if not provided, the output is considered a change output.
+
 #### Method broadcast
 
 Broadcasts a transaction.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "1.2.14",
+  "version": "1.2.15",
   "type": "module",
   "description": "BSV Blockchain Software Development Kit",
   "main": "dist/cjs/mod.js",

package/src/script/templates/P2PKH.ts

@@ -30,6 +30,7 @@ export default class P2PKH implements ScriptTemplate {
     } else {
       data = pubkeyhash
     }
+    if (data.length !== 20) throw new Error('P2PKH hash length must be 20 bytes')
     return new LockingScript([
       { op: OP.OP_DUP },
       { op: OP.OP_HASH160 },

package/src/transaction/Transaction.ts

@@ -13,6 +13,7 @@ import ChainTracker from './ChainTracker.js'
 import { defaultBroadcaster } from './broadcasters/DefaultBroadcaster.js'
 import { defaultChainTracker } from './chaintrackers/DefaultChainTracker.js'
 import { ATOMIC_BEEF, BEEF_MAGIC } from './Beef.js'
+import P2PKH from '../script/templates/P2PKH.js'
 
 /**
  * Represents a complete Bitcoin transaction. This class encapsulates all the details
@@ -455,9 +456,30 @@ export default class Transaction {
    */
   addOutput (output: TransactionOutput): void {
     this.cachedHash = undefined
+    if (!output.change) {
+      if (typeof output.satoshis === 'undefined') throw new Error('either satoshis must be defined or change must be set to true')
+      if (output.satoshis <= 0) throw new Error('satoshis must be a positive integer or zero')
+    }
+    if (!output.lockingScript) throw new Error('lockingScript must be defined')
     this.outputs.push(output)
   }
 
+  /**
+   * Adds a new P2PKH output to the transaction.
+   *
+   * @param {number[] | string} address - The P2PKH address of the output.
+   * @param {number} [satoshis] - The number of satoshis to send to the address - if not provided, the output is considered a change output.
+   *
+   */
+  addP2PKHOutput (address: number[] | string, satoshis?: number): void {
+    const lockingScript = new P2PKH().lock(address)
+    if (typeof satoshis === 'undefined') { return this.addOutput({ lockingScript, change: true }) }
+    this.addOutput({
+      lockingScript,
+      satoshis
+    })
+  }
+
   /**
    * Updates the transaction's metadata.
    *

package/src/transaction/__tests/Transaction.benchmarks.test.ts

@@ -42,7 +42,7 @@ describe('Transaction Verification Benchmark', () => {
         }
 
         // Build the chain
-        for (let i = 0; i < depth; i++) {
+        for (let i = 1; i < depth + 1; i++) {
             const newTx = new Transaction()
             newTx.addInput({
                 sourceTransaction: tx,
@@ -52,7 +52,7 @@ describe('Transaction Verification Benchmark', () => {
             })
             newTx.addOutput({
                 lockingScript: p2pkh.lock(publicKeyHash),
-                satoshis: 100000 - 1000 * (i + 1)
+                satoshis: 100000 - (i * 10)
             })
             await newTx.sign()
             tx = newTx

package/src/transaction/__tests/Transaction.test.ts

@@ -973,4 +973,48 @@ describe('Transaction', () => {
       }).toThrowError('Transaction with TXID 0000000000000000000000000000000000000000000000000000000000000000 not found in BEEF data.')
     })
   })
+
+  describe('addP2PKHOutput', () => {
+    it('should create an output on the current transaction using an address hash or string', async () => {
+      const privateKey = PrivateKey.fromRandom()
+      const lockingScript = new P2PKH().lock(privateKey.toAddress())
+      const tx = new Transaction()
+      tx.addInput({
+        sourceTXID: '00'.repeat(32),
+        sourceOutputIndex: 0,
+        unlockingScriptTemplate: new P2PKH().unlock(privateKey),
+      })
+      tx.addP2PKHOutput(privateKey.toAddress(), 10000)
+      expect(tx.outputs.length).toEqual(1)
+      expect(tx.outputs[0].satoshis).toEqual(10000)
+      expect(tx.outputs[0].lockingScript.toHex() === lockingScript.toHex()).toBeTruthy()
+    })
+    it('should error is the address is non base58', async () => {
+      const tx = new Transaction()    
+      expect(() => tx.addP2PKHOutput('A small chicken', 10000)).toThrow("Invalid base58 character ")
+    })
+    it('should error if the address is incorrectly copied', async () => {
+      const tx = new Transaction()
+      expect(() => tx.addP2PKHOutput('14afWk1jLH9Uwi2mC9C5ehrsvcFxTLYDp', 10000)).toThrow("Invalid checksum")
+    })
+    it('should error if the address is a hash of wrong length', async () => {
+      const tx = new Transaction()
+      const address = [1,2,3,4,5]
+      expect(() => tx.addP2PKHOutput(address, 10000)).toThrow("P2PKH hash length must be 20 bytes")
+    })
+    it('should set the output to a change output if the satoshi value is not given', async () => {
+      const tx = new Transaction()
+      tx.addP2PKHOutput('18E63MgXH43KBb288ETM8u91J2cqdGNEmg')
+      expect(tx.outputs[0].change).toBeTruthy()
+      expect(tx.outputs[0].satoshis).toBeUndefined()
+    })
+    it('throw error when satoshi value is negative', async () => {
+      const tx = new Transaction()
+      expect(() => tx.addP2PKHOutput('18E63MgXH43KBb288ETM8u91J2cqdGNEmg', -1000)).toThrow('satoshis must be a positive integer or zero')
+    })
+    it('throw error when output does not set satoshi value', async () => {
+      const tx = new Transaction()
+      expect(() => tx.addOutput({ lockingScript: Script.fromASM('OP_TRUE') })).toThrow('either satoshis must be defined or change must be set to true')
+    })
+  })
 })