@bsv/sdk 1.2.2 → 1.2.4

package/src/transaction/Transaction.ts

@@ -140,9 +140,9 @@ export default class Transaction {
     const validTxids = new Set<string>()
     // All BUMP level 0 hashes are valid.
     for (const bump of BUMPs) {
-      for (const n of bump.path[0])
-        if (n.hash)
-          validTxids.add(n.hash)
+      for (const n of bump.path[0]) {
+        if (n.hash) { validTxids.add(n.hash) }
+      }
     }
     // To keep track of which transactions were used.
     const unusedTxTxids = new Set<string>()
@@ -524,17 +524,47 @@ export default class Transaction {
     }
 
     // Distribute change among change outputs
+    let distributedChange = 0
     if (changeDistribution === 'random') {
-      // TODO
-      throw new Error('Not yet implemented')
+      // Implement Benford's Law distribution for change outputs
+      const changeOutputs = this.outputs.filter(out => out.change)
+      let changeToUse = change
+
+      // Helper function to generate a number approximating Benford's Law
+      const benfordNumber = (min: number, max: number): number => {
+        const d = Math.floor(Math.random() * 9) + 1
+        return Math.floor(min + (max - min) * Math.log10(1 + 1 / d) / Math.log10(10))
+      }
+
+      const benfordNumbers = Array(changeOutputs.length).fill(1)
+      changeToUse -= changeOutputs.length
+      distributedChange += changeOutputs.length
+      for (let i = 0; i < changeOutputs.length - 1; i++) {
+        const portion = benfordNumber(0, changeToUse)
+        benfordNumbers[i] += portion
+        distributedChange += portion
+        changeToUse -= portion
+      }
+
+      for (let i = 0; i < this.outputs.length; i++) {
+        if (this.outputs[i].change) {
+          const t = benfordNumbers.shift()
+          this.outputs[i].satoshis = t
+        }
+      }
     } else if (changeDistribution === 'equal') {
       const perOutput = Math.floor(change / changeCount)
       for (const out of this.outputs) {
         if (out.change) {
+          distributedChange += perOutput
           out.satoshis = perOutput
         }
       }
     }
+    // if there's any remaining change, add it to the last output
+    if (distributedChange < change) {
+      this.outputs[this.outputs.length - 1].satoshis += (change - distributedChange)
+    }
   }
 
   /**
@@ -868,13 +898,14 @@ export default class Transaction {
 
   /**
    * Serializes this transaction, together with its inputs and the respective merkle proofs, into the BEEF (BRC-62) format. This enables efficient verification of its compliance with the rules of SPV.
-   * 
+   *
    * @param allowPartial If true, error will not be thrown if there are any missing sourceTransactions.
    *
    * @returns The serialized BEEF structure
    * @throws Error if there are any missing sourceTransactions unless `allowPartial` is true.
    */
   toBEEF (allowPartial?: boolean): number[] {
+    this.outputs.length
     const writer = new Writer()
     writer.writeUInt32LE(4022206465)
     const BUMPs: MerklePath[] = []
@@ -919,10 +950,7 @@ export default class Transaction {
       if (!hasProof) {
         for (let i = 0; i < tx.inputs.length; i++) {
           const input = tx.inputs[i]
-          if (typeof input.sourceTransaction === 'object')
-            addPathsAndInputs(input.sourceTransaction)
-          else if (!allowPartial)
-            throw new Error('A required source transaction is missing!')
+          if (typeof input.sourceTransaction === 'object') { addPathsAndInputs(input.sourceTransaction) } else if (!allowPartial) { throw new Error('A required source transaction is missing!') }
         }
       }
     }

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

@@ -346,7 +346,7 @@ describe('Transaction', () => {
       // 4000 sats in - 1000 sats out - 1033 sats fee = expected 1967 sats change
       expect(spendTx.outputs[1].satoshis).toEqual(1967)
     })
-    it('Distributes change among multiple change outputs', async () => {
+    it('Distributes change equally among multiple change outputs', async () => {
       const privateKey = new PrivateKey(1)
       const publicKey = new Curve().g.mul(privateKey)
       const publicKeyHash = hash160(publicKey.encode(true)) as number[]
@@ -369,17 +369,146 @@ describe('Transaction', () => {
       }, {
         lockingScript: p2pkh.lock(publicKeyHash),
         change: true
+      }, {
+        lockingScript: p2pkh.lock(publicKeyHash),
+        change: true
+      }, {
+        lockingScript: p2pkh.lock(publicKeyHash),
+        change: true
       }], 0)
       expect(spendTx.outputs[1].satoshis).not.toBeDefined()
       expect(spendTx.outputs[2].satoshis).not.toBeDefined()
+      expect(spendTx.outputs[3].satoshis).not.toBeDefined()
+      expect(spendTx.outputs[4].satoshis).not.toBeDefined()
       await spendTx.fee({
         // Our custom fee model will always charge 1033 sats for a tx.
-        computeFee: async () => 1033
+        computeFee: async () => 1032
       })
       // 4000 sats in - 1000 sats out - 1033 sats fee = expected 1967 sats change
       // Divide by 2 (no remainder) = 983 sats per change output
-      expect(spendTx.outputs[1].satoshis).toEqual(983)
-      expect(spendTx.outputs[2].satoshis).toEqual(983)
+      expect(spendTx.outputs[0].satoshis).toEqual(1000)
+      expect(spendTx.outputs[1].satoshis).toEqual(492)
+      expect(spendTx.outputs[2].satoshis).toEqual(492)
+      expect(spendTx.outputs[3].satoshis).toEqual(492)
+      expect(spendTx.outputs[4].satoshis).toEqual(492)
+    })
+    it('Distributes change randomly among multiple change outputs', async () => {
+      const privateKey = new PrivateKey(1)
+      const publicKey = new Curve().g.mul(privateKey)
+      const publicKeyHash = hash160(publicKey.encode(true)) as number[]
+      const p2pkh = new P2PKH()
+      const sourceTx = new Transaction(1, [], [{
+        lockingScript: p2pkh.lock(publicKeyHash),
+        satoshis: 900
+      }], 0)
+      const spendTx = new Transaction(1, [{
+        sourceTransaction: sourceTx,
+        sourceOutputIndex: 0,
+        unlockingScriptTemplate: p2pkh.unlock(privateKey),
+        sequence: 0xffffffff
+      }], [{
+        satoshis: 1,
+        lockingScript: p2pkh.lock(publicKeyHash)
+      }, {
+        lockingScript: p2pkh.lock(publicKeyHash),
+        change: true
+      }, {
+        lockingScript: p2pkh.lock(publicKeyHash),
+        change: true
+      }, {
+        lockingScript: p2pkh.lock(publicKeyHash),
+        change: true
+      }, {
+        lockingScript: p2pkh.lock(publicKeyHash),
+        change: true
+      }, {
+        lockingScript: p2pkh.lock(publicKeyHash),
+        change: true
+      }, {
+        lockingScript: p2pkh.lock(publicKeyHash),
+        change: true
+      }], 0)
+      expect(spendTx.outputs[1].satoshis).not.toBeDefined()
+      expect(spendTx.outputs[2].satoshis).not.toBeDefined()
+      expect(spendTx.outputs[3].satoshis).not.toBeDefined()
+      expect(spendTx.outputs[4].satoshis).not.toBeDefined()
+      expect(spendTx.outputs[5].satoshis).not.toBeDefined()
+      expect(spendTx.outputs[6].satoshis).not.toBeDefined()
+      await spendTx.fee({
+        computeFee: async () => 3
+      }, 'random')
+      expect(spendTx.outputs[0].satoshis).toEqual(1)
+      expect(spendTx.outputs.reduce((a, b) => a + b.satoshis, 0)).toEqual(897)
+    })
+    it('Distributes change randomly among multiple change outputs, with one set output', async () => {
+      const privateKey = new PrivateKey(1)
+      const publicKey = new Curve().g.mul(privateKey)
+      const publicKeyHash = hash160(publicKey.encode(true)) as number[]
+      const p2pkh = new P2PKH()
+      const sourceTx = new Transaction(1, [], [{
+        lockingScript: p2pkh.lock(publicKeyHash),
+        satoshis: 9
+      }], 0)
+      const spendTx = new Transaction(1, [{
+        sourceTransaction: sourceTx,
+        sourceOutputIndex: 0,
+        unlockingScriptTemplate: p2pkh.unlock(privateKey),
+        sequence: 0xffffffff
+      }], [{
+        satoshis: 1,
+        lockingScript: p2pkh.lock(publicKeyHash)
+      }, {
+        lockingScript: p2pkh.lock(publicKeyHash),
+        change: true
+      }, {
+        lockingScript: p2pkh.lock(publicKeyHash),
+        change: true
+      }, {
+        lockingScript: p2pkh.lock(publicKeyHash),
+        change: true
+      }, {
+        lockingScript: p2pkh.lock(publicKeyHash),
+        change: true
+      }, {
+        lockingScript: p2pkh.lock(publicKeyHash),
+        change: true
+      }, {
+        lockingScript: p2pkh.lock(publicKeyHash),
+        change: true
+      }], 0)
+      expect(spendTx.outputs[1].satoshis).not.toBeDefined()
+      expect(spendTx.outputs[2].satoshis).not.toBeDefined()
+      expect(spendTx.outputs[3].satoshis).not.toBeDefined()
+      expect(spendTx.outputs[4].satoshis).not.toBeDefined()
+      expect(spendTx.outputs[5].satoshis).not.toBeDefined()
+      expect(spendTx.outputs[6].satoshis).not.toBeDefined()
+      await spendTx.fee({
+        computeFee: async () => 1
+      }, 'random')
+      expect(spendTx.outputs.reduce((a, b) => a + b.satoshis, 0)).toEqual(8)
+    })
+    it('Distributes change randomly among multiple change outputs, thinnly spread', async () => {
+      const privateKey = new PrivateKey(1)
+      const publicKey = new Curve().g.mul(privateKey)
+      const publicKeyHash = hash160(publicKey.encode(true)) as number[]
+      const p2pkh = new P2PKH()
+      const sourceTx = new Transaction(1, [], [{
+        lockingScript: p2pkh.lock(publicKeyHash),
+        satoshis: 46
+      }], 0)
+      const spendTx = new Transaction(1, [{
+        sourceTransaction: sourceTx,
+        sourceOutputIndex: 0,
+        unlockingScriptTemplate: p2pkh.unlock(privateKey),
+        sequence: 0xffffffff
+      }], Array(21).fill(null).map(() => ({
+        lockingScript: p2pkh.lock(publicKeyHash),
+        change: true
+      })), 0)
+      await spendTx.fee({
+        computeFee: async () => 1
+      }, 'random')
+      expect(spendTx.outputs.reduce((a, b) => a + b.satoshis, 0)).toEqual(45)
     })
     it('Calculates fee for utxo based transaction', async () => {
       const utxos = [ // WoC format utxos

package/src/wallet/CachedKeyDeriver.ts

@@ -17,7 +17,7 @@ export default class CachedKeyDeriver {
      * @param {Object} [options] - Optional settings for the cache.
      * @param {number} [options.maxCacheSize=1000] - The maximum number of entries to store in the cache.
      */
-  constructor(rootKey: PrivateKey | 'anyone', options?: { maxCacheSize?: number }) {
+  constructor (rootKey: PrivateKey | 'anyone', options?: { maxCacheSize?: number }) {
     this.keyDeriver = new KeyDeriver(rootKey)
     this.cache = new Map<string, any>()
     this.maxCacheSize = options?.maxCacheSize || 1000
@@ -32,7 +32,7 @@ export default class CachedKeyDeriver {
      * @param {boolean} [forSelf=false] - Whether deriving for self.
      * @returns {PublicKey} - The derived public key.
      */
-  derivePublicKey(
+  derivePublicKey (
     protocolID: [0 | 1 | 2, string],
     keyID: string,
     counterparty: PublicKey | string | 'self' | 'anyone',
@@ -56,7 +56,7 @@ export default class CachedKeyDeriver {
      * @param {PublicKey | string | 'self' | 'anyone'} counterparty - The counterparty's public key or a predefined value ('self' or 'anyone').
      * @returns {PrivateKey} - The derived private key.
      */
-  derivePrivateKey(
+  derivePrivateKey (
     protocolID: [0 | 1 | 2, string],
     keyID: string,
     counterparty: PublicKey | string | 'self' | 'anyone'
@@ -80,7 +80,7 @@ export default class CachedKeyDeriver {
      * @returns {SymmetricKey} - The derived symmetric key.
      * @throws {Error} - Throws an error if attempting to derive a symmetric key for 'anyone'.
      */
-  deriveSymmetricKey(
+  deriveSymmetricKey (
     protocolID: [0 | 1 | 2, string],
     keyID: string,
     counterparty: PublicKey | string | 'self' | 'anyone'
@@ -102,7 +102,7 @@ export default class CachedKeyDeriver {
      * @returns {number[]} - The shared secret as a number array.
      * @throws {Error} - Throws an error if attempting to reveal a shared secret for 'self'.
      */
-  revealCounterpartySecret(counterparty: PublicKey | string | 'self' | 'anyone'): number[] {
+  revealCounterpartySecret (counterparty: PublicKey | string | 'self' | 'anyone'): number[] {
     const cacheKey = this.generateCacheKey('revealCounterpartySecret', counterparty)
     if (this.cache.has(cacheKey)) {
       return this.cacheGet(cacheKey)
@@ -121,7 +121,7 @@ export default class CachedKeyDeriver {
      * @param {string} keyID - The key identifier.
      * @returns {number[]} - The specific key association as a number array.
      */
-  revealSpecificSecret(
+  revealSpecificSecret (
     counterparty: PublicKey | string | 'self' | 'anyone',
     protocolID: [0 | 1 | 2, string],
     keyID: string
@@ -142,7 +142,7 @@ export default class CachedKeyDeriver {
      * @param {...any} args - The arguments passed to the method.
      * @returns {string} - The generated cache key.
      */
-  private generateCacheKey(methodName: string, ...args: any[]): string {
+  private generateCacheKey (methodName: string, ...args: any[]): string {
     const serializedArgs = args.map((arg) => this.serializeArgument(arg)).join('|')
     return `${methodName}|${serializedArgs}`
   }
@@ -152,7 +152,7 @@ export default class CachedKeyDeriver {
      * @param {any} arg - The argument to serialize.
      * @returns {string} - The serialized argument.
      */
-  private serializeArgument(arg: any): string {
+  private serializeArgument (arg: any): string {
     if (arg instanceof PublicKey || arg instanceof PrivateKey) {
       return arg.toString()
     } else if (Array.isArray(arg)) {
@@ -169,7 +169,7 @@ export default class CachedKeyDeriver {
      * @param {string} cacheKey - The key of the cached item.
      * @returns {any} - The cached value.
      */
-  private cacheGet(cacheKey: string): any {
+  private cacheGet (cacheKey: string): any {
     const value = this.cache.get(cacheKey)
     // Update the entry to reflect recent use
     this.cache.delete(cacheKey)
@@ -182,7 +182,7 @@ export default class CachedKeyDeriver {
      * @param {string} cacheKey - The key of the item to cache.
      * @param {any} value - The value to cache.
      */
-  private cacheSet(cacheKey: string, value: any): void {
+  private cacheSet (cacheKey: string, value: any): void {
     if (this.cache.size >= this.maxCacheSize) {
       // Evict the least recently used item (first item in Map)
       const firstKey = this.cache.keys().next().value

package/src/wallet/KeyDeriver.ts

@@ -11,7 +11,7 @@ export default class KeyDeriver {
      * Initializes the KeyDeriver instance with a root private key.
      * @param {PrivateKey | 'anyone'} rootKey - The root private key or the string 'anyone'.
      */
-  constructor(rootKey: PrivateKey | 'anyone') {
+  constructor (rootKey: PrivateKey | 'anyone') {
     if (rootKey === 'anyone') {
       this.rootKey = new PrivateKey(1)
     } else {
@@ -27,7 +27,7 @@ export default class KeyDeriver {
      * @param {boolean} [forSelf=false] - Whether deriving for self.
      * @returns {PublicKey} - The derived public key.
      */
-  derivePublicKey(protocolID: [0 | 1 | 2, string], keyID: string, counterparty: PublicKey | string | 'self' | 'anyone', forSelf: boolean = false): PublicKey {
+  derivePublicKey (protocolID: [0 | 1 | 2, string], keyID: string, counterparty: PublicKey | string | 'self' | 'anyone', forSelf: boolean = false): PublicKey {
     counterparty = this.normalizeCounterparty(counterparty)
     if (forSelf) {
       return this.rootKey.deriveChild(counterparty, this.computeInvoiceNumber(protocolID, keyID)).toPublicKey()
@@ -43,7 +43,7 @@ export default class KeyDeriver {
      * @param {PublicKey | string | 'self' | 'anyone'} counterparty - The counterparty's public key or a predefined value ('self' or 'anyone').
      * @returns {PrivateKey} - The derived private key.
      */
-  derivePrivateKey(protocolID: [0 | 1 | 2, string], keyID: string, counterparty: PublicKey | string | 'self' | 'anyone'): PrivateKey {
+  derivePrivateKey (protocolID: [0 | 1 | 2, string], keyID: string, counterparty: PublicKey | string | 'self' | 'anyone'): PrivateKey {
     counterparty = this.normalizeCounterparty(counterparty)
     return this.rootKey.deriveChild(counterparty, this.computeInvoiceNumber(protocolID, keyID))
   }
@@ -57,7 +57,7 @@ export default class KeyDeriver {
      * @returns {SymmetricKey} - The derived symmetric key.
      * @throws {Error} - Throws an error if attempting to derive a symmetric key for 'anyone'.
      */
-  deriveSymmetricKey(protocolID: [0 | 1 | 2, string], keyID: string, counterparty: PublicKey | string | 'self' | 'anyone'): SymmetricKey {
+  deriveSymmetricKey (protocolID: [0 | 1 | 2, string], keyID: string, counterparty: PublicKey | string | 'self' | 'anyone'): SymmetricKey {
     if (counterparty === 'anyone') {
       throw new Error(
         'Symmetric keys (such as encryption keys or HMAC keys) should not be derivable by everyone, because messages would be decryptable by anyone who knows the identity public key of the user, and HMACs would be similarly forgeable.'
@@ -76,7 +76,7 @@ export default class KeyDeriver {
      * @returns {number[]} - The shared secret as a number array.
      * @throws {Error} - Throws an error if attempting to reveal a shared secret for 'self'.
      */
-  revealCounterpartySecret(counterparty: PublicKey | string | 'self' | 'anyone'): number[] {
+  revealCounterpartySecret (counterparty: PublicKey | string | 'self' | 'anyone'): number[] {
     if (counterparty === 'self') {
       throw new Error('Counterparty secrets cannot be revealed for counterparty=self.')
     }
@@ -101,7 +101,7 @@ export default class KeyDeriver {
      * @param {string} keyID - The key identifier.
      * @returns {number[]} - The specific key association as a number array.
      */
-  revealSpecificSecret(counterparty: PublicKey | string | 'self' | 'anyone', protocolID: [0 | 1 | 2, string], keyID: string): number[] {
+  revealSpecificSecret (counterparty: PublicKey | string | 'self' | 'anyone', protocolID: [0 | 1 | 2, string], keyID: string): number[] {
     counterparty = this.normalizeCounterparty(counterparty)
     const sharedSecret = this.rootKey.deriveSharedSecret(counterparty)
     const invoiceNumberBin = Utils.toArray(this.computeInvoiceNumber(protocolID, keyID), 'utf8')
@@ -114,7 +114,7 @@ export default class KeyDeriver {
      * @returns {PublicKey} - The normalized counterparty public key.
      * @throws {Error} - Throws an error if the counterparty is invalid.
      */
-  private normalizeCounterparty(counterparty: PublicKey | string | 'self' | 'anyone'): PublicKey {
+  private normalizeCounterparty (counterparty: PublicKey | string | 'self' | 'anyone'): PublicKey {
     if (!counterparty) {
       throw new Error('counterparty must be self, anyone or a public key!')
     } else if (counterparty === 'self') {
@@ -135,7 +135,7 @@ export default class KeyDeriver {
      * @returns {string} - The computed invoice number.
      * @throws {Error} - Throws an error if protocol ID or key ID are invalid.
      */
-  private computeInvoiceNumber(protocolID: [0 | 1 | 2, string], keyID: string): string {
+  private computeInvoiceNumber (protocolID: [0 | 1 | 2, string], keyID: string): string {
     const securityLevel = protocolID[0]
     if (!Number.isInteger(securityLevel) || securityLevel < 0 || securityLevel > 2) {
       throw new Error('Protocol security level must be 0, 1, or 2')