@bsv/sdk 1.1.1 → 1.1.2

package/docs/examples/EXAMPLE_VERIFYING_SPENDS.md

@@ -1,69 +0,0 @@
-# Example: Verifying Spends with Script Intrepreter
-
-The SDK comes with a script interpreter that allows you to verify the chain of spends within Bitcoin. When coins are spent from one transaction to another, the process is carried out between a particular output of the source transaction and a particular input of the spending transaction. The `Spend` class sets up the necessary contextual information for this process, and then evaluates the scripts to determine if the transfer is legitimate.
-
-This guide will walk you through the verification of a real spend, with real data. You can apply this code to your own transactions to ensure the transfer of coins from one state into the next is legitimate.
-
-## Pre-requisites
-
-We will need two transactions: a source transaction and a spending transaction, in order to set up the `Spend` context in which the transfer of coins occurs between them. When you construct an instance of the `Spend` class, you'll need to provide this information in the correct format. In a new file, let's set up som basic things we'll need:
-
-```typescript
-import { Spend, LockingScript, UnlockingScript } from '@bsv/sdk'
-
-const spend = new Spend({
-
-    // Replace with the TXID of the transaction where you are spending from
-    sourceTXID: '0000000000000000000000000000000000000000000000000000000000000000',
-
-    // Replace with the output index you are redeeming
-    sourceOutputIndex: 0,
-
-    // Replace with the number of satoshis in the output you are redeeming
-    sourceSatoshis: 1,
-
-    // Replace with the locking script you are spending
-    lockingScript: LockingScript.fromASM('OP_3 OP_ADD OP_7 OP_EQUAL'),
-
-    // Replace with the version of the new spending transaction
-    transactionVersion: 1,
-
-    // Other inputs from the spending transaction that are needed for verification.
-    // The SIGHASH flags used in signatures may not require this (if SIGHASH_ANYONECANPAY was used).
-    // This is an ordered array of TransactionInputs with the input whose script we're currently evaluating missing.
-    otherInputs: [],
-
-    // TransactionOutputs from the spending transaction that are needed for verification.
-    // The SIGHASH flags used in signatures may nnt require this (if SIGHASH_NONE was used).
-    // If SIGHASH_SINGLE is used, it's possible for this to be a sparse array, with only the index corresponding to
-    // the inputIndex populated.
-    outputs: [],
-
-    // This is the index of the input whose script we are currently evaluating.
-    inputIndex: 0,
-
-    // This is the unlocking script that we are evaluating, to see if it unlocks the source output.
-    unlockingScript: UnlockingScript.fromASM('OP_4'),
-
-    // This is the sequence number of the input whose script we are currently evaluating.
-    inputSequence: 0xffffffff,
-
-    // This is the lock time of the spending transaction.
-    lockTime: 0
-})
-```
-
-Once you've provided the context and constructed the Spend, you should have a new spend instance ready for verification.
-
-## Validating the Spend
-
-You can use the `validate()` method to run the scripts and validate the spend, as follows:
-
-```typescript
-const validated = spend.validate()
-// console.log(validated) => true
-```
-
-The result will be a boolean indicating the result of the script. If there is an error thrown, or if the boolean is false, the script is not valid. If the boolean is true, the spend is considered valid.
-
-Errors from the spend will contain useful information, such as the specific opcode and context in which the error occurred (in either the locking or unlocking script).

package/docs/examples/GETTING_STARTED_NODE_CJS.md

