@bsv/sdk 1.1.1 → 1.1.2

package/docs/examples/EXAMPLE_SCRIPT_TEMPLATES.md

@@ -1,170 +0,0 @@
-# Example: Creating the R-puzzle Script Template
-
-This guide will provide information about the structure and functionality of script templates within the BSV SDK. Script templates are a powerful abstraction layer designed to simplify the creation and management of the scripts used in Bitcoin transactions. By understanding how these templates work, developers can leverage them to build more sophisticated and efficient blockchain applications. By the end of this example, you'll understand how the R-puzzle script template (P2RPH) was created.
-
-### Understanding Script Templates
-
-A script template is essentially a blueprint for creating the locking and unlocking scripts that are crucial for securing and spending bitcoins. These templates encapsulate the logic needed to construct these scripts dynamically, based on the parameters passed to them. This approach allows for a modular and reusable codebase, where common scripting patterns can be defined once and then instantiated as needed across different transactions.
-
-#### Locking Script
-
-The locking script, or output script, specifies the conditions under which the bitcoins can be spent. In the BSV SDK, the `lock` function of a script template is responsible for generating this script. By abstracting the creation of locking scripts into a method that accepts parameters, developers can easily create diverse conditions for spending bitcoins without having to write the low-level script code each time.
-
-For example, a locking script might require the presentation of a public key that matches a certain hash or the fulfillment of a multi-signature condition. The flexibility of passing parameters to the `lock` function enables the creation of locking scripts tailored to specific requirements. This example will require a signature created with a particular ephemeral K-value, [an R-puzzle](https://wiki.bitcoinsv.io/index.php/R-Puzzles).
-
-#### Unlocking Script
-
-The unlocking script, or input script, provides the evidence needed to satisfy the conditions set by the locking script. The `unlock` method in a script template not only generates this script but also offers two key functionalities — it's a function that returns an object with two properties:
-
-1. **`estimateLength`**: Before a transaction is signed and broadcast to the network, it's crucial to estimate its size to calculate the required fee accurately. The `estimateLength` function predicts the length of the unlocking script once it will be created, allowing developers to make informed decisions about fee estimation.
-
-2. **`sign`**: This function generates an unlocking script that includes the necessary signatures or data required to unlock the bitcoins. By accepting a transaction and an input index as arguments, it ensures that the unlocking script is correctly associated with the specific transaction input it intends to fund, allowing signatures to be scoped accordingly.
-
-### Creating a Script Template
-
-To create a script template, developers define a class that adheres to the `ScriptTemplate` interface. This involves implementing the `lock` and `unlock` methods with the specific logic needed for their application.
-
-Now that you understand the necessary components, here's the code for the R-puzzle script template:
-
-```javascript
-import {
-  OP, ScriptTemplate, LockingScript, UnlockingScript, Transaction,
-  PrivateKey, TransactionSignature, sha256, ScriptChunk, BigNumber
-} from '@bsv/sdk'
-
-/**
- * RPuzzle class implementing ScriptTemplate.
- *
- * This class provides methods to create R Puzzle and R Puzzle Hash locking and unlocking scripts, including the unlocking of UTXOs with the correct K value.
- */
-export default class RPuzzle implements ScriptTemplate {
-  type: 'raw' | 'SHA1' | 'SHA256' | 'HASH256' | 'RIPEMD160' | 'HASH160' = 'raw'
-
-  /**
-   * @constructor
-   * Constructs an R Puzzle template instance for a given puzzle type
-   *
-   * @param {'raw'|'SHA1'|'SHA256'|'HASH256'|'RIPEMD160'|'HASH160'} type Denotes the type of puzzle to create
-   */
-  constructor (type: 'raw' | 'SHA1' | 'SHA256' | 'HASH256' | 'RIPEMD160' | 'HASH160' = 'raw') {
-    this.type = type
-  }
-
-  /**
-   * Creates an R puzzle locking script for a given R value or R value hash.
-   *
-   * @param {number[]} value - An array representing the R value or its hash.
-   * @returns {LockingScript} - An R puzzle locking script.
-   */
-  lock (value: number[]): LockingScript {
-    const chunks: ScriptChunk[] = [
-      { op: OP.OP_OVER },
-      { op: OP.OP_3 },
-      { op: OP.OP_SPLIT },
-      { op: OP.OP_NIP },
-      { op: OP.OP_1 },
-      { op: OP.OP_SPLIT },
-      { op: OP.OP_SWAP },
-      { op: OP.OP_SPLIT },
-      { op: OP.OP_DROP }
-    ]
-    if (this.type !== 'raw') {
-      chunks.push({
-        op: OP['OP_' + this.type]
-      })
-    }
-    chunks.push({ op: value.length, data: value })
-    chunks.push({ op: OP.OP_EQUALVERIFY })
-    chunks.push({ op: OP.OP_CHECKSIG })
-    return new LockingScript(chunks)
-  }
-
-  /**
-   * Creates a function that generates an R puzzle unlocking script along with its signature and length estimation.
-   *
-   * The returned object contains:
-   * 1. `sign` - A function that, when invoked with a transaction and an input index,
-   *    produces an unlocking script suitable for an R puzzle locked output.
-   * 2. `estimateLength` - A function that returns the estimated length of the unlocking script in bytes.
-   *
-   * @param {BigNumber} k — The K-value used to unlock the R-puzzle.
-   * @param {PrivateKey} privateKey - The private key used for signing the transaction. If not provided, a random key will be generated.
-   * @param {'all'|'none'|'single'} signOutputs - The signature scope for outputs.
-   * @param {boolean} anyoneCanPay - Flag indicating if the signature allows for other inputs to be added later.
-   * @returns {Object} - An object containing the `sign` and `estimateLength` functions.
-   */
-  unlock (
-    k: BigNumber,
-    privateKey: PrivateKey,
-    signOutputs: 'all' | 'none' | 'single' = 'all',
-    anyoneCanPay: boolean = false
-  ): {
-      sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
-      estimateLength: () => Promise<106>
-    } {
-    return {
-      sign: async (tx: Transaction, inputIndex: number) => {
-        if (typeof privateKey === 'undefined') {
-          privateKey = PrivateKey.fromRandom()
-        }
-        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 otherInputs = [...tx.inputs]
-        const [input] = otherInputs.splice(inputIndex, 1)
-        if (typeof input.sourceTransaction !== 'object') {
-          throw new Error(
-            'The source transaction is needed for transaction signing.'
-          )
-        }
-        const preimage = TransactionSignature.format({
-          sourceTXID: input.sourceTransaction.id('hex') as string,
-          sourceOutputIndex: input.sourceOutputIndex,
-          sourceSatoshis: input.sourceTransaction.outputs[input.sourceOutputIndex].satoshis,
-          transactionVersion: tx.version,
-          otherInputs,
-          inputIndex,
-          outputs: tx.outputs,
-          inputSequence: input.sequence,
-          subscript: input.sourceTransaction.outputs[input.sourceOutputIndex].lockingScript,
-          lockTime: tx.lockTime,
-          scope: signatureScope
-        })
-        const rawSignature = privateKey.sign(sha256(preimage), undefined, true, k)
-        const sig = new TransactionSignature(
-          rawSignature.r,
-          rawSignature.s,
-          signatureScope
-        )
-        const sigForScript = sig.toChecksigFormat()
-        const pubkeyForScript = privateKey.toPublicKey().encode(true) as number[]
-        return new UnlockingScript([
-          { op: sigForScript.length, data: sigForScript },
-          { op: pubkeyForScript.length, data: pubkeyForScript }
-        ])
-      },
-      estimateLength: async () => {
-        // public key (1+33) + signature (1+71)
-        // Note: We add 1 to each element's length because of the associated OP_PUSH
-        return 106
-      }
-    }
-  }
-}
-```
-
-In this example, `RPuzzle` defines custom logic for creating both locking and unlocking scripts. The opcodes, intermixed with the various template fields, enable end-users to implement R-puzzles into their applications without being concerned with these low-level details. Check out [this guide](./EXAMPLE_COMPLEX_TX.md) to see an example of this template used in a transaction.
-
-### Conclusion
-
-Script templates in the BSV SDK offer a structured and efficient way to handle the creation of locking and unlocking scripts in Bitcoin transactions. By encapsulating the logic for script generation and providing essential functionalities like signature creation and length estimation, script templates make it easier for developers to implement complex transactional logic. With these tools, template consumers can focus on the higher-level aspects of their blockchain applications, relying on the SDK to manage the intricacies of script handling.

package/docs/examples/EXAMPLE_SIMPLE_TX.md

@@ -1,145 +0,0 @@
-# Example: Creating a Simple Transaction
-
-This guide walks you through the steps of creating a simple Bitcoin transaction. To get started, let's explain some basic concepts around Bitcoin transactions.
-
-## Understanding and Creating Transactions
-
-Transactions in Bitcoin are mechanisms for transferring value and invoking smart contract logic. The `Transaction` class in the BSV SDK encapsulates the creation, signing, and broadcasting of transactions, also enabling the use of Bitcoin's scripting language for locking and unlocking coins.
-
-## Creating and Signing a Transaction
-
-Consider the scenario where you need to create a transaction. The process involves specifying inputs (where the bitcoins are coming from) and outputs (where they're going). Here's a simplified example:
-
-```typescript
-import { Transaction, PrivateKey, PublicKey, P2PKH, ARC } from '@bsv/sdk'
-
-const privKey = PrivateKey.fromWif('...') // Your P2PKH private key
-const changePrivKey = PrivateKey.fromWif('...') // Change private key (never re-use addresses)
-const recipientAddress = '1Fd5F7XR8LYHPmshLNs8cXSuVAAQzGp7Hc' // Address of the recipient
-
-const tx = new Transaction()
-
-// Add the input
-tx.addInput({
-  sourceTransaction: Transaction.fromHex('...'), // The source transaction where the output you are spending was created,
-  sourceOutputIndex: 0, // The output index in the source transaction
-  unlockingScriptTemplate: new P2PKH().unlock(privKey), // The script template you are using to unlock the output, in this case P2PKH
-})
-
-// Pay an output to a recipient using the P2PKH locking template
-tx.addOutput({
-  lockingScript: new P2PKH().lock(recipientAddress),
-  satoshis: 2500
-})
-
-// Send remainder back the change
-tx.addOutput({
-  lockingScript: new P2PKH().lock(changePrivKey.toPublicKey().toHash()),
-  change: true
-})
-
-// Now we can compute the fee and sign the transaction
-await tx.fee()
-await tx.sign()
-
-// Finally, we broadcast it with ARC.
-// get your api key from https://console.taal.com
-const apiKey = 'mainnet_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx' // replace
-await tx.broadcast()
-```
-
-This code snippet demonstrates creating a transaction, adding an input and an output, setting a change script, configuring the fee, signing the transaction, and broadcasting with the ARC broadcaster. It uses the P2PKH Template, which is a specific type of Bitcoin locking program. To learn more about templates, check out this example (link to be provided once cmpplete).
-
-## Handling Hex Locking Scripts
-
-Moving beyond this basic example into more advanced use-cases enables you to start dealing with custom scripts. If you're provided with a hex-encoded locking script for an output, you can set it directly in the transaction's output as follows:
-
-```typescript
-transaction.addOutput({
-  lockingScript: Script.fromHex('76a9....88ac'), // Hex-encoded locking script
-  satoshis: 2500 // Number of satoshis
-})
-```
-
-The `Transaction` class abstracts the complexity of Bitcoin's transaction structure. It handles inputs, outputs, scripts, and serialization, offering methods to easily modify and interrogate the transaction. Check out the full code-level documentation, refer to other examples, or reach out to the community to learn more.
-
-## Choosing broadcasting target (ARC or WhatsOnChain)
-
-### ARC
-
-You can broadcast via selected ARC by providing ARC instance to the `broadcast` method.
-
-```typescript
-await tx.broadcast(new ARC('https://api.taal.com/arc', apiKey))
-```
-
-### WhatsOnChain
-
-You can broadcast via What's On Chain by providing WhatsOnChainBroadcaster instance to the `broadcast` method.
-
-```typescript
-const network = 'main' // or 'test'
-await tx.broadcast(new WhatsOnChainBroadcaster(network))
-```
-
-## Use custom http client for broadcasting
-
-The ARC broadcaster requires an HTTP client to broadcast transactions. By default, the SDK will try to search for `window.fetch` in browser or `https` module on Node.js. 
-If you want to use a custom (or preconfigured) HTTP client, you can pass it with use of the adapter the ARC constructor:
-
-### fetch
-
-```typescript
-// In this example we're assuming you have variable fetch holding the fetch function`
-
-const arc = new ARC('https://api.taal.com/arc', apiKey, new FetchHttpClient(mockFetch))
-```
-
-### https
-
-Because ARC is assuming concrete interface of the http client, we're providing an adapter for https module. 
-You can use it as follows:
-
-```typescript
-// In this example we're assuming you have variable https holding the https module loaded for example with `require('https')`
-
-const arc = new ARC('https://api.taal.com/arc', apiKey, new NodejsHttpClient(https))
-
-```
-
-### axios
-
-Although the SDK is not providing adapters for axios, it can be easily used with the ARC broadcaster. 
-You can make your own "adapter" for axios as follows:
-
-```typescript
-const axiosHttpClient =   const httpClient: HttpClient = {
-  request: async (...args) => {
-    let res;
-    try {
-      res = await axios(...args);
-    } catch (e: unknown) {
-      if (axios.isAxiosError(e)) {
-        res = e.response;
-      } else {
-        throw e;
-      }
-    }
-    if (!res) {
-      throw new Error('No response');
-    }
-    return {
-      ok: res.status >= 200 && res.status <= 299,
-      ...res
-    };
-  },
-};
-
-new ARC('https://api.taal.com/arc', apiKey, axiosHttpClient) 
-```
-
-### other libraries
-
-Although the SDK is not providing adapters for other libraries, 
-you can easily create your own adapter by implementing the `HttpClient` interface.
-Please look at the example for axios above to see how easy it can be done.

package/docs/examples/EXAMPLE_TYPE_42.md

@@ -1,108 +0,0 @@
-# Example: Using Type 42 Key Derivation for Bitcoin Wallet Management
-
-Welcome to this type-42 key derivation guide! We're glad you're here, especially if you're migrating from an older key derivation system. Type-42 is more private, more elegant and it's easy to understand.
-
-This guide will walk you through using type-42 keys in the context of a Bitcoin wallet.
-
-## Generating keys
-
-Generating type-42 keys with the SDK is identical to generating normal private keys. Secretly, every private key (and public key) in the SDK is already a type-42 key!
-
-```typescript
-import { PrivateKey } from '@bsv/sdk'
-
-const privateKey = PrivateKey.fromRandom()
-```
-
-Now, we can move on to key derivation.
-
-## Type 42 Key Derivation
-
-In type-42 systems, you provide a counterparty key when deriving, as well as your own. There is always one public key and one private key. It's either:
-
-- Your private key and the public key of your counterparty are used to derive one of your private keys, or
-- Your private key and the public key of your counterparty are used to derive one of their public keys
-
-When you and your counterparty use the same invoice number to derive keys, the public key you derive for them will correspond to the private key they derive for themselves. A private key that you derive for yourself will correspond to the public key they derived for you.
-
-Once you understand those concepts, we're ready to jump into some code!
-
-### Alice and Bob
-
-Let's consider the scenario of Alice and Bob, who want to exchange some Bitcoin. How can Alice send Bitcoins to Bob?
-
-1. Alice learns Bob's master public key, and they agree on the Bitcoin aount to exchange.
-2. They also agree on an invoice number.
-3. Alice uses Bob's master public key with her private key to derive the payment key she will use.
-4. Alice creates a Bitcoin transaction and pays Bob the money.
-5. Bob uses Alice's public key and his own private key to derive the corresponding private key, verifying it matches the transaction Alice sent him.
-
-Here's an example:
-
-```typescript
-// Alice and Bob have master private keys...
-const alice = PrivateKey.fromRandom()
-const bob = PrivateKey.fromRandom()
-alice.toString()
-'106674548343907642146062962636638307981249604845652704224160905817279514790351'
-bob.toString()
-'108446104340374144960104248963000752145648236191076545713737995455205583156408'
-
-// ... and master public keys
-const alicePub = alice.toPublicKey()
-const bobPub = bob.toPublicKey()
-alicePub.toString()
-'0260846fbaf8e950c1896d360954a716f26699252b879fea1743a9f78a0950d167'
-bobPub.toString()
-'0258bfa42bd832c4ab655295cac5e2f64daefb2b4cd9a2b72bdd3c3f9ba5076cb7'
-
-// To pay Alice, they agree on an invoice number and then Bob derives a key where he can pay Alice
-const paymentKey = alicePub.deriveChild(bob, 'AMZN-44-1191213')
-
-// The key can be converted to an address if desired
-paymentKey2.toAddress()
-'1HqfEfHNF9ji9p3AEC66mj8fhGA7sy2WYT'
-
-// To unlock the coins, Alice derives the private key with the same invoice number, using Bob's public key
-const paymentPriv = alice.deriveChild(bobPub, 'AMZN-44-1191213')
-
-// The key can be converted to WIF if desired
-paymentPriv.toWif()
-'L22stYh323a8DfBNunLvxrcrxudT2YXjdKxe1q9ecARYT9XfFGGc'
-
-// To check, Alice can convert the private key back into an address.
-paymentPriv.toPublicKey().toAddress()
-'1HqfEfHNF9ji9p3AEC66mj8fhGA7sy2WYT'
-```
-
-This provides privacy for Alice and Bob, even if eeryone in the world knows Alice and Bob's master public keys.
-
-## Going Further: Public Derivation
-
-Sometimes, there is a legitimate reason to do "public key derivation" from a key, so that anyone can link a master key to a child key, like in BIP32. To accomplish this, rather than creating a new algorithm, we just use a private key that everyone already knows: the number `1`.
-
-```typescript
-alicePub.deriveChild(new PrivateKey(1), '1').toString()
-'0391ff4958a6629be3176330bed0efd99d860f2b7630c21b2e33a42f3cd1740544'
-alicePub.deriveChild(new PrivateKey(1), '2').toString()
-'022ea65d6d66754dc7d94e197dab31a4a8854cdb28d57f216e765af7dfddb5322d'
-alicePub.deriveChild(new PrivateKey(1), 'Bitcoin SV').toString()
-'039e9bf79f4cf7accc061d570b1282bd24d2045be44584e8c6744cd3ff42e1758c'
-alicePub.deriveChild(new PrivateKey(1), '2-tempo-1').toString() // BRC-43 :)
-'02fd1e62689b7faaa718fabe9593da718fb2f966a9b391e5c48f25b1f9fbd4e770'
-```
-
-Because everyone knows the number `1`, everyone can derive Alice's public keys with these invoice numbers. But only Alice can derive the corresponding private keys:
-
-```typescript
-alice.deriveChild(new PrivateKey(1).toPublicKey(), '1').toString()
-'5097922263303694608415912843049723146488598519566487750842578489217455687866'
-alice.deriveChild(new PrivateKey(1).toPublicKey(), '2').toString()
-'30335387255051916743526252561695774618041865683431443265879198629898915116869'
-alice.deriveChild(new PrivateKey(1).toPublicKey(), 'Bitcoin SV').toString()
-'78577766545688955856149390014909118010252835780550951683873199149559002824861'
-alice.deriveChild(new PrivateKey(1).toPublicKey(), '2-tempo-1').toString() // BRC-43 :)
-'85481526811941870977151386860102277207605069038305420293413543998866547111586'
-```
-
-The type-42 system enables both public and private key derivation, all while providing a more flexible and open-ended invoice numbering scheme than BIP32.

package/docs/examples/EXAMPLE_UTXOS_TX.md

@@ -1,85 +0,0 @@
-# Example: Creating a Transaction from UTXOs
-
-This guide shows how to create a transaction from UTXOs fetched from WhatsOnChain.
-It also shows how to set a fixed fee and build OP_RETURN outputs.
-
-## The UTXOs format
-
-Although its not a standard, UTXOs can be fetched from apis like [WhatsOnChain](https://whatsonchain.com/) in a similar format.
-
-```typescript
-/** Utxos from whatsonchain api*/
-const utxos = [
-  {
-    height: 1600000,
-    tx_pos: 0,
-    tx_hash: '672dd6a93fa5d7ba6794e0bdf8b479440b95a55ec10ad3d9e03585ecb5628d8f',
-    value: 10000
-  },
-  {
-    height: 1600000,
-    tx_pos: 0,
-    tx_hash: 'f33505acf37a7726cc37d391bc6f889b8684ac2a2d581c4be2a4b1c8b46609bb',
-    value: 10000
-  },
-]
-```
-
-## Building a transaction from UTXOs
-
-The first step is to build a transaction and add inputs from the utxos related to the private key `priv`.
-
-```typescript
-import { Transaction, PrivateKey, P2PKH, LockingScript, Utils, OP } from '@bsv/sdk'
-
-const priv = PrivateKey.fromWif('...')
-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)
-  })
-})
-```
-
-## Adding the outputs
-
-Next an OP_RETURN output script is added along with a change address to the original `priv`, note that addresses should not be reused as its not a good practice.
-
-```typescript
-const data = Utils.toArray('some data')
-const script = [
-  { op: OP.OP_FALSE },
-  { op: OP.OP_RETURN },
-  { op: data.length, data }
-]
-
-// Add the new OP_RETURN script as output
-tx.addOutput({
-  lockingScript: new LockingScript(script),
-  satoshis: 0
-})
-
-// Add a change output to the used private key
-tx.addOutput({
-  lockingScript: new P2PKH().lock(priv.toAddress()),
-  change: true
-})
-```
-
-## Finalize the transaction
-
-Last step is to set the transaction fee, sign the transaction and broadcast it.
-
-```typescript
-await tx.fee(10) // a fixed fee of 10 sats is used
-await tx.sign()
-await tx.broadcast()
-```
-
-That concludes this basic example but common practice to create a transaction from UTXOs. Refer to other examples for instructions on how to calculate fees from transaction size, use different locking script templates, different broadcast services and more.

package/docs/examples/EXAMPLE_VERIFYING_BEEF.md

@@ -1,62 +0,0 @@
-# Example: Verifying a BEEF Structure
-
-The BSV SDK comes with advanced capabilities around the SPV architecture. In Bitcoin, SPV refers to the process of creating, exchanging, and verifying transactions in a way that anchors them to the blockchain. One of the standard formats for representing the necessary SPV data is known as BEEF (background-evaluated extended format), representing a transaction and its parents together with needed merkle proofs. This example will show you how to verify the legitimacy of a BEEF-formatted SPV structure you've received, checking to ensure the target transaction and its ancestors are well-anchored to the blockchain based on the current chain of block headers. First we'll unpack these concepts, then we'll dive into the code.
-
-## Block Headers and Merkle Proofs
-
-In Bitcoin, miners create blocks. These blocks comprise merkle trees of the included transactions. The root of the merkle tree, together with other useful information, is collected together into a block header that can be used to verify the block's proof-of-work. This merkle tree structure enables anyone to keep track of the chain of block headers without keeping a copy of every Bitcoin transaction.
-
-Merkle proofs are simply a way for someone to prove the existence of a given transaction within a given merkle tree, and by extension, its inclusion by the miners in a particular block of the blockchain. This becomes extremely important and useful when we think about Simplified Payment Verification (SPV).
-
-## Simplified Payment Verification (SPV)
-
-The process for SPV is detailed in [BRC-67](https://github.com/bitcoin-sv/BRCs/blob/master/transactions/0067.md), but the main idea is that when a sender sends a transaction, they include merkle proofs on all of the input transactions. This allows anyone with a copy of the Bitcoin block headers to check that the input transactions are included in the blockchain. Verifiers then check that all the input and output scripts correctly transfer value from one party to the next, ensuring an unbroken chain of spends. The [BEEF data structure](https://github.com/bitcoin-sv/BRCs/blob/master/transactions/0062.md) provides a compact and efficient way for people to represent the data required to perform SPV. 
-
-## Verifying a BEEF Structure
-
-Now that you have access to a block headers client (either Pulse on a real project or the above code for a toy example), we can proceed to verifying the BEEF structure with the following code:
-
-```typescript
-import { Transaction } from '@bsv/sdk'
-
-// Replace with the BEEF structure you'd like to check
-const BEEFHex = '0100beef01fe636d0c0007021400fe507c0c7aa754cef1f7889d5fd395cf1f785dd7de98eed895dbedfe4e5bc70d1502ac4e164f5bc16746bb0868404292ac8318bbac3800e4aad13a014da427adce3e010b00bc4ff395efd11719b277694cface5aa50d085a0bb81f613f70313acd28cf4557010400574b2d9142b8d28b61d88e3b2c3f44d858411356b49a28a4643b6d1a6a092a5201030051a05fc84d531b5d250c23f4f886f6812f9fe3f402d61607f977b4ecd2701c19010000fd781529d58fc2523cf396a7f25440b409857e7e221766c57214b1d38c7b481f01010062f542f45ea3660f86c013ced80534cb5fd4c19d66c56e7e8c5d4bf2d40acc5e010100b121e91836fd7cd5102b654e9f72f3cf6fdbfd0b161c53a9c54b12c841126331020100000001cd4e4cac3c7b56920d1e7655e7e260d31f29d9a388d04910f1bbd72304a79029010000006b483045022100e75279a205a547c445719420aa3138bf14743e3f42618e5f86a19bde14bb95f7022064777d34776b05d816daf1699493fcdf2ef5a5ab1ad710d9c97bfb5b8f7cef3641210263e2dee22b1ddc5e11f6fab8bcd2378bdd19580d640501ea956ec0e786f93e76ffffffff013e660000000000001976a9146bfd5c7fbe21529d45803dbcf0c87dd3c71efbc288ac0000000001000100000001ac4e164f5bc16746bb0868404292ac8318bbac3800e4aad13a014da427adce3e000000006a47304402203a61a2e931612b4bda08d541cfb980885173b8dcf64a3471238ae7abcd368d6402204cbf24f04b9aa2256d8901f0ed97866603d2be8324c2bfb7a37bf8fc90edd5b441210263e2dee22b1ddc5e11f6fab8bcd2378bdd19580d640501ea956ec0e786f93e76ffffffff013c660000000000001976a9146bfd5c7fbe21529d45803dbcf0c87dd3c71efbc288ac0000000000'
-
-// You can create a Transaction from BEEF hex directly
-const tx = Transaction.fromHexBEEF(BEEFHex)
-
-// This ensures the BEEF structure is legitimate
-const verified = await tx.verify()
-
-// Print the results
-console.log(verified)
-```
-
-The above code allows you to ensure that a given BEEF structure is valid according to the rules of SPV.
-
-## Chain tracker
-
-To verify BEEF structures with the BSV SDK, you'll need to provide a block headers client that, given a merkle root, will indicate to the library whether the merkle root is correct for the block that's in the active chain at the given block height.
-
-The TypeScript BSV SDK does provides default implementation of the chain tracker that use What's On Chain API. 
-
-### What's On Chain configuration
-
-#### BSV network
-
-The default network for the chain tracker is `main`. You can change it to other network by providing the instance of WhatsOnChain ChainTracker configured for other network to `.verify()` method.
-
-```typescript
-tx.verify(new WhatsOnChain())
-```
-
-#### Api Key
-
-It is possible to use WhatsOnChain ChainTracker with obtained API KEY of [WhatsOnChain](https://docs.taal.com/core-products/whatsonchain). 
-To do so, you need to provide to `.verify()` method the custom instance of WhatsOnChain ChainTracker with the API KEY.
-
-```typescript
-import { Transaction, WhatsOnChain } from '@bsv/sdk'
-
-tx.verify(new WhatsOnChain('main', {apiKey: 'YOUR_API_KEY'}))
-```

package/docs/examples/EXAMPLE_VERIFYING_ROOTS.md

@@ -1,97 +0,0 @@
-# Example: Building a Pulse Block Headers Client
-
-When [verifying BEEF structures](EXAMPLE_VERIFYING_BEEF.md), it's necessary to ensure that all transactions are well-anchored: this is to say, that they come from inputs in the honest chain. The SDK doesn't ship with a headers client, but this guide shows an example of how to use it with [block-headers-service](https://github.com/bitcoin-sv/block-headers-service): a popular client suitable for a wide range of use-cases.
-
-## Pre-requisites
-
-As stated in the README, you will need to be running a Pulse instance. Get it up and running, and configure a level of authentication appropriate for your use-case:
-
-```sh
-docker pull bsvb/block-headers-service
-docker run bsvb/block-headers-service:latest
-```
-
-## Building our Client
-
-The SDK's `ChainTracker` interface defines the required structure for our implementation, as follows:
-
-```typescript
-/**
- * The Chain Tracker is responsible for verifying the validity of a given Merkle root
- * for a specific block height within the blockchain.
- *
- * Chain Trackers ensure the integrity of the blockchain by
- * validating new headers against the chain's history. They use accumulated
- * proof-of-work and protocol adherence as metrics to assess the legitimacy of blocks.
- *
- * @interface ChainTracker
- * @function isValidRootForHeight - A method to verify the validity of a Merkle root
- *          for a given block height.
- *
- * @example
- * const chainTracker = {
- *   isValidRootForHeight: async (root, height) => {
- *     // Implementation to check if the Merkle root is valid for the specified block height.
- *   }
- * };
- */
-export default interface ChainTracker {
-  isValidRootForHeight: (root: string, height: number) => Promise<boolean>
-}
-
-```
-
-Given an array of merkle roots and corresponding block heights, we return a boolean indicating whether they're all valid.
-
-We can plug in the Block Header Service API with appropriate HTTP handling logic as follows:
-
-```typescript
-import {defaultHttpClient} from "@bsv/sdk";
-
-/**
- * Represents a Block Headers Client.
- */
-export default class BlockHeadersClient implements ChainTracker {
-  URL: string
-  apiKey: string
-
-  /**
-   * Constructs an instance of the Pulse chain tracker.
-   *
-   * @param {string} URL - The URL endpoint for the Pulse API.
-   * @param {string} apiKey - The API key used for authorization with the Pulse API.
-   */
-  constructor(URL: string, apiKey: string) {
-    this.URL = URL
-    this.apiKey = apiKey
-    this.httpClient = defaultHttpClient()
-  }
-
-  /**
-   * Checks a set of merkle roots with corresponding heights.
-   *
-   * @param root: string - The merkle root to check
-   * @param height: number - The corresponding height
-   * @returns {Promise<boolean>} A promise that resolves to either a success or failure response (true or false).
-   */
-  async isValidRootForHeight(root: string, height: number): Promise<boolean> {
-    const response = await httpsClient(`${this.URL}/api/v1/chain/merkleroot/verify`, {
-      method: 'POST',
-      body: [{merkleRoot: root, blockHeight: height}],
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${this.apiKey}`
-      }
-    })
-    if (response.ok) {
-      return response.data?.confirmationState === 'CONFIRMED'
-    } else {
-      throw new Error(`Failed to verify root at height ${height} with response ${response.status}`)
-    }
-  }
-}
-```
-
-Now, we can use our `BlockHeadersClient` as a `ChainTracker` when calling the `Transaction` object's `.verify()` method. You can see an example in the [BEEF verification guide](EXAMPLE_VERIFYING_BEEF.md).
-
-This provides the ability to ensure that a transaction is well-anchored.