@bsv/sdk 1.1.1 → 1.1.3

package/docs/examples/EXAMPLE_FEE_MODELING.md

@@ -1,199 +0,0 @@
-# Example: Creating a Custom Transaction Fee Model
-
-Bitcoin miners accept transactions into a block when they pay an appropriate fee. The transaction fee is simply the difference between the amounts used as input, and the amounts claimed by transaction outputs. This is to say, any amount of Bitcoins that are unclaimed (left over) after all transaction outputs have been fulfilled is given to the miner who solves the block in which the transaction is included.
-
-To date, fees have generally been measured in satoshis per kilobyte of block space used by the transaction. However, the SDK allows you to create custom fee models that take other factors into account. This guide will show you the default fee model, and discuss how it might be customized in the future. Note that you'll need to consult with various miners if considering an alternative fee model, to make sure your transactions would still be included in the blockchain.
-
-## Default Fee Model
-
-The `.fee()` method on a `Transaction` object takes a fee model as an optional parameter. The function of a fee model is to compute the number of satoshis that the transaction should pay in fees. Here's the interface all fee models need to follow:
-
-```typescript
-/**
- * Represents the interface for a transaction fee model.
- * This interface defines a standard method for computing a fee when given a transaction.
- *
- * @interface
- * @property {function} computeFee - A function that takes a Transaction object and returns a BigNumber representing the number of satoshis the transaction should cost.
- */
-export default interface FeeModel {
-  computeFee: (transaction: Transaction) => Promise<number>
-}
-
-```
-
-In short, a fee model is an object with a `computeFee` function that, when called with a `Transaction` as its first and only parameter, will return a `Promise` for a `number` of satoshis.
-
-The default fee model, used if no other model is provided, looks like this:
-
-```typescript
-/**
- * Represents the "satoshis per kilobyte" transaction fee model.
- */
-export default class SatoshisPerKilobyte implements FeeModel {
-  /**
-   * @property
-   * Denotes the number of satoshis paid per kilobyte of transaction size.
-   */
-  value: number
-
-  /**
-   * Constructs an instance of the sat/kb fee model.
-   *
-   * @param {number} value - The number of satoshis per kilobyte to charge as a fee.
-   */
-  constructor(value: number) {
-    this.value = value
-  }
-
-  /**
-   * Computes the fee for a given transaction.
-   *
-   * @param tx The transaction for which a fee is to be computed.
-   * @returns The fee in satoshis for the transaction, as a number.
-   */
-  async computeFee(tx: Transaction): Promise<number> {
-    const getVarIntSize = (i: number): number => {
-      if (i > 2 ** 32) {
-        return 9
-      } else if (i > 2 ** 16) {
-        return 5
-      } else if (i > 253) {
-        return 3
-      } else {
-        return 1
-      }
-    }
-    // Compute the (potentially estimated) size of the transaction
-    let size = 4 // version
-    size += getVarIntSize(tx.inputs.length) // number of inputs
-    for (let i = 0; i < tx.inputs.length; i++) {
-      const input = tx.inputs[i]
-      size += 40 // txid, output index, sequence number
-      let scriptLength: number
-      if (typeof input.unlockingScript === 'object') {
-        scriptLength = input.unlockingScript.toBinary().length
-      } else if (typeof input.unlockingScriptTemplate === 'object') {
-        scriptLength = await input.unlockingScriptTemplate.estimateLength(tx, i)
-      } else {
-        throw new Error('All inputs must have an unlocking script or an unlocking script template for sat/kb fee computation.')
-      }
-      size += getVarIntSize(scriptLength) // unlocking script length
-      size += scriptLength // unlocking script
-    }
-    size += getVarIntSize(tx.outputs.length) // number of outputs
-    for (const out of tx.outputs) {
-      size += 8 // satoshis
-      const length = out.lockingScript.toBinary().length
-      size += getVarIntSize(length) // script length
-      size += length // script
-    }
-    size += 4 // lock time
-    // We'll use Math.ceil to ensure the miners get the extra satoshi.
-    const fee = Math.ceil((size / 1000) * this.value)
-    return fee
-  }
-}
-```
-
-Here, you can see we're computing the size of the transaction in bytes, then computing the number of satoshis based on the number of kilobytes.
-
-## Making Adjustments
-
-Let's modify our fee model to check for a few custom cases, just as a purely theoretical example:
-
-- If the version of the transaction is 3301, the transaction is free.
-- If there are more than 3x as many inputs as there are outputs (the transaction is helping shrink the number of UTXOs), the transaction gets a 20% discount.
-- If there are more than 5x as many outputs as there are inputs, the transaction is 10% more expensive.
-- Other than that, the rules are the same as the Satoshis per Kilobyte fee model.
-
-With these rules in place, let's build a custom fee model!
-
-```typescript
-/**
- * Represents the "example" transaction fee model.
- */
-export default class Example implements FeeModel {
-  /**
-   * @property
-   * Denotes the base number of satoshis paid per kilobyte of transaction size.
-   */
-  value: number
-
-  /**
-   * Constructs an instance of the example fee model.
-   *
-   * @param {number} value - The base number of satoshis per kilobyte to charge as a fee.
-   */
-  constructor(value: number) {
-    this.value = value
-  }
-
-  /**
-   * Computes the fee for a given transaction.
-   *
-   * @param tx The transaction for which a fee is to be computed.
-   * @returns The fee in satoshis for the transaction, as a number.
-   */
-  async computeFee(tx: Transaction): Promise<number> {
-    const getVarIntSize = (i: number): number => {
-      if (i > 2 ** 32) {
-        return 9
-      } else if (i > 2 ** 16) {
-        return 5
-      } else if (i > 253) {
-        return 3
-      } else {
-        return 1
-      }
-    }
-
-    // Version 3301 transactions are free :)
-    if (tx.version === 3301) {
-        return 0
-    }
-
-    // Compute the (potentially estimated) size of the transaction
-    let size = 4 // version
-    size += getVarIntSize(tx.inputs.length) // number of inputs
-    for (let i = 0; i < tx.inputs.length; i++) {
-      const input = tx.inputs[i]
-      size += 40 // txid, output index, sequence number
-      let scriptLength: number
-      if (typeof input.unlockingScript === 'object') {
-        scriptLength = input.unlockingScript.toBinary().length
-      } else if (typeof input.unlockingScriptTemplate === 'object') {
-        scriptLength = await input.unlockingScriptTemplate.estimateLength(tx, i)
-      } else {
-        throw new Error('All inputs must have an unlocking script or an unlocking script template for sat/kb fee computation.')
-      }
-      size += getVarIntSize(scriptLength) // unlocking script length
-      size += scriptLength // unlocking script
-    }
-    size += getVarIntSize(tx.outputs.length) // number of outputs
-    for (const out of tx.outputs) {
-      size += 8 // satoshis
-      const length = out.lockingScript.toBinary().length
-      size += getVarIntSize(length) // script length
-      size += length // script
-    }
-    size += 4 // lock time
-    let fee = ((size / 1000) * this.value)
-
-    // Now we apply our input and output rules
-    // For the inputs incentive
-    if (tx.inputs.length / 3 >= tx.outputs.length) {
-        fee *= 0.8
-    }
-    // For the outputs penalty
-    if (tx.outputs.length / 5 >= tx.inputs.length) {
-        fee *= 1.1
-    }
-
-    // We'll use Math.ceil to ensure the miners get the extra satoshi.
-    return Math.ceil(fee)
-  }
-}
-```
-
-Now. when you create a new transaction and call the `.ee()` method with this fee model, it will follow the rules we have set above!

