@bsv/sdk 1.1.32 → 1.2.0

package/src/overlay-tools/index.ts

@@ -0,0 +1,5 @@
+export * from './LookupResolver.js'
+export * from './SHIPBroadcaster.js'
+export { default as OverlayAdminTokenTemplate } from './OverlayAdminTokenTemplate.js'
+export { default as LookupResolver } from './LookupResolver.js'
+export { default as SHIPBroadcaster } from './SHIPBroadcaster.js'

package/src/script/templates/PushDrop.ts

@@ -0,0 +1,246 @@
+import { ScriptTemplate, LockingScript, UnlockingScript, OP } from '../index.js'
+import { Utils, Hash, TransactionSignature, Signature, PublicKey } from '../../primitives/index.js'
+import { Wallet } from '../../wallet/Wallet.interfaces.js'
+import { Transaction } from '../../transaction/index.js'
+
+/**
+ * For a given piece of data to push onto the stack in script, creates the correct minimally-encoded script chunk,
+ * including the correct push operation.
+ *
+ * TODO: This should be made into a TS-SDK util (distinct from the `minimallyEncode` util)
+ */
+const createMinimallyEncodedScriptChunk = (data: number[]): { op: number, data?: number[] } => {
+  if (data.length === 0) {
+    // Could have used OP_0.
+    return { op: 0 }
+  }
+  if (data.length === 1 && data[0] === 0) {
+    // Could have used OP_0.
+    return { op: 0 }
+  }
+  if (data.length === 1 && data[0] > 0 && data[0] <= 16) {
+    // Could have used OP_0 .. OP_16.
+    return { op: 0x50 + data[0] }
+  }
+  if (data.length === 1 && data[0] === 0x81) {
+    // Could have used OP_1NEGATE.
+    return { op: 0x4f }
+  }
+  if (data.length <= 75) {
+    // Could have used a direct push (opcode indicating number of bytes
+    // pushed + those bytes).
+    return { op: data.length, data }
+  }
+  if (data.length <= 255) {
+    // Could have used OP_PUSHDATA.
+    return { op: 0x4c, data }
+  }
+  if (data.length <= 65535) {
+    // Could have used OP_PUSHDATA2.
+    return { op: 0x4d, data }
+  }
+  return { op: 0x4e, data }
+}
+
+export default class PushDrop implements ScriptTemplate {
+  wallet: Wallet
+
+  /**
+   * Decodes a PushDrop script back into its token fields and the locking public key. If a signature was present, it will be the last field returned.
+   * Warning: Only works with a P2PK lock at the beginning of the script.
+   * @param script PushDrop script to decode back into token fields
+   * @returns An object containing PushDrop token fields and the locking public key. If a signature was included, it will be the last field.
+   */
+  static decode(script: LockingScript): { lockingPublicKey: PublicKey, fields: number[][] } {
+    const lockingPublicKey = PublicKey.fromString(Utils.toHex(script.chunks[0].data))
+    const fields = []
+    for (let i = 2; i < script.chunks.length; i++) {
+      const nextOpcode = script.chunks[i + 1].op
+      let chunk = script.chunks[i].data
+      if (!chunk) {
+        if (script.chunks[i].op >= 80 && script.chunks[i].op <= 95) {
+          chunk = [script.chunks[i].op - 80]
+        } else if (script.chunks[i].op === 0) {
+          chunk = [0]
+        } else if (script.chunks[i].op === 0x4f) {
+          chunk = [0x81]
+        }
+      }
+      fields.push(chunk)
+
+      // If the next value is DROP or 2DROP then this is the final field
+      if (nextOpcode === OP.OP_DROP || nextOpcode === OP.OP_2DROP) {
+        break
+      }
+    }
+
+    return {
+      fields,
+      lockingPublicKey
+    }
+  }
+
+  /**
+   * Constructs a new instance of the PushDrop class.
+   *
+   * @param {Wallet} wallet - The wallet interface used for creating signatures and accessing public keys.
+   */
+  constructor(wallet: Wallet) {
+    this.wallet = wallet
+  }
+
+  /**
+   * Creates a PushDrop locking script with arbitrary data fields and a public key lock.
+   *
+   * @param {number[][]} fields - The token fields to include in the locking script.
+   * @param {[0 | 1 | 2, string]} protocolID - The protocol ID to use.
+   * @param {string} keyID - The key ID to use.
+   * @param {string} counterparty - The counterparty involved in the transaction, "self" or "anyone".
+   * @param {boolean} [forSelf=false] - Flag indicating if the lock is for the creator (default no).
+   * @param {boolean} [includeSignature=true] - Flag indicating if a signature should be included in the script (default yes).
+   * @returns {Promise<LockingScript>} The generated PushDrop locking script.
+   */
+  async lock(fields: number[][], protocolID: [0 | 1 | 2, string], keyID: string, counterparty: string, forSelf = false, includeSignature = true, lockPosition: 'before' | 'after' = 'before'): Promise<LockingScript> {
+    const { publicKey } = await this.wallet.getPublicKey({
+      protocolID,
+      keyID,
+      counterparty,
+      forSelf
+    })
+    const lockChunks: Array<{ op: number, data?: number[] }> = []
+    const pushDropChunks: Array<{ op: number, data?: number[] }> = []
+    lockChunks.push({ op: publicKey.length / 2, data: Utils.toArray(publicKey, 'hex') })
+    lockChunks.push({ op: OP.OP_CHECKSIG })
+    if (includeSignature) {
+      const dataToSign = fields.reduce((a, e) => [...a, ...e], [])
+      const { signature } = await this.wallet.createSignature({
+        data: dataToSign,
+        protocolID,
+        keyID,
+        counterparty
+      })
+      fields.push(signature)
+    }
+    for (const field of fields) {
+      pushDropChunks.push(createMinimallyEncodedScriptChunk(field))
+    }
+    let notYetDropped = fields.length
+    while (notYetDropped > 1) {
+      pushDropChunks.push({ op: OP.OP_2DROP })
+      notYetDropped -= 2
+    }
+    if (notYetDropped) {
+      pushDropChunks.push({ op: OP.OP_DROP })
+    }
+    if (lockPosition === 'before') {
+      return new LockingScript([
+        ...lockChunks,
+        ...pushDropChunks
+      ])
+    } else {
+      return new LockingScript([
+        ...pushDropChunks,
+        ...lockChunks
+      ])
+    }
+  }
+
+  /**
+   * Creates an unlocking script for spending a PushDrop token output.
+   *
+   * @param {[0 | 1 | 2, string]} protocolID - The protocol ID to use.
+   * @param {string} keyID - The key ID to use.
+   * @param {string} counterparty - The counterparty involved in the transaction, "self" or "anyone".
+   * @param {string} [sourceTXID] - The TXID of the source transaction.
+   * @param {number} [sourceSatoshis] - The number of satoshis in the source output.
+   * @param {LockingScript} [lockingScript] - The locking script of the source output.
+   * @param {'all' | 'none' | 'single'} [signOutputs='all'] - Specifies which outputs to sign.
+   * @param {boolean} [anyoneCanPay=false] - Specifies if the anyone-can-pay flag is set.
+   * @returns {Object} An object containing functions to sign the transaction and estimate the script length.
+   */
+  unlock(
+    protocolID: [0 | 1 | 2, string],
+    keyID: string,
+    counterparty: string,
+    signOutputs: 'all' | 'none' | 'single' = 'all',
+    anyoneCanPay = false,
+    sourceSatoshis?: number,
+    lockingScript?: LockingScript
+  ): {
+    sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
+    estimateLength: () => Promise<73>
+  } {
+    return {
+      sign: async (tx: Transaction, inputIndex: number): Promise<UnlockingScript> => {
+        let signatureScope = TransactionSignature.SIGHASH_FORKID
+        if (signOutputs === 'all') {
+          signatureScope |= TransactionSignature.SIGHASH_ALL
+        }
+        if (signOutputs === 'none') {
+          signatureScope |= TransactionSignature.SIGHASH_NONE
+        }
+        if (signOutputs === 'single') {
+          signatureScope |= TransactionSignature.SIGHASH_SINGLE
+        }
+        if (anyoneCanPay) {
+          signatureScope |= TransactionSignature.SIGHASH_ANYONECANPAY
+        }
+
+        const input = tx.inputs[inputIndex]
+
+        const otherInputs = tx.inputs.filter((_, index) => index !== inputIndex)
+
+        const sourceTXID = input.sourceTXID ? input.sourceTXID : input.sourceTransaction?.id('hex')
+        if (!sourceTXID) {
+          throw new Error(
+            'The input sourceTXID or sourceTransaction is required for transaction signing.'
+          )
+        }
+        sourceSatoshis ||= input.sourceTransaction?.outputs[input.sourceOutputIndex].satoshis
+        if (!sourceSatoshis) {
+          throw new Error(
+            'The sourceSatoshis or input sourceTransaction is required for transaction signing.'
+          )
+        }
+        lockingScript ||= input.sourceTransaction?.outputs[input.sourceOutputIndex].lockingScript
+        if (!lockingScript) {
+          throw new Error(
+            'The lockingScript or input sourceTransaction is required for transaction signing.'
+          )
+        }
+
+        const preimage = TransactionSignature.format({
+          sourceTXID,
+          sourceOutputIndex: input.sourceOutputIndex,
+          sourceSatoshis,
+          transactionVersion: tx.version,
+          otherInputs,
+          inputIndex,
+          outputs: tx.outputs,
+          inputSequence: input.sequence,
+          subscript: lockingScript,
+          lockTime: tx.lockTime,
+          scope: signatureScope
+        })
+        const preimageHash = Hash.sha256(preimage)
+        const { signature: bareSignature } = await this.wallet.createSignature({
+          data: preimageHash,
+          protocolID,
+          keyID,
+          counterparty
+        })
+        const signature = Signature.fromDER([...bareSignature])
+        const txSignature = new TransactionSignature(
+          signature.r,
+          signature.s,
+          signatureScope
+        )
+        const sigForScript = txSignature.toChecksigFormat()
+        return new UnlockingScript([
+          { op: sigForScript.length, data: sigForScript }
+        ])
+      },
+      estimateLength: async () => 73
+    }
+  }
+}

