@bsv/sdk 1.1.1 → 1.1.3

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.

package/docs/low-level/TYPE_42.md

@@ -1,53 +0,0 @@
-# Type 42 Key Derivation
-
-The BSV SDK supports type-42 key derivation, which is a way for two people who have master keys to derive child keys from one another, given a specific string called an invoice number. They can then use these keys for message signing, message encryption or any other purpose.
-
-This guide will cover the process of type-42 derivation, the steps involved, and then demonstrate a simple example of using it for message signing. Finally, we will talk about the "anyone key" and why it can sometimes be useful within type-42 systems.
-
-## The Process
-
-The process starts with two users, who each generate a "master key" from which everything else will be based. Then, they share the associated public key with the other party.
-
-Next, they make use of [ECDH](./ECDH.md) to arrive at a shared secret between themselves. They agree on the "invoice number" they will be using to communicate. We call it an invoice number because type-42 has historically been used for Bitcoin payments. In reality, this is just the unique identifier for the keys to derive.
-
-Now, they compute an [HMAC](./USING_HASHES_AND_HMACS.md) over the invoice number, using the shared secret as the HMAC key. Because the shared secret is private, the HMAC hash function initialized with its value is only usable by the two parties. This means only these two people can hash the invoice number in this unique way.
-
-Finally, the output of the HMAC function over the invoice number is used for key derivation. If Alice wants to derive a key from Bob, she will add this HMAC output to Bob's master public key. Conversely, if Bob wants to derive his own private key to match, he can add the same vlue to his original master private key.
-
-Every invoice number leads to a unique, privately-derivable key in a "shared key universe" occupied only by Alice and Bob. Alice can derive public keys for Bob, and Bob can derive the corresponding private keys. Conversely, Bob can derive public keys for Alice, and Alice can derive the corresponding private keys. They just need to agree on the right invoice number to use, and know each other's master public keys.
-
-Because no one else can compute a shared secret between these two values, no one else can use the special HMAC function over the invoice numbers, and thus no one else can link the master keys of either party to any other party.
-
-## Practical Example
-
-Let's use the BSV SDK to create a practical example. Here, Alice and Bob will generate private keys. Then, Alice will sign a message privately for Bob to verify, using a specific invoice number. Finally, Bob will use the invoice number to deriv Alice's child signing public key, so he can verify the message that Alice signed for him:
-
-```ts
-import { PrivateKey, Utils } from '@bsv/sdk'
-
-const alice = PrivateKey.fromRandom()
-const alicePub = alice.toPublicKey()
-
-const bob = PrivateKey.fromRandom()
-const bobPub = bob.toPublicKey()
-
-// Both parties agree on an invoice number to use
-const invoiceNumber = '2-simple signing protocol-1'
-
-// Alice derives a child private key for signing
-const aliceSigningChild = alice.deriveChild(bobPub, invoiceNumber)
-
-// Alice signs a message for Bob
-const message = Utils.toArray('Hi Bob', 'utf8')
-const signature = aliceSigningChild.sign(message)
-
-// Bob derives Alice's correct signing public key from her master public key
-const aliceSigningPub = alicePub.deriveChild(bob, invoiceNumber)
-
-// Now, Bob can privately verify Alice's signature
-const verified = aliceSigningPub.verify(message, signature)
-console.log(verified)
-// true
-```
-
-This enables people to securely agree on which keys to use, and derive keys for one another privately.

package/docs/low-level/USING_ECDSA.md