package/docs/examples/EXAMPLE_HD_WALLETS.md

@@ -1,71 +0,0 @@
-# Example: BIP32 Key Derivation with HD Wallets
-
-For a long time, BIP32 was the standard way to structure a Bitcoin wallet. While [type-42](EXAMPLE_TYPE_42.md) has since taken over as the standard approach due to its increased privacy and open-ended invoice numbering scheme, it's sometimes still necessary to interact with legacy systems using BIP32 key derivation.
-
-This guide will show you how to generate keys, derive child keys, and convert them to WIF and Bitcoin address formats. At the end, we'll compare BIP32 to the [type-42 system and encourage you to adopt the new approach](EXAMPLE_TYPE_42.md) to key management.
-
-## Generating BIP32 keys
-
-You can generate a BIP32 seed with the SDK as follows:
-
-```typescript
-import { HD } from '@bsv/sdk'
-const randomKey = HD.fromRandom()
-
-// Convert your "xprv" key to a string
-console.log(randomKey.toString())
-
-// Example: xprv9s21ZrQH143K2vF2szsDFhrRehet4iHNCBPWprjymByU9mzN7n687qj3ULQ2YYXdNqFwhVSsKv9W9fM675whM9ATaYrmsLpykQSxMc6RN8V
-```
-
-You can also import an existing key as follows:
-
-```typescript
-const importedKey = HD.fromString('xprv...')
-```
-
-Now that you've generated or imported your key, you're ready to derive child keys.
-
-## Deriving Child Keys
-
-BIP32 child keys can be derived from a key using the `.derive()` method. Here's a full example:
-
-```typescript
-const key = HD.fromString('xprv9s21ZrQH143K2vF2szsDFhrRehet4iHNCBPWprjymByU9mzN7n687qj3ULQ2YYXdNqFwhVSsKv9W9fM675whM9ATaYrmsLpykQSxMc6RN8V')
-const child = key.derive('m/0/1/2')
-console.log(child.toString())
-// 'xprv9yGx5dNDfq8pt1DJ9SFCK3gNFhjrL3kTqEj98oDs6xvfaUAUs3nyvVakQzwHAEMrc6gg1c3iaNCDubUruhX75gNHC7HAnFxHuxeiMVgLEqS'
-```
-
-Any of the standard derivation paths can be passed into the `.derive()` method.
-
-## Converting Between Formats
-
-XPRIV keys can be converted to normal `PrivateKey` instances, and from there to WIF keys. XPUB keys can be converted to normal `PublicKey` instances, and from there to Bitcoin addresses. XPRIV keys can also be converted to XPUB keys:
-
-```typescript
-const key = HD.fromString('xprv9s21ZrQH143K2vF2szsDFhrRehet4iHNCBPWprjymByU9mzN7n687qj3ULQ2YYXdNqFwhVSsKv9W9fM675whM9ATaYrmsLpykQSxMc6RN8V')
-
-// Convert XPRIV to XPUB
-const xpubKey = key.toPublic()
-console.log(xpubKey.toString());
-// xpub661MyMwAqRbcFQKVz2QDcqoACjVNUB1DZQK7dF9bKXWT2aKWfKQNfe3XKakZ1EnxeNP5E4MqZnZZw4P7179rPbeJEjhYbwF5ovkbGkeYPdF
-
-// Convert XPRIV to WIF
-console.log(key.privKey.toWif())
-// L1MZHeu2yMYRpDr45icTvjN7s3bBK1o7NgsRMkcfhzgRjLzewAhZ
-
-// Convert XPUB to public key
-console.log(xpubKey.pubKey.toString())
-// 022248d79bf217de60fa4afd4c7841e4f957b6459ed9a8c9c01b61e16cd4da3aae
-
-// Convert XPUB to address
-console.log(xpubKey.pubKey.toAddress())
-// 1CJXwGLb6GMCF46A721VYW59b21kkoRc5D
-```
-
-This guide has demonstrated how to use BIP32 for key derivation and format conversion. You can continue to use BIP32 within BSV wallet applications, but it's important to consider the disadvantages and risks of continued use, which are discussed below.
-
-## Disadvantages and Risks
-
-BIP32 allows anyone to derive child keys if they know an XPUB. The number of child keys per parent is limited to 2^31, and there's no support for custom invoice numbering schemes that can be used when deriving a child, only a simple integer. Finally, BIP32 has no support for private derivation, where two parties share a common key universe no one else can link to them, even while knowing the master public key. It's for these reasons that we recommend the use of type-42 over BIP32. You can read an equivalent guide [here](EXAMPLE_TYPE_42.md).