package/src/script/templates/__tests/PushDrop.test.ts

@@ -0,0 +1,158 @@
+/* eslint-env jest */
+import PushDrop from '../../../../dist/cjs/src/script/templates/PushDrop.js'
+import ProtoWallet from '../../../../dist/cjs/src/wallet/ProtoWallet.js'
+import { PrivateKey, Utils } from '../../../../dist/cjs/src/primitives/index.js'
+import { Script, Spend } from '../../../../dist/cjs/src/script/index.js'
+import { Transaction } from '../../../../dist/cjs/src/transaction/index.js'
+
+describe('PushDrop', () => {
+  let privateKey: typeof PrivateKey
+  let wallet
+  let pushDrop: PushDrop
+
+  const createDecodeRedeem = async (fields: number[][] = [], protocolID: [0 | 1 | 2, string] = [0, 'tests'], keyID: string = 'test-key', counterparty: string = 'self', signOutputs: 'all' | 'none' | 'single' = 'all', anyoneCanPay: boolean = false) => {
+    const lockingScript = await pushDrop.lock(fields, protocolID, keyID, counterparty)
+    expect(lockingScript).toBeInstanceOf(Script)
+    const decoded = await PushDrop.decode(lockingScript)
+    expect(decoded.fields).toEqual(fields)
+    const expectedPublicKey = (await wallet.getPublicKey({ protocolID, keyID, counterparty })).publicKey
+    expect(decoded.lockingPublicKey.toString()).toEqual(expectedPublicKey)
+    const satoshis = 1
+    const unlockingTemplate = await pushDrop.unlock(protocolID, keyID, counterparty, signOutputs, anyoneCanPay)
+    const sourceTx = new Transaction(1, [], [{
+      lockingScript,
+      satoshis
+    }], 0)
+    const spendTx = new Transaction(1, [{
+      sourceTransaction: sourceTx,
+      sourceOutputIndex: 0,
+      sequence: 0xffffffff
+    }], [], 0)
+    const unlockingScript = await unlockingTemplate.sign(spendTx, 0)
+    expect(await unlockingTemplate.estimateLength()).toEqual(73)
+    const spend = new Spend({
+      sourceTXID: sourceTx.id('hex'),
+      sourceOutputIndex: 0,
+      sourceSatoshis: satoshis,
+      lockingScript,
+      transactionVersion: 1,
+      otherInputs: [],
+      inputIndex: 0,
+      unlockingScript,
+      outputs: [],
+      inputSequence: 0xffffffff,
+      lockTime: 0
+    })
+    const valid = spend.validate()
+    expect(valid).toBe(true)
+  }
+
+  beforeEach(() => {
+    privateKey = PrivateKey.fromRandom()
+    wallet = new ProtoWallet(privateKey)
+    pushDrop = new PushDrop(wallet)
+  })
+
+  it('Passes various test vectors', async () => {
+    await createDecodeRedeem()
+    await createDecodeRedeem([[0]])
+    await createDecodeRedeem([[1]])
+    await createDecodeRedeem([[0x81]])
+    await createDecodeRedeem([[3, 1, 4, 1, 5, 9]])
+    await createDecodeRedeem([new Array(200).fill(0xff)])
+    await createDecodeRedeem([new Array(400).fill(0xff)])
+    await createDecodeRedeem([new Array(70000).fill(0xff)])
+    await createDecodeRedeem([[0], [1], [2]])
+    await createDecodeRedeem([[0], [1], [2], [3]])
+    await createDecodeRedeem([[3, 1, 4, 1, 5, 9]], undefined, undefined, undefined, 'none', false)
+    await createDecodeRedeem([[3, 1, 4, 1, 5, 9]], undefined, undefined, undefined, 'single', false)
+    await createDecodeRedeem([[3, 1, 4, 1, 5, 9]], undefined, undefined, undefined, 'all', true)
+    await createDecodeRedeem([[3, 1, 4, 1, 5, 9]], undefined, undefined, undefined, 'none', true)
+    await createDecodeRedeem([[3, 1, 4, 1, 5, 9]], undefined, undefined, undefined, 'single', true)
+  })
+
+  describe('lock', () => {
+    it('creates a correct locking script', async () => {
+      const fields = [
+        Utils.toArray('hello world', 'utf8'),
+        Utils.toArray('This is a field', 'utf8'),
+        [0xde, 0xad, 0xbe, 0xef]
+      ]
+      const protocolID: [0 | 1 | 2, string] = [0, 'tests']
+      const keyID = 'test-key'
+      const counterparty = 'self'
+      const lockingScript = await pushDrop.lock(fields, protocolID, keyID, counterparty)
+
+      // Check that the locking script is not null
+      expect(lockingScript).toBeInstanceOf(Script)
+
+      // Decode the locking script and check the fields and locking public key
+      const decoded = await PushDrop.decode(lockingScript)
+      expect(decoded.fields).toEqual(fields)
+      const expectedPublicKey = (await wallet.getPublicKey({ protocolID, keyID, counterparty })).publicKey
+      expect(decoded.lockingPublicKey.toString()).toEqual(expectedPublicKey)
+    })
+  })
+
+  describe('unlock', () => {
+    it('creates a correct unlocking script', async () => {
+      const fields = [
+        Utils.toArray('hello world', 'utf8'),
+        Utils.toArray('This is a field', 'utf8'),
+        [0xde, 0xad, 0xbe, 0xef]
+      ]
+      const protocolID: [0 | 1 | 2, string] = [0, 'tests']
+      const keyID = 'test-key'
+      const counterparty = 'self'
+      const lockingScript = await pushDrop.lock(fields, protocolID, keyID, counterparty)
+      const satoshis = 1
+      const unlockingTemplate = await pushDrop.unlock(protocolID, keyID, counterparty)
+      const sourceTx = new Transaction(1, [], [{
+        lockingScript,
+        satoshis
+      }], 0)
+      const spendTx = new Transaction(1, [{
+        sourceTransaction: sourceTx,
+        sourceOutputIndex: 0,
+        sequence: 0xffffffff
+      }], [], 0)
+      const unlockingScript = await unlockingTemplate.sign(spendTx, 0)
+      expect(await unlockingTemplate.estimateLength()).toEqual(73)
+      const spend = new Spend({
+        sourceTXID: sourceTx.id('hex'),
+        sourceOutputIndex: 0,
+        sourceSatoshis: satoshis,
+        lockingScript,
+        transactionVersion: 1,
+        otherInputs: [],
+        inputIndex: 0,
+        unlockingScript,
+        outputs: [],
+        inputSequence: 0xffffffff,
+        lockTime: 0
+      })
+      const valid = spend.validate()
+      expect(valid).toBe(true)
+    })
+  })
+
+  describe('decode', () => {
+    it('decodes the locking script correctly', async () => {
+      const fields = [
+        Utils.toArray('hello world', 'utf8'),
+        Utils.toArray('This is a field', 'utf8'),
+        [0xde, 0xad, 0xbe, 0xef]
+      ]
+      const protocolID: [0 | 1 | 2, string] = [0, 'tests']
+      const keyID = 'test-key'
+      const counterparty = 'self'
+
+      const lockingScript = await pushDrop.lock(fields, protocolID, keyID, counterparty)
+
+      const decoded = await PushDrop.decode(lockingScript)
+      expect(decoded.fields).toEqual(fields)
+      const expectedPublicKey = (await wallet.getPublicKey({ protocolID, keyID, counterparty })).publicKey
+      expect(decoded.lockingPublicKey.toString()).toEqual(expectedPublicKey)
+    })
+  })
+})