@@ -1,30 +0,0 @@
-# Low-level: Making Use of ECDSA with Public and Private Keys
-
-In this tutorial, we will learn how to use ECDSA with asymmetric public and private key pairs. Note, this is a low-level tutorial and should only be used if the SDK's higher-level [Message Signing Capabilities](../examples/EXAMPLE_MESSAGE_SIGNING.md) do not meet your needs.
-
-## Getting Started
-
-First, you'll need to import the `PrivateKey` function. We'll also import `utils` so we can represent our messages in human-readable formats.
-
-```ts
-import { PrivateKey, Utils } from '@bsv/sdk'
-```
-
-Now, let's generate a random private key and sign a message with it.
-
-```ts
-const privateKey = PrivateKey.fromRandom()
-const message = Utils.toArray('Message to sign!')
-
-// The .sign() method creates an ECDSA digital signature for the message from the private key.
-const signature = privateKey.sign(message)
-
-// Anyone with the corresponding public key can now verify the message.
-const publicKey = privateKey.toPublicKey()
-
-// The .verify() method is used for message verification
-const valid = publicKey.verify(message, signature)
-// console.log(valid) --> true
-```
-
-Anyone who knows the public key can verify the message, even if they don't have the private key. You can sign Bitcoin transactions, documents, or any other type of information with ECDSA. Changing the message will invalidate the signature.

package/docs/low-level/USING_HASHES_AND_HMACS.md

@@ -1,79 +0,0 @@
-# Using Hashes and HMACs
-
-Hashes allow you to check the integrity of a message, by providing a deterministic one-way function that ransforms the input data. Hashes are widely useful, especially within Bitcoin. The BSV SDK provides first-class support for the hashing functions used within Bitcoin and its scripting language.
-
-In this tutorial, we will learn how to use hashes and HMACs (Hash-based Message Authentication Codes) to verify the integrity of information, ensuring it has not been changed.
-
-## Setting Up
-
-First, install the `@bsv/sdk` package into your project. We will be using two SDK modules for this exercise:
-
-- **Hash** - contains the hash and HMAC functions we will be using.
-- **Utils** - the SDK provides several helpful utility functions such as `toArray` and and `toUTF8` which allow you to encode and transform data as needed.
-
-```ts
-import { Hash, Utils } from '@bsv/sdk'
-```
-
-## Creating a Hash
-
-The following code performs a straightforward SHA256 hash of a message with the resulting hash returned as a hex string. 
-
-This is a one-way process where the input message is transformed into a fixed-size string (the hash), which acts as a unique representation of the input data. It's primarily used for verifying data integrity.
-
-```ts
-  let sha256Hasher = new Hash.SHA256()
-  sha256Hasher.update('Message to hash')
-  let hashedMessage = sha256Hasher.digestHex()
-  // console.log(hashedMessage)
-  // -> f1aa45b0f5f6703468f9b9bc2b9874d4fa6b001a170d0f132aa5a26d00d0c7e5
-```
-
-A binary hash can also be produced by using the `digest` function instead of `digestHex`.
-
-```ts
-  let hmacMessage = hmacHasher.digest()
-```
-
-Other hashing algorithms are also supported including the following:
-- `Hash.RIPEMD160`
-- `Hash.SHA1`
-- `Hash.SHA512`
-
-There are also shorthand helpers, which will construct the hashesr and digest the message automatically. For example, we can use the `hash.sha256` function as follows:
-
-```ts
-const result = Hash.sha256(toArray('hello, world', 'utf8'))
-```
-
-In addition to simple hashes, the library also support HMAC functions.
-
-## Creating an HMAC
-
-In comparison to standard hashing, the following code introduces HMAC which combines a secret key with the hashing process to provide both data integrity and authentication. 
-
-A key is involved in the hashing process, making the output hash specific not just to the message but also to the key. This means the same message hashed with a different key would produce a different result, adding a layer of security.
-
-```ts
-  let hmacHasher = new Hash.SHA256HMAC('key')
-  hmacHasher.update('Message to hash')
-  let hmacMessageHex = hmacHasher.digestHex()
-  // console.log
-  // -> 41495ec4a050f4059f20c8722b6308efe6e0a90a6a4886b02a31d22180db367c
-```
-
-Just as with hashes, a binary hmac message can also be produced by using the `digest` function instead of `digestHex`.
-
-```ts
-  let hmacMessage = hmacHasher.digest()
-```
-
-In addition to SHA256 based HMACs, `Hash.SHA512HMAC` is also supported which uses the SHA-512 cryptographic hash function.
-
-Just as with hashes, there are also shorthand helpers available for HMACs:
-
-```ts
-const result = Hash.sha256hmac('key', 'message')
-```
-
-This guide has explored the core concepts and practical applications of hashing and HMACs using the BSV SDK. Whether you're verifying the integrity of data, securing communications, or implementing authentication protocols, these tools will serve you well in your development journey.

