@bsv/sdk 1.0.36 → 1.0.38

package/src/messages/__tests/EncryptedMessage.test.ts

@@ -11,6 +11,32 @@ describe('EncryptedMessage', () => {
     const decrypted = decrypt(encrypted, recipient)
     expect(decrypted).toEqual(message)
   })
+  it('Encrypts a message for a recipient with rare key length', () => {
+    const recipient = new PrivateKey(21)
+    {
+      // Rare length case... Leading zeros in key BigNumber array.
+      const encrypted = [
+        66,66,16,51,2,215,146,77,79,125,
+        67,234,150,90,70,90,227,9,95,244,
+        17,49,229,148,111,60,133,247,158,68,
+        173,188,248,226,126,8,14,2,53,43,
+        191,74,76,221,18,86,79,147,250,51,
+        44,227,51,48,29,154,212,2,113,248,
+        16,113,129,52,10,239,37,190,89,213,
+
+        75,148,8,235,104,137,80,129,55,68,
+        182,141,118,212,215,121,161,107,62,247,
+        12,172,244,170,208,37,213,198,103,118,
+        75,166,166,131,191,105,48,232,101,223,
+        255,169,176,204,126,249,78,178,10,51,
+        13,163,58,232,122,111,210,218,187,247,
+        164,101,207,15,37,227,108,82,70,35,
+        5,148,18,162,120,64,46,40,227,197,
+        6,112,207,200,238,81
+      ]
+      expect(() => decrypt(encrypted, recipient)).not.toThrow()
+    }
+  })
   it('Fails to decrypt a message with wrong version', () => {
     const sender = new PrivateKey(15)
     const recipient = new PrivateKey(21)

package/src/primitives/AESGCM.ts

@@ -178,17 +178,23 @@ export function AES (input: number[], key: number[]): number[] {
   const state = [[], [], [], []]
   const output = []
 
-  if (key.length === 16) {
+  // Since the BigNumber representation of keys ignores big endian zeroes,
+  // extend incoming key arrays with zeros to the smallest standard key size.
+  let ekey = Array.from(key)
+  if (ekey.length <= 16) {
+    while (ekey.length < 16) ekey.unshift(0) 
     roundLimit = 11
-  } else if (key.length === 24) {
+  } else if (ekey.length <= 24) {
+    while (ekey.length < 24) ekey.unshift(0) 
     roundLimit = 13
-  } else if (key.length === 32) {
+  } else if (key.length <= 32) {
+    while (ekey.length < 32) ekey.unshift(0) 
     roundLimit = 15
   } else {
     throw new Error('Illegal key length: ' + String(key.length))
   }
 
-  const w = keyExpansion(roundLimit, key)
+  const w = keyExpansion(roundLimit, ekey)
 
   for (i = 0; i < 15; i++) {
     state[parseInt(String(i / 4))].push(input[(i * 4) % 15])

package/src/primitives/PrivateKey.ts

@@ -209,15 +209,17 @@ export default class PrivateKey extends BigNumber {
    * Base58Check encodes the hash of the public key associated with this private key with a prefix to indicate locking script type.
    * Defaults to P2PKH for mainnet, otherwise known as a "Bitcoin Address".
    *
-   * @param prefix defaults to [0x00] for mainnet, set to [0x6f] for testnet.
+   * @param prefix defaults to [0x00] for mainnet, set to [0x6f] for testnet or use the strings 'testnet' or 'mainnet'
    *
    * @returns Returns the address encoding associated with the hash of the public key associated with this private key.
    *
    * @example
-   * const address = pubkey.toAddress()
-   * const testnetAddress = pubkey.toAddress([0x6f])
+   * const address = privkey.toAddress()
+   * const address = privkey.toAddress('mainnet')
+   * const testnetAddress = privkey.toAddress([0x6f])
+   * const testnetAddress = privkey.toAddress('testnet')
    */
-  toAddress (prefix: number[] = [0x00]): string {
+  toAddress (prefix: number[] | string = [0x00]): string {
     return this.toPublicKey().toAddress(prefix)
   }
 

package/src/primitives/PublicKey.ts

@@ -145,15 +145,26 @@ export default class PublicKey extends Point {
    * Base58Check encodes the hash of the public key with a prefix to indicate locking script type.
    * Defaults to P2PKH for mainnet, otherwise known as a "Bitcoin Address".
    *
-   * @param prefix defaults to [0x00] for mainnet, set to [0x6f] for testnet.
+   * @param prefix defaults to [0x00] for mainnet, set to [0x6f] for testnet or use the strings 'mainnet' or 'testnet'
    *
    * @returns Returns the address encoding associated with the hash of the public key.
    *
    * @example
    * const address = pubkey.toAddress()
+   * const address = pubkey.toAddress('mainnet')
    * const testnetAddress = pubkey.toAddress([0x6f])
+   * const testnetAddress = pubkey.toAddress('testnet')
    */
-  toAddress (prefix: number[] = [0x00]): string {
+  toAddress (prefix: number[] | string = [0x00]): string {
+    if (typeof prefix === 'string') {
+      if (prefix === 'testnet' || prefix === 'test') {
+        prefix = [0x6f]
+      } else if (prefix === 'mainnet' || prefix === 'main') {
+        prefix = [0x00]
+      } else {
+        throw new Error(`Invalid prefix ${prefix}`)
+      }
+    }
     return toBase58Check(this.toHash() as number[], prefix)
   }
 

package/src/script/templates/P2PKH.ts

@@ -91,6 +91,7 @@ export default class P2PKH implements ScriptTemplate {
           )
         }
         sourceSatoshis ||= input.sourceTransaction?.outputs[input.sourceOutputIndex].satoshis
+        sourceSatoshis ||= input.sourceSatoshis
         if (!sourceSatoshis) {
           throw new Error(
             'The sourceSatoshis or input sourceTransaction is required for transaction signing.'

package/src/transaction/Transaction.ts

@@ -293,26 +293,35 @@ export default class Transaction {
   /**
    * Computes fees prior to signing.
    * If no fee model is provided, uses a SatoshisPerKilobyte fee model that pays 10 sat/kb.
+   * If fee is a number, the transaction uses that value as fee.
    *
-   * @param model - The initialized fee model to use
+   * @param modelOrFee - The initialized fee model to use or fixed fee for the transaction
    * @param changeDistribution - Specifies how the change should be distributed
    * amongst the change outputs
    *
    * TODO: Benford's law change distribution.
    */
-  async fee (model?: FeeModel, changeDistribution: 'equal' | 'random' = 'equal'): Promise<void> {
+  async fee (modelOrFee?: FeeModel | number, changeDistribution: 'equal' | 'random' = 'equal'): Promise<void> {
     this.cachedHash = undefined
-    if (typeof model === 'undefined') {
-      model = new SatoshisPerKilobyte(10)
+    if (typeof modelOrFee === 'undefined') {
+      modelOrFee = new SatoshisPerKilobyte(10)
     }
-    const fee = await model.computeFee(this)
+    if (typeof modelOrFee === 'number') {
+      const sats = modelOrFee
+      modelOrFee = {
+        computeFee: async () => sats
+      }
+    }
+    const fee = await modelOrFee.computeFee(this)
     // change = inputs - fee - non-change outputs
     let change = 0
     for (const input of this.inputs) {
-      if (typeof input.sourceTransaction !== 'object') {
-        throw new Error('Source transactions are required for all inputs during fee computation')
+      if (typeof input.sourceTransaction !== 'object' && typeof input.sourceSatoshis !== 'number') {
+        throw new Error('Source transactions or sourceSatoshis are required for all inputs during fee computation')
       }
-      change += input.sourceTransaction.outputs[input.sourceOutputIndex].satoshis
+      change += input.sourceTransaction
+        ? input.sourceTransaction.outputs[input.sourceOutputIndex].satoshis
+        : input.sourceSatoshis
     }
     change -= fee
     let changeCount = 0
@@ -350,6 +359,28 @@ export default class Transaction {
     }
   }
 
+  /**
+   * Utility method that returns the current fee based on inputs and outputs
+   *
+   * @returns The current transaction fee
+   */
+  getFee (): number {
+    let totalIn = 0
+    for (const input of this.inputs) {
+      if (typeof input.sourceTransaction !== 'object' && typeof input.sourceSatoshis !== 'number') {
+        throw new Error('Source transactions or sourceSatoshis are required for all inputs to calculate fee')
+      }
+      totalIn += input.sourceTransaction
+        ? input.sourceTransaction.outputs[input.sourceOutputIndex].satoshis
+        : input.sourceSatoshis || 0
+    }
+    let totalOut = 0
+    for (const output of this.outputs) {
+      totalOut += output.satoshis || 0
+    }
+    return totalIn - totalOut
+  }
+
   /**
    * Signs a transaction, hydrating all its unlocking scripts based on the provided script templates where they are available.
    */

package/src/transaction/TransactionInput.ts

@@ -16,6 +16,9 @@ import Transaction from './Transaction.js'
  * @property {number} sourceOutputIndex - The index of the output in the source transaction
  *           that this input is spending. It is zero-based, indicating the position of the
  *           output in the array of outputs of the source transaction.
+ * @property {number} [sourceSatoshis] - The amount of satoshis of the source transaction
+ *           output that this input is spending, used for fee calculation and signing when
+ *           source transaction is not present
  * @property {UnlockingScript} [unlockingScript] - Optional. The script that 'unlocks' the
  *           source output for spending. This script typically contains signatures and
  *           public keys that evidence the ownership of the output.
@@ -54,6 +57,7 @@ export default interface TransactionInput {
   sourceTransaction?: Transaction
   sourceTXID?: string
   sourceOutputIndex: number
+  sourceSatoshis?: number
   unlockingScript?: UnlockingScript
   unlockingScriptTemplate?: {
     sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>

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

@@ -317,6 +317,32 @@ describe('Transaction', () => {
       // 4000 sats in - 1000 sats out - 1033 sats fee = expected 1967 sats change
       expect(spendTx.outputs[1].satoshis).toEqual(1967)
     })
+    it('Computes fee using FixedFee model', 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: 4000
+      }], 0)
+      const spendTx = new Transaction(1, [{
+        sourceTransaction: sourceTx,
+        sourceOutputIndex: 0,
+        unlockingScriptTemplate: p2pkh.unlock(privateKey),
+        sequence: 0xffffffff
+      }], [{
+        satoshis: 1000,
+        lockingScript: p2pkh.lock(publicKeyHash)
+      }, {
+        lockingScript: p2pkh.lock(publicKeyHash),
+        change: true
+      }], 0)
+      expect(spendTx.outputs[1].satoshis).not.toBeDefined()
+      await spendTx.fee(1033)
+      // 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 () => {
       const privateKey = new PrivateKey(1)
       const publicKey = new Curve().g.mul(privateKey)
@@ -352,6 +378,41 @@ describe('Transaction', () => {
       expect(spendTx.outputs[1].satoshis).toEqual(983)
       expect(spendTx.outputs[2].satoshis).toEqual(983)
     })
+    it('Calculates fee for utxo based transaction', async () => {
+      const utxos = [ // WoC format utxos
+        {
+          height: 1600000,
+          tx_pos: 0,
+          tx_hash: '672dd6a93fa5d7ba6794e0bdf8b479440b95a55ec10ad3d9e03585ecb5628d8d',
+          value: 10000
+        },
+        {
+          height: 1600000,
+          tx_pos: 0,
+          tx_hash: 'f33505acf37a7726cc37d391bc6f889b8684ac2a2d581c4be2a4b1c8b46609bc',
+          value: 10000
+        },
+      ]
+      const priv = PrivateKey.fromRandom()
+      const tx = new Transaction()
+      utxos.forEach(utxo => {
+        const script = new P2PKH().lock(priv.toPublicKey().toHash())
+        tx.addInput({
+          sourceTXID: utxo.tx_hash,
+          sourceOutputIndex: utxo.tx_pos,
+          sourceSatoshis: utxo.value,
+          unlockingScriptTemplate: new P2PKH()
+            .unlock(priv, 'all', false, utxo.value, script)
+        })
+      })
+      tx.addOutput({
+        lockingScript: new P2PKH().lock(priv.toAddress()),
+        change: true
+      })
+      await tx.fee({ computeFee: async () => 10 })
+      expect(tx.outputs[0].satoshis).toEqual(20000 - 10)
+      expect(tx.getFee()).toEqual(10)
+    })
   })
 
   describe('Broadcast', () => {

package/src/transaction/broadcasters/ARC.ts

@@ -13,6 +13,8 @@ export interface ArcConfig {
   deploymentId?: string
   /** The HTTP client used to make requests to the ARC API. */
   httpClient?: HttpClient
+  /** The headers to be attached to all tx submissions. */
+  headers?: Record<string, string>
 }
 
 
@@ -27,6 +29,7 @@ export default class ARC implements Broadcaster {
   readonly URL: string
   readonly apiKey: string | undefined
   readonly deploymentId: string
+  readonly headers: Record<string, string> | undefined
   private readonly httpClient: HttpClient;
 
   /**
@@ -50,10 +53,11 @@ export default class ARC implements Broadcaster {
       this.apiKey = config
       this.httpClient = defaultHttpClient()
     } else {
-      const {apiKey, deploymentId, httpClient} = config ?? {} as ArcConfig
+      const {apiKey, deploymentId, headers, httpClient} = config ?? {} as ArcConfig
       this.httpClient = httpClient ?? defaultHttpClient()
       this.deploymentId = deploymentId ?? defaultDeploymentId()
       this.apiKey = apiKey
+      this.headers = headers
     }
   }
 
@@ -118,6 +122,12 @@ export default class ARC implements Broadcaster {
       headers['Authorization'] = `Bearer ${this.apiKey}`
     }
 
+    if (!!this.headers) {
+      for (const key in this.headers) {
+        headers[key] = this.headers[key]
+      }
+    }
+
     return headers
   }
 }

package/src/transaction/broadcasters/__tests/ARC.test.ts

@@ -189,7 +189,7 @@ describe('ARC Broadcaster', () => {
       headers: {
         get(key: string) {
           if (key === 'Content-Type') {
-            return 'application/json'
+            return 'application/json; charset=UTF-8'
           }
         }
       },
@@ -205,7 +205,7 @@ describe('ARC Broadcaster', () => {
           statusCode: response.status,
           statusMessage: response.status == 200 ? 'OK' : 'Bad request',
           headers: {
-            'content-type': 'application/json'
+            'content-type': 'application/json; charset=UTF-8'
           },
           on: (event, handler) => {
             if (event === 'data') handler(JSON.stringify(response.data))

package/src/transaction/http/FetchHttpClient.ts

@@ -38,7 +38,7 @@ export class FetchHttpClient implements HttpClient {
 
     const res = await this.fetch(url, fetchOptions);
     const mediaType = res.headers.get('Content-Type');
-    const data = mediaType === 'application/json' ? await res.json() : await res.text();
+    const data = mediaType.startsWith('application/json') ? await res.json() : await res.text();
 
     return {
       ok: res.ok,

package/src/transaction/http/NodejsHttpClient.ts

@@ -32,7 +32,7 @@ export class NodejsHttpClient implements HttpClient {
         res.on('end', () => {
           const ok = res.statusCode >= 200 && res.statusCode <= 299;
           const mediaType = res.headers['content-type'];
-          const data = body && mediaType === 'application/json' ? JSON.parse(body) : body;
+          const data = body && mediaType.startsWith('application/json') ? JSON.parse(body) : body;
           resolve({
             status: res.statusCode,
             statusText: res.statusMessage,