package/src/script/templates/index.ts

@@ -1,2 +1,3 @@
 export { default as P2PKH } from './P2PKH.js'
 export { default as RPuzzle } from './RPuzzle.js'
+export { default as PushDrop } from './PushDrop.js'

package/src/transaction/Beef.ts

@@ -396,11 +396,10 @@ export class Beef {
   }
 
   /**
-     * Returns a binary array representing the serialized BEEF
-     * @returns A binary array representing the BEEF
-     */
-  toBinary (): number[] {
-    const writer = new Writer()
+   * Serializes this data to `writer`
+   * @param writer 
+   */
+  toWriter (writer: Writer) {
     writer.writeUInt32LE(this.magic)
 
     writer.writeVarIntNum(this.bumps.length)
@@ -412,7 +411,38 @@ export class Beef {
     for (const tx of this.txs) {
       tx.toWriter(writer, this.magic)
     }
+  }
+
+  /**
+     * Returns a binary array representing the serialized BEEF
+     * @returns A binary array representing the BEEF
+     */
+  toBinary (): number[] {
+    const writer = new Writer()
+    this.toWriter(writer)
+    return writer.toArray()
+  }
 
+  /**
+   * Serialize this Beef as AtomicBEEF.
+   * 
+   * `txid` must exist and be the last transaction
+   * in sorted (dependency) order.
+   * 
+   * @param txid 
+   * @returns serialized contents of this Beef with AtomicBEEF prefix.
+   */
+  toBinaryAtomic(txid: string) {
+    this.sortTxs()
+    const tx = this.findTxid(txid)
+    if (!tx)
+      throw new Error(`${txid} does not exist in this Beef`)
+    if (this.txs[this.txs.length - 1] !== tx)
+      throw new Error(`${txid} is not the last transaction in this Beef`)
+    const writer = new Writer()
+    writer.writeUInt32LE(ATOMIC_BEEF)
+    writer.write(toArray(txid, 'hex'))
+    this.toWriter(writer)
     return writer.toArray()
   }
 
@@ -429,7 +459,7 @@ export class Beef {
     let atomicTxid: string | undefined = undefined
     if (version === ATOMIC_BEEF) {
       // Skip the txid and re-read the BEEF version
-      atomicTxid = toHex(br.readReverse(32))
+      atomicTxid = toHex(br.read(32))
       version = br.readUInt32LE()
     }
     if (version !== BEEF_MAGIC && version !== BEEF_MAGIC_V2) { throw new Error(`Serialized BEEF must start with ${BEEF_MAGIC} or ${BEEF_MAGIC_V2} but starts with ${version}`) }

package/src/transaction/Transaction.ts

@@ -138,7 +138,18 @@ export default class Transaction {
 
     // Ensure that all transactions are part of the dependency graph of the subject 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)
+    }
+    // To keep track of which transactions were used.
+    const unusedTxTxids = new Set<string>()
+    for (const txid of Object.keys(transactions)) unusedTxTxids.add(txid)
+
     const traverseDependencies = (txid: string) => {
+      unusedTxTxids.delete(txid)
       if (validTxids.has(txid)) {
         return
       }
@@ -156,10 +167,8 @@ export default class Transaction {
     traverseDependencies(subjectTXID)
 
     // Check for any unrelated transactions
-    for (const txid in transactions) {
-      if (!validTxids.has(txid)) {
-        throw new Error(`Unrelated transaction with TXID ${txid} found in Atomic BEEF data.`)
-      }
+    for (const txid of unusedTxTxids) {
+      throw new Error(`Unrelated transaction with TXID ${txid} found in Atomic BEEF data.`)
     }
 
     // Build the transaction by linking inputs and merkle paths

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

@@ -101,7 +101,7 @@ describe('Beef tests', () => {
         }
     })
 
-    test('4_all merkleRoots equal', async () => {
+    test('1_all merkleRoots equal', async () => {
         {
           const beef = Beef.fromString(beefs[0])
           expect(beef.isValid(undefined)).toBe(true)
@@ -115,7 +115,7 @@ describe('Beef tests', () => {
         }
     })
 
-    test('4_allowTxidOnly', async () => {
+    test('2_allowTxidOnly', async () => {
         {
           const beef = Beef.fromString(beefs[0])
           expect(beef.isValid(undefined)).toBe(true)
@@ -125,7 +125,7 @@ describe('Beef tests', () => {
         }
     })
 
-    test('4_removeExistingTxid', async () => {
+    test('3_removeExistingTxid', async () => {
         {
           const beef = Beef.fromString(beefs[0])
           expect(beef.isValid(undefined)).toBe(true)
@@ -165,7 +165,7 @@ describe('Beef tests', () => {
         }
     })
 
-    test('4_mergeBeef', async () => {
+    test('5_mergeBeef', async () => {
         {
           const beef = Beef.fromString(beefs[0])
           const beefB = Beef.fromString(beefs[0])
@@ -201,7 +201,7 @@ describe('Beef tests', () => {
         }
     })
 
-    test('4_BeefParty', async () => {
+    test('6_BeefParty', async () => {
 
       const bp = new BeefParty(['b', 'c'])
       expect(bp.isParty('a')).toBe(false)
@@ -254,7 +254,7 @@ describe('Beef tests', () => {
       }
     })
 
-    test('5_AtomicBeef', async () => {
+    test('7_AtomicBeef', async () => {
       {
         const beef = Beef.fromString(beefs[0])
         expect(beef.toHex()).toBe(beefs[0])
@@ -291,6 +291,20 @@ describe('Beef tests', () => {
         expect(beef2.toHex()).toBe(beefHex)
       }
     })
+
+    test('8_toBinaryAtomic', async () => {
+      {
+        const beef = Beef.fromString(beefs[0])
+        const tx = Transaction.fromHex(txs[0])
+        beef.mergeTransaction(tx)
+        const sr = beef.sortTxs()
+        const log = beef.toLogString()
+        const atomic = beef.toBinaryAtomic(tx.id('hex'))
+        const t2 = Transaction.fromAtomicBEEF(atomic)
+        const beef2 = t2.toAtomicBEEF()
+        expect(atomic).toEqual(beef2)
+      }
+    })
 })
 
 const txs: string[] = [

package/src/transaction/http/DefaultHttpClient.ts

@@ -16,7 +16,7 @@ export function defaultHttpClient (): HttpClient {
 
   if (typeof window !== 'undefined' && typeof window.fetch === 'function') {
     // Use fetch in a browser environment
-    return new FetchHttpClient(window.fetch)
+    return new FetchHttpClient(window.fetch.bind(window))
   } else if (typeof require !== 'undefined') {
     // Use Node.js https module
     // eslint-disable-next-line