package/docs/low-level/USING_PRIVATE_PUBLIC_KEYS.md

@@ -1,70 +0,0 @@
-# Generating, Serializing, and Deserializing Private and Public Keys
-
-Private keys protect Bitcoins, enable secure message signing, among other vital roles in the BSV ecosystem. Public keys enable ownership tracking, message attestation, and attribution for signed messages, among other use-cases. In this low-level tutorial, we will learn how to generate, serialize and deserialize public and private keys using the functions provided by the SDK.
-
-## Getting Set Up
-
-We'll be making use of two SDK modules in this guide. Make sure you've installed the `@bsv/sdk` package in your project, then import the modules we'll be using:
-
-- **PrivateKey** - this class will enable to you create a new PrivateKey from various sources such as random, hex string, and WIP. It can also transform a private key into a public key.
-- **Utils** - the SDK provides several helpful utility functions such as `toArray` and and `toUTF8` which allow you to serialize and deserialize data as needed.
-
-```ts
-import { PrivateKey, Utils } from '@bsv/sdk'
-```
-
-## Generating and Deserializing Keys
-First, we will learn how to generate new cryptographic keys to be used within your applications. Unless generating a new private key from random, this will most often involve deserializing a key from various types the most common being such as hex, WIF, and binary.
-
-Here is an example of how this can be done:
-
-```ts
-  const privKeyRandom = PrivateKey.fromRandom()
-  const privKeyFromHex = PrivateKey.fromHex('08dcced21ebf831cb1b1d320c5de2dee690ebea9b4930a7f1af9b7bde8f7858a')
-  const privKeyFromHex2 = PrivateKey.fromString('08dcced21ebf831cb1b1d320c5de2dee690ebea9b4930a7f1af9b7bde8f7858a', 'hex')
-  const privKeyFromWif = PrivateKey.fromWif('L3dyA911FSFwSpgzRFhncUTRPk57aNTHkEhRtXoi4W7fz63bR45W')
-  const privKeyFromBinary = new PrivateKey(Utils.toArray('e0f6f9084f02a59cdc0aa9498b28fe8e20d0d4eeeb19af629761099210990894', 'hex'))
-```
-
-We can then transform these to find the corresponding public key  as follows:
-
-```ts
-  const privKeyRandom = PrivateKey.fromRandom()
-  // Get the corresponding public key
-  let pubKey = privKeyRandom.toPublicKey()
-```
-
-## Serializing Keys
-
-Sometimes you will want to convert private / public keys into a format that can be more easily transported in your applications such as hex or binary.
-
-Let's explore the available functions the SDK provides.
-
-### Private Keys
-Serialize a private key into hex and binary:
-```ts
-  // Starting private key
-  const privKey = PrivateKey.fromRandom()
-
-  // Serialized formats
-  const privKeyHex = privKey.toHex()
-  const privKeyBinary = privKey.toArray()
-  const privKeyWif = privKey.toWif()
-```
-
-### Public Keys
-Public keys can be serialized as well, and include helper functions to serialize into common formats such as an address or DER.
-
-```ts
-  
-  const privateKey = PrivateKey.fromRandom()
-  const publicKey = privateKey.toPublicKey()
-  const publicKeyHex = publicKey.toString()
-  const publicKeyAddress = publicKey.toAddress()
-  const publicKeyDER = publicKey.toDER()
-
-  // Serialize a public key using function chaining
-  const publicKey = PrivateKey.fromRandom().toPublicKey().toString()
-```
-
-Now you should be able to manage cryptographic keys with the SDK, including generating, serializing, and deserializing both private and public keys. These skills are important for using low-level cryptographic keys, ensuring you have the necessary tools to leverage the security benefits they offer and to implement advanced cryptographic functions within your applications.