package/docs/examples/EXAMPLE_MESSAGE_SIGNING.md

@@ -1,63 +0,0 @@
-# Example: Message Signing
-
-This guide walks through the necessary steps for both public and private message signing.
-
-## Overview
-
-Message signing is a mechanism that preserves the integrity of secure communications, enabling entities to verify the authenticity of a message's origin. This document emphasizes two primary types of message signing: private and public.
-
-Private message signing is used when a message needs to be verified by a *specific recipient*. In this scenario, the sender creates a unique signature using their private key combined with the recipient's public key. The recipient, using their private key, can then verify the signature and thereby the message's authenticity.
-
-On the other hand, public message signing creates a signature that can be verified by *anyone*, without the need for any specific private key. This is achieved by the sender using only their private key to create the signature.
-
-The choice between private and public message signing hinges on the specific requirements of the communication. For applications that require secure communication where authentication is paramount, private message signing proves most effective. Conversely, when the authenticity of a message needs to be transparent to all parties, public message signing is the go-to approach. Understanding these differences will enable developers to apply the correct method of message signing depending on their specific use case.
-
-### 1. Example Code - Private Message Signing
- To get started, you will first want to import the required functions / classes.
-
-```ts
-import { PrivateKey, SignedMessage, Utils } from '@bsv/sdk'
-```
-
-Next, you will want to configure who the sender is, the recipient, and what message you would like to sign.
-
-```ts
-const sender = new PrivateKey(15)
-const recipient = new PrivateKey(21)
-const recipientPub = recipient.toPublicKey()
-const message: number[] = Utils.toArray('I like big blocks and I cannot lie', 'utf8')
-```
-
-Now we can sign the message and generate a signature that can only be verified by our specified recipient.
-
-```ts
-const signature = SignedMessage.sign(message, sender, recipientPub)
-const verified = SignedMessage.verify(message, signature, recipient)
-// console.log(verified) -> true
-```
-
-### 2. Example Code - Public Message Signing
-To create a signature that anyone can verify, the code is very similar to the first example, just without a specified recipient. This will allow anyone to verify the signature generated without requiring them to know a specific private key.
-
-```ts
-import { PrivateKey, SignedMessage, Utils } from '@bsv/sdk'
-
-const sender = new PrivateKey(15)
-const message: number[] = Utils.toArray('I like big blocks and I cannot lie', 'utf8')
-
-const signature = SignedMessage.sign(message, sender)
-const verified = SignedMessage.verify(message, signature)
-// console.log(verified) -> true
-```
-
-## Considerations
-
-While these private signing functions are built on industry standards and well-tested code, there are considerations to keep in mind when integrating them into your applications.
-
-- **Private Key Security**: Private keys must be stored securely to prevent unauthorized access, as they can be used to sign fraudulent messages.
-
-- **Use Case Analysis**: As stated in the overview, you should carefully evaluate whether you need a private or publicly verifiable signature based on your use case.
-
-- **Implications of Signature Verifiability**: When creating signatures that anyone can verify, consider the implications. While transparency is achieved, sensitive messages should only be verifiable by intended recipients.
-
-By understanding and applying these considerations, you can ensure a secure implementation of private signing within your applications.

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.