@@ -1,71 +0,0 @@
-# Getting Started with BSV SDK in NodeJS (CommonJS)
-
-Welcome to the BSV SDK! This guide is tailored for developers working in a NodeJS environment, specifically those who are using the CommonJS module system. We'll walk you through the installation process and show you how to get started with creating and signing a Bitcoin SV transaction using the SDK. Whether you're building on BSV for the first time or transitioning an existing project to use the SDK, this guide is for you.
-
-## Prerequisites
-
-Before we begin, make sure you have Node.js installed on your system. You can download and install Node.js from [nodejs.org](https://nodejs.org/). This guide assumes you have basic knowledge of JavaScript and the Node.js environment.
-
-## Installation
-
-First, you'll need to install the BSV SDK package in your project. Open your terminal, navigate to your project directory, and run the following command:
-
-```bash
-npm install @bsv/sdk
-```
-
-This command installs the BSV SDK in your project, making it ready for use. There are no external runtime dependencies.
-
-## Requiring the SDK
-
-To use the BSV SDK in a NodeJS project with CommonJS, you'll import modules using the `require` syntax. Here's how you set up a basic script to use the BSV SDK:
-
-1. Create a new JavaScript file in your project. For example, `index.js`.
-2. At the top of your file, require the SDK modules you plan to use. For instance:
-
-```javascript
-const { PrivateKey, P2PKH, Transaction, ARC } = require('@bsv/sdk');
-```
-
-## Creating and Signing a Transaction
-
-Now, let's create and sign a transaction. We'll follow the example provided in the README. This example demonstrates how to create a transaction from a source to a recipient, including calculating fees, signing the transaction, and broadcasting it to ARC.
-
-Copy and paste the following code into your `index.js` file below your `require` statement:
-
-```javascript
-const privKey = PrivateKey.fromWif('...')
-
-const sourceTransaction = Transaction.fromHex('...')
-
-const version = 1
-const input = {
-  sourceTransaction,
-  sourceOutputIndex: 0,
-  unlockingScriptTemplate: new P2PKH().unlock(privKey),
-}
-const output = {
-  lockingScript: new P2PKH().lock(privKey.toPublicKey().toHash()),
-  change: true
-}
-
-const tx = new Transaction(version, [input], [output])
-await tx.fee()
-await tx.sign()
-
-await tx.broadcast()
-```
-
-This script demonstrates the entire process of creating a transaction, from initializing keys to signing and broadcast. When you run this script using Node.js (replacing the source transaction, private key, and ARC credentials), the spend will be signed and broadcast to the BSV network.
-
-## Running Your Script
-
-To run your script, simply execute the following command in your terminal:
-
-```bash
-node index.js
-```
-
-## Conclusion
-
-Congratulations! You've successfully installed the BSV SDK in your NodeJS project and created a signed transaction. This guide covered the basics to get you started, but the BSV SDK is capable of much more. Explore the SDK documentation for detailed information on all the features and functionalities available to build scalable applications with the BSV blockchain.

package/docs/examples/GETTING_STARTED_REACT.md

@@ -1,119 +0,0 @@
-Getting Started with BSV SDK using React and TypeScript
-=======================================================
-
-Welcome to the guide! This guide is designed for developers working in a React environment using TypeScript. We'll walk through the installation process and show you how to create and broadcast a Bitcoin SV transaction using the BSV SDK. Whether you're freshly starting on BSV or transitioning an existing project to use the SDK, this would be your go-to guide.
-
-Prerequisites
--------------
-
-Ensure that you have Node.js installed on your system. You can download and install Node.js from [nodejs.org](https://nodejs.org/). Basic knowledge of JavaScript, React and TypeScript is recommended for this guide.
-
-Setting Up
-----------
-
-Begin by creating a new project using Create React App with the TypeScript template:
-
-```bash
-npx create-react-app my-bsv-app --template typescript
-cd my-bsv-app
-```
-
-Next, install the BSV SDK package in your project:
-
-```bash
-npm install @bsv/sdk
-```
-
-Writing the Component
----------------------
-
-Let's now create a Button component that builds and broadcasts a transaction when clicked.
-
-1.  Create a new file in your project, such as `src/components/BsvButton.tsx`.
-2.  At the top of your component file, import the necessary modules from the BSV SDK:
-
-```
-import React from 'react';
-import { PrivateKey, Transaction, ARC, P2PKH } from '@bsv/sdk';
-```
-
-3.  Define a new component function, `BsvButton`, that handles the creation and broadcast of a transaction upon a button click:
-
-```typescript
-const BsvButton: React.FC = () => {
-  const handleClick = async () => {
-    const privKey = PrivateKey.fromWif('...')
-    const sourceTransaction = Transaction.fromHex('...') // your source transaction goes here
-
-    const version = 1
-    const input = {
-      sourceTransaction,
-      sourceOutputIndex: 0,
-      unlockingScriptTemplate: new P2PKH().unlock(privKey),
-    }
-    const output = {
-      lockingScript: new P2PKH().lock(privKey.toPublicKey().toHash()),
-      change: true
-    }
-
-    const tx = new Transaction(version, [input], [output])
-    await tx.fee()
-    await tx.sign()
-
-    await tx.broadcast()
-  }
-
-  return (
-    <button onClick={handleClick}>
-      Create Transaction
-    </button>
-  );
-}
-```
-
-4.  Finally, export the `BsvButton` component:
-
-```typescript
-export default BsvButton;
-```
-
-Integrating into Application
-----------------------------
-
-Now, let's integrate our `BsvButton` component into our app:
-
-1.  Open `src/App.tsx`.
-2.  Delete all of its content and replace it with the following:
-
-```typescript
-import React from 'react';
-import BsvButton from './components/BsvButton';
-
-function App() {
-  return (
-    <div className="App">
-      <header className="App-header">
-        <BsvButton />
-      </header>
-    </div>
-  );
-}
-
-export default App;
-```
-
-Running the App
----------------
-
-To run your application, just type the following command in your terminal:
-
-```bash
-npm run start
-```
-
-Now when you click the button, a transaction will be created, signed, and broadcast to the BSV network.
-
-Conclusion
-----------
-
-Congratulations! You've successfully integrated the BSV SDK into your TypeScript & React application and created a button which broadcasts a bitcoin transaction on click. This guide covered the basic steps needed to get you started, but the BSV SDK can do a lot more. Explore the SDK documentation to dive deep into all the features and functionalities available to build scalable applications on the BSV blockchain.

package/docs/examples/README.md

@@ -1,19 +0,0 @@
-# Examples
-
-Here, you will find documentation for common example usages of the library.
-
-- [Getting Started (Node, CommonJS)](./GETTING_STARTED_NODE_CJS.md)
-- [Getting Started (React)](./GETTING_STARTED_REACT.md)
-- [Example: Creating a Simple Transaction](EXAMPLE_SIMPLE_TX.md)
-- [Example: Verifying a BEEF Structure](EXAMPLE_VERIFYING_BEEF.md)
-- [Example: Creating Transactions with Inputs, Outputs and Templates](EXAMPLE_COMPLEX_TX.md)
-- [Example: Creating the R-puzzle Script Template](EXAMPLE_SCRIPT_TEMPLATES.md)
-- [Example: Message Encryption and Decryption](EXAMPLE_ENCRYPT_DECRYPT_MESSAGE.md)
-- [Example: Message Signing](EXAMPLE_MESSAGE_SIGNING.md)
-- [Example: Building a Custom Transaction Broadcast Client](EXAMPLE_BUILDING_CUSTOM_TX_BROADCASTER.md)
-- [Example: Verifying Spends with Script Intrepreter](EXAMPLE_VERIFYING_SPENDS.md)
-- [Example: BIP32 Key Derivation with HD Wallets](EXAMPLE_HD_WALLETS.md)
-- [Example: Using Type 42 Key Derivation for Bitcoin Wallet Management](EXAMPLE_TYPE_42.md)
-- [Example: Creating a Custom Transaction Fee Model](EXAMPLE_FEE_MODELING.md)
-- [Example: Building a Pulse Block Headers Client](EXAMPLE_PULSE_HEADERS.md)
-- [Example: Using ECIES Encryption](EXAMPLE_ECIES.md)

package/docs/low-level/AES_SYMMETRIC_ENCRYPTION.md

@@ -1,40 +0,0 @@
-# Using AES for the Symmetric Encryption of Data
-
-The goal of this tutorial is to explore the encryption of data using symmetric keys with the Advanced Encryption Standard (AES). We will make use of the functions provided by the SDK in order to encrypt data with a key, and then decrypt it again.
-
-<img src="./images/symmetric_encryption_diagram.png" width="600" alt=""/>
-
-If you would like to learn more about AES encryption, here are some general resources that may help:
-
-- [AES - Wiki](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard)
-- [GCM - Wiki](https://en.wikipedia.org/wiki/Galois/Counter_Mode)
-
-The library supports GCM, a specific counter mode of AES that works well in many applications. The library also handles initialization vectors, automatically prepending them to ciphertext and removing them in the decryption process. Now that you know the basics, let's get started!
-
-## Getting Started
-
-First, let's import the `SymmetricKey` class from the SDK, and we'll also use `Utils` for human-readable messages.
-
-```ts
-import { SymmetricKey, Utils } from '@bsv/sdk'
-```
-
-Next, we wil define the keys to be used and the data to encrypt. They `.encrypt()` method expects a parameter of type `number[]` so we will use the Utils `toArray` function to convert the UTF8 message to the correct type.
-
-```ts
-  const symmetricKey = SymmetricKey.fromRandom()
-  const messageToEncrypt = 'Hello Alice, this is Bob!'
-```
-
-### Encrypting and Decrypting
-
-When you encrypt a message, an initialization vector is prepended to the message to prevent potential key re-use attacks. Conversely, when decrypting, the initialization vector that was initially added is spliced out and used in the AES-GSM decryption processes.
-
-We will use the `encrypt` and `decrypt` methods of the SymmetricKey class to transform the message.
-
-```ts
-  const encryptedMessage = SymmetricKey.encrypt(messageToEncrypt)
-  const plaintext = SymmetricKey.decrypt(encryptedMessage, 'utf8')
-  // console.log(plaintext) --> 'Hello Alice, this is Bob!'
-
-This is just a basic demonstration of symmetric encryption/decryption using the BSV SDK, however the possibilities of what you can do are endless once you understand these fundamentals.

package/docs/low-level/ECDH.md

@@ -1,64 +0,0 @@
-# ECDH (Elliptic Curve Diffie-Hallman)
-
-The process of ECDH enables two parties to agree on a common shared secret. Then, messages can be exchanged using this common secret. This guide provides a conceptual example, then delves into a practical example.
-
-## The Setup
-
-Each party randomly generates a private key, then sends the associated public key to the other party. In order to compute the public key from the private key, they multiply the private key by a generator point on an elliptic curve, using point multiplication.
-
-```
-Alice = random()
-AlicePub = Alice * GeneratorPoint
-Bob = random()
-BobPub = Bob * GeneratorPoint
-```
-
-Then, the parties use Elliptic Curve Diffie-Hallman (ECDH) to derive a shared secret. The way this works is that the first party, let's call her Alice, uses her private key combined with the second user's (call him Bob) public key to compute a secret. Meanwhile, Bob can use his private key and Alice's public key to compute the same secret:
-
-```
-AliceSecret = Alice * BobPub
-BobSecret = Bob * AlicePub
-```
-
-These secrets are equal because:
-
-```
-AlicePub (Alice * GeneratorPoint) * Bob = BobPub (Bob * GeneratorPoint) * Alice
-```
-
-Put more simply:
-
-```
-Alice * Bob * GeneratorPoint
-Bob * Alice * GeneratorPoint
-```
-
-Because multiplication is easy but division is practically impossible in elliptic curve math, the system is secure even though both parties generate the same shared secret. Also, no third party can generate the shared secret. Alice can't learn Bob's private key and Bob can't learn Alice's private key.
-
-## Practical Demonstration
-
-The BSV SDK enables the computation of a shared secret as follows:
-
-```ts
-import { PrivateKey } from '@bsv/sdk'
-
-const alice = PrivateKey.fromRandom()
-const alicePub = alice.toPublicKey()
-
-const bob = PrivateKey.fromRandom()
-const bobPub = bob.toPublicKey()
-
-// Alice derives the secret with Bob's public key
-// She does not need his private key.
-const aliceSecret = alice.deriveSharedSecret(bobPub).toString()
-
-// Bob derives the secret with Alice's public key
-// He does not need her private key.
-const bobSecret = bob.deriveSharedSecret(alicePub).toString()
-
-// We've converted these secrets into hex and now we can see if they are equal
-console.log(aliceSecret === bobSecret)
-// true
-```
-
-You can then use the secret to encrypt data or otherwise communicate securely between the two parties.

package/docs/low-level/NUMBERS_POINTS.md

@@ -1,116 +0,0 @@
-# Numbers and Points
-
-At the base of both symmetric and asymmetric algorithms lie the concept of numbers, large enough to represent a key that can be used in various operations. Further, asymmetric systems based in elliptic curves rely on a way to represent the points on these curves. Both numbers and points have various mathematical operations that enable these algorithms, and this guide will provide an overview of the SDK's implementations of each.
-
-## Big Numbers
-
-In JavaScript and TypeScript, natural numbers are limited to 53 bits of precision. This means that it's not possible to have numbers larger than 2 to the power of 53. However, the keys used in secure algorithms, such as those used in Bitcoin, are on the order of 256 bits in length. This means that we need a specialized representation of these large numbers, and the necessary mathematical operations on them.
-
-The SDK's `BigNumber` class provides this capability. Here's a simple example:
-
-```ts
-import { BigNumber, Random } from '@bsv/sdk'
-
-const bn1 = new BigNumber(7)
-const bn2 = new BigNumber(4)
-const bn3 = bn1.add(bn2)
-console.log(bn3.toNumber())
-// 11
-```
-
-Here, we're creating two "big" numbers and adding them together. These numbers aren't actually very large, but they illustrate the point. We can use larger numbers, generating them randomly, and convert them into hex:
-
-```ts
-// Generate a BigNumber from 32 random bytes (256 bits, like Bitcoin private keys)
-const bn1 = new BigNumber(Random(32))
-console.log(bn1.toHex())
-// 31af7e86775fbbab9b8618eaad8d9782251cc67ff7366d7f59aee5455119c44f
-
-// Multiply this number by 65536
-const bn2 = bn1.muln(65536)
-
-// Printed on the screen, this should be two bytes shfted over in hex
-// This amounts to four extra zeroes at the end
-console.log(bn2.toHex())
-// 31af7e86775fbbab9b8618eaad8d9782251cc67ff7366d7f59aee5455119c44f0000
-```
-
-It's also possible to do many othe operations, like subtraction, division, and conversion into various formats:
-
-```ts
-const bn1 = new BigNumber(21)
-const bn2 = new BigNumber(5)
-
-console.log(bn1.sub(bn2).toNumber()) // 16
-
-// Note that decimal numbers are not supported.
-// For division, we are expecting a whole number.
-console.log(bn1.div(bn2).toNumber()) // 4
-
-// We can get the remainder with the modulous function.
-console.log(bn1.mod(bn2).toNumber()) // 1
-
-// BigNumbers can be imported and exported to various formats
-const bn3 = new BigNumber(Random(6))
-console.log(bn3.toHex()) // e09bcaeda91c
-console.log(bn3.toBitArray()) // binary value
-console.log(bn3.toArray()) // [ 224, 155, 202, 237, 169, 28 ]
-```
-
-Private keys and symmetric keys are just an extension of the `BigNumber` class, enabling access to various specialized algorithms like digital signatures and encryption, respectively. When considering public keys, we need to go further and talk about elliptic curves and points.
-
-## Curves and Points
-
-An elliptic curve has various properties and mathematical primitives. The curve used in Bitcoin is called `secp256k1`, and the SDK provides an implementation in the `Curve` class. In order to get started using a curve, you will need the generator point. The generator point can be multiplied with a private key in order to get a corresponding public key.
-
-Let's start by importing the `Curve` class, generating a private key (a random number), and multiplying it by the generator point (called `G`) to get a point representing the corresponding public key:
-
-```ts
-import { Curve, BigNumber, Random } from '@bsv/sdk'
-
-const curve = new Curve()
-const privateKey = new BigNumber(Random(32))
-const G = curve.g
-const publicPoint = G.mul(privateKey)
-console.log(`Private key: ${privateKey.toHex()}`)
-// Private key: fd026136e9803295655bb342553ab8ad3260bd5e1a73ca86a7a92de81d9cee78
-
-console.log(`Public key: ${publicPoint.toString()}`)
-// Public key: 028908061925dac16b651e814995cba3dac8acbf8cf1bade40920a31a1611e6970
-```
-
-Now, the public key can be shared with the world, and the private key remains secure. This is because the process of point multiplication is impractical to reverse (there is no "point division" or "dividing by the generator point").
-
-## Point Addition and Multiplication
-
-Points are represented (wrapped) at a higher level by the SDK's `PublicKey` class, which simply adds some extra helper functions. Conversely, the SDK wraps Big Numbers with the `PrivateKey` class to extend their functionality.
-
-When dealing with points, we can perform other useful operations. For example, the [type 42 scheme](./TYPE_42.md) talks about adding one point to another. We will demonstrate, and then we'll go further to show the multiplication of a point by a number, to show the process behind [ECDH](./ECDH.md):
-
-```ts
-import { Curve, BigNumber, Random } from '@bsv/sdk'
-
-const curve = new Curve()
-const G = curve.g
-
-const key1 = new BigNumber(Random(32))
-const pubpoint1 = G.mul(key1)
-
-const key2 = new BigNumber(Random(32))
-const pubpoint2 = G.mul(key2)
-
-// two points can be added together
-const added1and2 = pubpoint1.add(pubpoint2)
-console.log(`${pubpoint1.toString()} + ${pubpoint2.toString()} = ${added1and2.toString()}`)
-// 0280879ebda787e241ecaf27e29b0539e7a1d3895ee6c881b6e5b3c4468f379bd1 + 03ffd671622049d8f6ccb11f17dcf88fcd43d0916d9698b3d338bb9360e24d48ec = 0254b1a5132c040688f7b85a4ef56cc968c87552222d5ebeefca13f65b88790eb1
-
-// (A * BG) = (B * AG) (this demonstrates why ECDH works)
-const mul1and2 = pubpoint1.mul(key2)
-console.log(`${pubpoint1.toString()} * ${key2.toHex()} = ${mul1and2.toString()}`)
-const mul2and1 = pubpoint2.mul(key1)
-console.log(`${pubpoint2.toString()} * ${key1.toHex()} = ${mul2and1.toString()}`)
-// 0280879ebda787e241ecaf27e29b0539e7a1d3895ee6c881b6e5b3c4468f379bd1 * 695a2ce8dbf5f1889eac7a5c3711d01e3b863df8ef530b9319924a354e5c20dd = 03f3c29024e3ada33a5ea2258544c63108a8c060378dcd5a69ef69851a8a25ad1f
-// 03ffd671622049d8f6ccb11f17dcf88fcd43d0916d9698b3d338bb9360e24d48ec * b329e4c294d2b04b3d6907492a0e471255d93d06472fcb2b1228d6f364c25940 = 03f3c29024e3ada33a5ea2258544c63108a8c060378dcd5a69ef69851a8a25ad1f
-```
-
-These lower-level constructs are useful when dealing with key derivation schemes, or when you need to perform specific mathematical operations on public, private or symmetric keys. Keep in mind that because public keys are an extension of `Point`, and because private and symmetric keys extend `BigNumber`, all of the low-level tools from these powerful base classes are always available for your use.

package/docs/low-level/README.md

@@ -1,13 +0,0 @@
-# Low-Level Constructs
-
-These documents cover the lower level functionalities of the BSV library. Generally, these are more advanced use-cases:
-
-- [Numbers and Points](NUMBERS_POINTS.md)
-- [Public and Private Keys](USING_PRIVATE_PUBLIC_KEYS.md)
-- [AES Symmetric Encryption](AES_SYMMETRIC_ENCRYPTION.md)
-- [ECDSA Digital Signature Algorithm](USING_ECDSA.md)
-- [ECDH (Elliptic Curve Diffie-Hallman)](ECDH.md)
-- [Hashes and HMAC Functions](USING_HASHES_AND_HMAC.md)
-- [Type 42 Derivation](TYPE_42.md)
-- [Transaction Signatures](TX_SIG.md)
-- [Serializing and Deserializing Scripts](USING_SCRIPTS.md)

package/docs/low-level/TX_SIG.md

@@ -1,132 +0,0 @@
-A Transaction Signature serves as strong evidence that the transaction has been authorized by the holder of the private key corresponding to an associated public key. This document provides information about the structure, serialization and pre-image format for these signatures.
-
-### Data Structure
-
-The `TransactionSignature` class extends the `Signature` class, inheriting its basic properties of `r` and `s`, which are components of the ECDSA (Elliptic Curve Digital Signature Algorithm) signature. Additionally, it introduces a `scope` variable which is specific to the context of transaction signing, indicating the parts of the transaction the signature commits to.
-
-The class defines several static readonly properties representing the SIGHASH types for the `scope`:
-
-- `SIGHASH_ALL`: The signature commits to all outputs of the transaction, ensuring none can be changed without invalidating the signature.
-- `SIGHASH_NONE`: The signature commits to no outputs, allowing others to add outputs to the transaction.
-- `SIGHASH_SINGLE`: The signature commits to exactly one output, the one with the same index as the input the signature is for. This allows for independent adjustment of outputs in multi-output transactions.
-- `SIGHASH_ANYONECANPAY`: Modifies the behavior of the other types by only committing to the current input, allowing others to add or remove other inputs.
-- `SIGHASH_FORKID`: Currently always enabled in BSV.
-
-### Serialization and Formats
-
-The `TransactionSignature` class includes methods for serializing and deserializing transaction signatures, useful for referencing them within scripts, among other things.
-
-- `format()`: This static method prepares the transaction data for signing by creating a preimage according to the specified SIGHASH type. It considers various components like inputs, outputs, the transaction sequence, and lock time. Useful for generating the data that will be signed to produce a transaction signature.
-- `fromChecksigFormat()`: Deserializes a script stack element into a `TransactionSignature` instance, useful for parsing signatures from raw transaction data.
-- `toChecksigFormat()`: Serializes the signature back into a format that can be embedded in a script. This includes converting the ECDSA components (`r` and `s`) into DER format, followed by the `scope` (SIGHASH flags) to indicate which components are signed.
-
-The `TransactionSignature` encapsulates the complexity of transaction signing and signature serialization. You can make use of the static `.format()` method to compute the signatures you need, enabling a wide variety of applications.
-
-## Using the Signature Preimage Formatter
-
-Here's an example of formatting a signature preimage for use in a Transaction:
-
-```typescript
-import { P2PKH, Transaction, PrivateKey, TransactionSignature, UnlockingScript, Hash } from '@bsv/sdk'
-
-// Initialize the script template, source TX, and the TX we'll be working on adding a signature for.
-const p2pkh = new P2PKH()
-const sourceTx = Transaction.fromHex('0200000001849c6419aec8b65d747cb72282cc02f3fc26dd018b46962f5de48957fac50528020000006a473044022008a60c611f3b48eaf0d07b5425d75f6ce65c3730bd43e6208560648081f9661b0220278fa51877100054d0d08e38e069b0afdb4f0f9d38844c68ee2233ace8e0de2141210360cd30f72e805be1f00d53f9ccd47dfd249cbb65b0d4aee5cfaf005a5258be37ffffffff03d0070000000000001976a914acc4d7c37bc9d0be0a4987483058a2d842f2265d88ac75330100000000001976a914db5b7964eecb19fcab929bf6bd29297ec005d52988ac809f7c09000000001976a914c0b0a42e92f062bdbc6a881b1777eed1213c19eb88ac00000000')
-const tx = new Transaction(
-    1, //version
-    [{
-        sourceTransaction: sourceTx,
-        sourceOutputIndex: 0,
-        sequence: 0xffffffff
-    }],
-    [{ // outputs
-        lockingScript: p2pkh.lock('176ayvhKue1C5StD31cTsdN1hwotw59jsR'),
-        satoshis: 1000
-    }],
-    0 // lock time
-)
-
-// The private key we will use for signing
-const privateKey = new PrivateKey(42) // Replace
-
-// Let's decide which input index we're signing
-const inputIndex = 0
-
-// We'll sign all inputs and outputs with this signature.
-let signatureScope = TransactionSignature.SIGHASH_FORKID | TransactionSignature.SIGHASH_ALL
-
-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.'
-    )
-}
-
-// The pre-image is the data that we are incorporating into the signature.
-// It needs a few important details about the output we're spending and the new transaction we're creating.
-const preimage = TransactionSignature.format({
-    // The source TXID of the output we're spending needs to be provided.
-    sourceTXID: input.sourceTransaction.id('hex') as string,
-
-    // Identify the output index in the source transaction so we know where the coins come from.
-    sourceOutputIndex: input.sourceOutputIndex,
-
-    // Identify the amount of satoshis that are in the source output.
-    sourceSatoshis: input.sourceTransaction.outputs[input.sourceOutputIndex].satoshis as number,
-
-    // Identify the version of the new transaction you are creating, that will spend the source output.
-    transactionVersion: tx.version,
-
-    // Stipulate any other inputs (with the current input removed from the list) in the new transaction
-    // that will be included in the signature. Note that with SIGHASH_ANYONECANPAY, this can be empty.
-    otherInputs,
-
-    // Stipulate the index of the current input in the new transaction you are working to create.
-    inputIndex,
-
-    // Stipulate the outputs to the new transaction you are creating.
-    // Note that if you are using SIGHASH_NONE, this can be empty.
-    // If you are using SIGHASH_SINGLE, it could be a "sparse array" with only the output at the same index as the inputIndex populated.
-    outputs: tx.outputs,
-
-    // Provide the current sequence number of the input that you are working on signing.
-    inputSequence: input.sequence,
-
-    // Provide the portion of the script in which you are working.
-    // In most simple use-cases (that don't make use of OP_CODESEPARATOR), this is just the locking script from the source output.
-    subscript: input.sourceTransaction.outputs[input.sourceOutputIndex].lockingScript,
-
-    // Provide the lock time for the new transaction you are working to create.
-    lockTime: tx.lockTime,
-
-    // Finally, provide the SIGHASH flags you wish to include in the preimage that will be generated.
-    scope: signatureScope
-})
-
-// The result will be a preimage that can be signed, and included in scripts.
-
-// We sign the hash of the preimage.
-// Because the `.sign()` method also performs a hash, the result is the "double-hash" needed by Bitcoin.
-const rawSignature = privateKey.sign(Hash.sha256(preimage))
-
-// Now, we construct a TransactionSignature from the ECDSA signature, for conversion to Checksig format.
-const sig = new TransactionSignature(
-    rawSignature.r,
-    rawSignature.s,
-    signatureScope
-)
-
-// Then we convert it so it can be used in a script
-const sigForScript = sig.toChecksigFormat()
-
-// Finally, we could go on to make any kind of needed unlocking script with the signature..
-const pubkeyForScript = privateKey.toPublicKey().encode(true) as number[]
-const script = new UnlockingScript([
-    { op: sigForScript.length, data: sigForScript },
-    { op: pubkeyForScript.length, data: pubkeyForScript }
-])
-console.log('Signature was computed! P2PKH Unlocking Script:', script.toHex())
-```
-
-First, we set up the data we wanted to sign. Then, we created a pre-image, hashed it, and signed it with a private key using ECSA. Then, we created a new `TransactionSignature` instance with the ECDSA signature, so that we could convert it into Checksig format. At this point, you could use the transaction signature in a script to help unlock a UTXO, enabling you to unlock and spend the associated Bitcoins or other digital assets.