package/docs/low-level/USING_SCRIPTS.md

@@ -1,71 +0,0 @@
-# Serializing and Deserializing Bitcoin Scripts
-
-Bitcoin scripts are the mechanism by which coins are locked and unlocked. They define the constraints and rules that govern transfers, and are therefore instrumental in the functionality of Bitcoin.
-
-In this low-level tutorial, we will learn how to serialize and deserialize Bitcoin scripts within your applications using the functions provided by the SDK.
-
-First, you will want to make sure you have installed the `@bsv/sdk` library and imported the necessary modules for this tutorial:
-
-- **Script** - this class will enable to you create a Bitcoin Script from various sources.
-- **PrivateKey** - Used in the demo of creating a P2PKH locking script.
-- **P2PKH** - This class provides methods to create Pay To Public Key Hash locking and unlocking scripts.
-- **OP** - Bitcoin opcode map used in example scripts. 
-
-```ts
-import { Script, PrivateKey, P2PKH, OP } from '@bsv/sdk'
-```
-
-## Generating and Deserializing Scripts
-First, we will learn how to generate new Bitcoin scripts. This will usually involve deserializing a script from various types the most common being as hex, ASM, and binary.
-
-Here is an example of how this can be done:
-
-```ts
-  // From Hex
-  const buf: number[] = [OP.OP_TRUE]
-  const scriptFromHex = Script.fromHex(Utils.toHex([OP.OP_TRUE]))
-
-  // From ASM
-  const scriptFromASM = Script.fromASM('OP_DUP OP_HASH160 1451baa3aad777144a0759998a03538018dd7b4b OP_EQUALVERIFY OP_CHECKSIG')
-
-  // From Binary
-  const buf2 = [OP.OP_PUSHDATA1, 3, 1, 2, 3]
-  const scriptFromBinary = Script.fromBinary(buf)
-```
-
-For a more advanced example, the P2PKH class can be used to creating a locking script to a Public Key Hash as follows:
-
-```ts
-  const priv = PrivateKey.fromRandom()
-  const publicKeyHash = priv.toPublicKey().toHash()
-  const lockingScript = new P2PKH().lock(publicKeyHash).toASM()
-  // console.log(lockingScript)
-  // -> 'OP_DUP OP_HASH160 99829df6ad0df41a759811add7f233e268501ea9 OP_EQUALVERIFY OP_CHECKSIG'
-
-```
-
-## Serializing Scripts
-
-Sometimes you will want to convert Scripts into a format that can be more easily transported in your applications such as hex or binary.
-
-Let's explore the available functions the SDK provides.
-
-```ts
-  // Create initial script
-  const script = Script.fromASM('OP_DUP OP_HASH160 1451baa3aad777144a0759998a03538018dd7b4b OP_EQUALVERIFY OP_CHECKSIG')
-
-  // Serialize script
-  const scriptAsHex = script.toHex()
-  // console.log(scriptAsHex)
-  // -> 76a9141451baa3aad777144a0759998a03538018dd7b4b88ac
-
-  const scriptAsASM = script.toASM()
-  // console.log(scriptAsASM)
-  // -> 'OP_DUP OP_HASH160 1451baa3aad777144a0759998a03538018dd7b4b OP_EQUALVERIFY OP_CHECKSIG'
-
-  const scriptAsBinary = script.toBinary()
-  // console.log(scriptAsBinary)
-  // -> [118, 169, 20, ..., 172]
-```
-
-We've covered how to interpret scripts from formats like hex, ASM, and binary, as well as how to convert them back for efficient transmission or storage. You should now be equipped to manage Bitcoin scripts efficiently in your journey to develop Bitcoin-powered applications.