@bsv/sdk 1.0.0

package/docs/getting-started/COMMONJS.md

@@ -0,0 +1,94 @@
+# Getting Started with BSV SDK in Node.js (CommonJS)
+
+Welcome to the quick start guide for the BSV SDK, tailored for Node.js applications using CommonJS syntax. This guide will walk you through the steps to install the SDK, set up your project, and run a simple example that leverages the BSV Blockchain Libraries Project for creating and signing a transaction. Whether you're working on an existing Node.js project or starting a new one, this guide will get you up and running with the BSV SDK in no time.
+
+## Prerequisites
+
+Before you begin, ensure you have the following:
+
+- Node.js installed on your machine. The BSV SDK is compatible with Node.js version 10 or later.
+- An understanding of JavaScript or TypeScript.
+- A basic familiarity with blockchain concepts, particularly those related to Bitcoin SV (BSV).
+
+## Installation
+
+First, you'll need to install the BSV SDK in your Node.js project. If you haven't already created a project, you can do so by running `npm init` in your project directory and following the prompts.
+
+To install the SDK, open your terminal, navigate to your project directory, and run:
+
+```bash
+npm install @bsv/sdk
+```
+
+This command will download and install the BSV SDK and its dependencies into your project.
+
+## Setting Up Your Project
+
+To use the SDK in a Node.js project with CommonJS syntax, you'll need to require the SDK modules in your JavaScript files. Here's how to set up a basic project structure and include the BSV SDK:
+
+1. **Create a New JavaScript File:** In your project directory, create a new file named `index.js` or any other name you prefer for your main application file.
+
+2. **Require the BSV SDK:** At the top of your `index.js` file, require the BSV SDK modules you plan to use. For example, to work with transactions, you might start with:
+
+```javascript
+const { Transaction } = require('@bsv/sdk');
+```
+
+3. **Configure Your Environment:** If your project involves interacting with the BSV blockchain network (e.g., sending transactions, querying blockchain data), ensure you have the necessary network configurations and API keys set up if required by the SDK or any third-party services you're using.
+
+## Example: Creating and Signing a Transaction
+
+Let's walk through a simple example of using the BSV SDK to create and sign a transaction. This example will demonstrate how to construct a transaction, add inputs and outputs, and sign it using a private key.
+
+1. **Prepare Your Script:** In your `index.js`, start by requiring the necessary modules from the SDK. For this example, we'll need `Transaction`, `PrivateKey`, and possibly other modules depending on the complexity of your transaction.
+
+```javascript
+const { Transaction, PrivateKey } = require('@bsv/sdk');
+```
+
+2. **Create a New Transaction:** Initialize a new `Transaction` object.
+
+```javascript
+let tx = new Transaction();
+```
+
+3. **Add Inputs and Outputs:** For this example, we'll add a dummy input and output. In a real-world scenario, you would fetch UTXO (Unspent Transaction Output) data from a blockchain explorer or your wallet.
+
+```javascript
+// Dummy input and output, replace with real data
+tx.from({
+  txId: 'your_utxo_txid',
+  outputIndex: 0,
+  address: 'your_address',
+  satoshis: 1000
+});
+tx.to('recipient_address', 500); // Send 500 satoshis to recipient
+```
+
+4. **Sign the Transaction:** Use a `PrivateKey` instance to sign the transaction. Replace `'your_private_key'` with your actual private key.
+
+```javascript
+const privateKey = new PrivateKey('your_private_key');
+tx.sign(privateKey);
+```
+
+5. **Broadcast the Transaction:** The SDK may provide a method to broadcast the transaction to the BSV network. This step varies depending on the SDK's capabilities and your setup.
+
+```javascript
+// This is a conceptual step; refer to the SDK documentation for actual broadcasting
+tx.broadcast();
+```
+
+## Running Your Project
+
+After setting up your project and writing the example code, you can run your project by executing:
+
+```bash
+node index.js
+```
+
+This command will run your `index.js` file, which includes the BSV SDK transaction creation and signing logic.
+
+## Conclusion
+
+You've now seen how to get started with the BSV SDK in a Node.js (CommonJS) environment, from installation to running a simple transaction example. This guide aimed to provide a straightforward path for integrating the B

package/docs/getting-started/REACT-TS.md

@@ -0,0 +1,131 @@
+# Getting Started with BSV SDK in a React TypeScript Project
+
+Welcome to a quick start guide designed to get you up and running with the BSV SDK in your React TypeScript projects. The BSV SDK offers a comprehensive set of tools for developing applications on the BSV Blockchain, and integrating it into a React application is straightforward. Follow these steps to begin building scalable blockchain applications with ease.
+
+## Prerequisites
+
+Before you start, ensure you have the following installed:
+- Node.js (preferably the latest LTS version)
+- npm (comes with Node.js) or Yarn
+- A code editor of your choice (VSCode is recommended for TypeScript projects)
+
+## Step 1: Setting Up Your React TypeScript Project
+
+If you're starting from scratch, create a new React TypeScript project by running the following command in your terminal:
+
+```bash
+npx create-react-app my-bsv-app --template typescript
+```
+
+This command creates a new React application named `my-bsv-app` with TypeScript setup. If you already have a React TypeScript project, you can skip this step.
+
+## Step 2: Installing the BSV SDK
+
+Navigate to your project directory in the terminal and install the BSV SDK by running:
+
+```bash
+npm install @bsv/sdk
+```
+
+or if you're using Yarn:
+
+```bash
+yarn add @bsv/sdk
+```
+
+This command adds the BSV SDK to your project, allowing you to interact with the BSV Blockchain.
+
+## Step 3: Using the BSV SDK in Your React Application
+
+Now that you've installed the SDK, let's use it to create and sign a transaction. First, create a new component where you'll implement your blockchain logic.
+
+### Create a New Component
+
+In your project's `src` directory, create a new file named `BlockchainExample.tsx`. This component will demonstrate a simple usage of the BSV SDK.
+
+### Implementing the Component
+
+Paste the following code into `BlockchainExample.tsx`:
+
+```typescript
+import React from 'react';
+// Import necessary modules from the SDK
+import { PrivateKey, Transaction } from '@bsv/sdk';
+
+const BlockchainExample: React.FC = () => {
+  // Example function to create and sign a transaction
+  const createTransaction = async () => {
+    try {
+      // Replace with actual private key and addresses
+      const privateKey = new PrivateKey('<your-private-key>');
+      const fromAddress = '<from-address>';
+      const toAddress = '<to-address>';
+      const satoshis = 1000; // Amount to send
+
+      // Create a new transaction
+      let tx = new Transaction();
+      tx.from(fromAddress) // Specify the sender's address
+        .to(toAddress, satoshis) // Specify the recipient and amount
+        .sign(privateKey); // Sign the transaction with the private key
+
+      console.log('Transaction created:', tx.toString());
+      // Add logic to broadcast the transaction
+    } catch (error) {
+      console.error('Error creating transaction:', error);
+    }
+  };
+
+  return (
+    <div>
+      <h2>Blockchain Example</h2>
+      <button onClick={createTransaction}>Create Transaction</button>
+    </div>
+  );
+};
+
+export default BlockchainExample;
+```
+
+**Note:** This is a simplified example for educational purposes. Replace placeholder values with actual private keys and addresses, and implement proper error handling and security measures in your real-world applications.
+
+### Add the Component to Your App
+
+Open `src/App.tsx` and import `BlockchainExample`. Include it in your application's render method:
+
+```typescript
+import React from 'react';
+import './App.css';
+import BlockchainExample from './BlockchainExample';
+
+function App() {
+  return (
+    <div className="App">
+      <header className="App-header">
+        <BlockchainExample />
+      </header>
+    </div>
+  );
+}
+
+export default App;
+```
+
+## Step 4: Running Your Application
+
+Now that everything is set up, start your application by running:
+
+```bash
+npm start
+```
+
+or if you're using Yarn:
+
+```bash
+yarn start
+```
+
+Your application will open in your default web browser. You'll see a button labeled "Create Transaction" that, when clicked, will run the logic to create and sign a transaction using the BSV SDK.
+
+## Next Steps
+
+This guide covered the basics to get you started with the BSV SDK in a React TypeScript project. Explore the SDK's comprehensive documentation to learn more about its capabilities, such as cryptographic primitives, script-level constructs, transaction construction, and much more. Happy coding!

package/docs/getting-started/TS-NODE.md

@@ -0,0 +1,106 @@
+To get started with the BSV SDK in a Node.js TypeScript project, follow these steps to install, configure, and use the library efficiently. This guide will help you set up a basic project structure, install the SDK, and create a simple application that uses BSV SDK functionalities.
+
+### Prerequisites
+
+Before you begin, ensure you have the following installed on your system:
+
+- Node.js (version 12.x or higher)
+- npm (usually comes with Node.js)
+- TypeScript (version 3.8 or higher)
+
+You can check the versions by running `node -v` and `npm -v` in your terminal.
+
+### Step 1: Setting Up Your Project
+
+If you're starting a new project, create a new directory for your project and initialize it with npm:
+
+```bash
+mkdir my-bsv-project
+cd my-bsv-project
+npm init -y
+```
+
+Install TypeScript and ts-node (for executing TypeScript files directly) as dev dependencies:
+
+```bash
+npm install typescript ts-node --save-dev
+```
+
+Create a `tsconfig.json` file to configure TypeScript options:
+
+```json
+{
+  "compilerOptions": {
+    "target": "es2018",
+    "module": "commonjs",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./dist"
+  },
+  "include": ["src/**/*"]
+}
+```
+
+This configuration is a good starting point for Node.js projects. Adjust it as necessary for your project needs.
+
+### Step 2: Installing BSV SDK
+
+Install the BSV SDK using npm:
+
+```bash
+npm install @bsv/sdk
+```
+
+This command installs the SDK and adds it to your project's `package.json` dependencies.
+
+### Step 3: Creating a TypeScript File
+
+In your project directory, create a `src` folder to hold your TypeScript files:
+
+```bash
+mkdir src
+```
+
+Inside the `src` folder, create a file named `index.ts`. This file will contain your code to interact with the BSV blockchain using the SDK.
+
+### Step 4: Using BSV SDK in Your Project
+
+Now, let's use the SDK to create and sign a transaction as an example. Open `src/index.ts` and add the following TypeScript code:
+
+```typescript
+import { PrivateKey, Transaction } from '@bsv/sdk';
+
+async function createAndSignTransaction() {
+  const privateKey = new PrivateKey();
+  const address = privateKey.toAddress();
+  
+  const tx = new Transaction();
+  tx.from(/* UTXO details here */);
+  tx.to(address, 1000); // Send 1000 satoshis to our address
+  tx.change(address); // Return the change to our address
+  await tx.sign(privateKey);
+
+  console.log(`Transaction ID: ${tx.id()}`);
+  console.log(`Raw Transaction: ${tx.serialize()}`);
+}
+
+createAndSignTransaction().catch(console.error);
+```
+
+Note: Replace `/* UTXO details here */` with actual UTXO (Unspent Transaction Output) details. This example assumes you have some UTXOs to spend.
+
+### Step 5: Running Your Code
+
+Finally, run your TypeScript file with `ts-node`:
+
+```bash
+npx ts-node src/index.ts
+```
+
+This command compiles your TypeScript code to JavaScript and executes it, displaying the transaction ID and raw transaction in the console.
+
+### Conclusion
+
+You've now set up a basic Node.js TypeScript project using the BSV SDK. This guide covered project initialization, SDK installation, and a simple application to create and sign transactions. Explore the SDK's extensive documentation to learn more about its features and capabilities for developing on the BSV blockchain.

package/docs/getting-started/VUE.md

@@ -0,0 +1,103 @@
+# Getting Started with BSV SDK in a Vue TypeScript Project
+
+Welcome to the quick start guide for integrating the BSV SDK into your Vue TypeScript project. This guide will walk you through the setup and basic usage of the BSV SDK, enabling you to build scalable applications on the BSV Blockchain. Let’s dive into how you can add blockchain capabilities to your Vue application.
+
+## Prerequisites
+
+Before starting, ensure you have the following installed:
+- Node.js (12.x or later)
+- npm (6.x or later)
+- Vue CLI (3.x or later)
+
+If you're new to Vue or TypeScript, it might be helpful to familiarize yourself with the basics of creating a Vue project with TypeScript support.
+
+## Step 1: Create Your Vue Project
+
+If you haven't already, start by creating a new Vue project. Open your terminal and run:
+
+```bash
+vue create my-bsv-app
+```
+
+During the setup, choose "Manually select features" to select TypeScript. Follow the prompts to set up TypeScript with Vue.
+
+## Step 2: Install the BSV SDK
+
+Navigate to your project directory in the terminal and install the BSV SDK by running:
+
+```bash
+npm install @bsv/sdk
+```
+
+This command will add the BSV SDK as a dependency to your project, making its functionality available for use in your Vue components.
+
+## Step 3: Initialize the SDK in Your Vue Application
+
+Create a new file `bsvPlugin.ts` in your project's `src` directory. This file will set up the BSV SDK so that it can be easily used throughout your application.
+
+```typescript
+// src/bsvPlugin.ts
+
+import { createApp } from 'vue';
+import App from './App.vue';
+
+// Import the SDK
+import * as BSV from '@bsv/sdk';
+
+const app = createApp(App);
+
+// Here you can add BSV SDK to Vue's global properties for easy access in components
+app.config.globalProperties.$bsv = BSV;
+
+app.mount('#app');
+```
+
+Update your `main.ts` to use this new setup:
+
+```typescript
+// src/main.ts
+
+import './bsvPlugin';
+```
+
+## Step 4: Using the BSV SDK in Your Components
+
+Now that you have the BSV SDK integrated into your Vue application, you can start using it in your components. Here's an example of how to create and sign a transaction within a Vue component:
+
+1. **Create a new Vue component** `TransactionComponent.vue` in your `src/components` directory.
+2. **Implement the BSV SDK logic** within your component:
+
+```vue
+<template>
+  <div>
+    <h1>Create and Sign a Transaction</h1>
+    <!-- Transaction form and submission button will go here -->
+  </div>
+</template>
+
+<script lang="ts">
+import { defineComponent } from 'vue';
+
+export default defineComponent({
+  name: 'TransactionComponent',
+  methods: {
+    async createAndSignTransaction() {
+      // Access the BSV SDK from the global properties
+      const BSV = this.$bsv;
+
+      // Example: Creating a new PublicKey
+      const privateKey = BSV.PrivateKey.fromRandom();
+      const publicKey = privateKey.toPublicKey();
+
+      console.log('PublicKey:', publicKey.toString());
+
+      // Add your transaction logic here
+    }
+  }
+});
+</script>
+```
+
+## Step 5: Interacting with the Blockchain
+
+With the BSV SDK now part of your Vue application, you can extend the functionality as needed to interact with the BSV Blockchain. Use the SDK's comprehensive API to create transactions, manage keys, verify signatures, and much more.

package/docs/messages.md

@@ -0,0 +1,146 @@
+# API
+
+Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
+
+## Classes
+
+## Functions
+
+## Variables
+
+| |
+| --- |
+| [decrypt](#variable-decrypt) |
+| [encrypt](#variable-encrypt) |
+| [sign](#variable-sign) |
+| [verify](#variable-verify) |
+
+Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
+
+---
+
+### Variable: sign
+
+```ts
+sign = (message: number[], signer: PrivateKey, verifier?: PublicKey): number[] => {
+    const recipientAnyone = typeof verifier !== "object";
+    if (recipientAnyone) {
+        const curve = new Curve();
+        const anyone = new PrivateKey(1);
+        const anyonePoint = curve.g.mul(anyone);
+        verifier = new PublicKey(anyonePoint.x, anyonePoint.y);
+    }
+    const keyID = Random(32);
+    const keyIDBase64 = toBase64(keyID);
+    const invoiceNumber = `2-message signing-${keyIDBase64}`;
+    const signingKey = signer.deriveChild(verifier, invoiceNumber);
+    const signature = signingKey.sign(message).toDER();
+    const senderPublicKey = signer.toPublicKey().encode(true);
+    const version = toArray(VERSION, "hex");
+    return [
+        ...version,
+        ...senderPublicKey,
+        ...(recipientAnyone ? [0] : verifier.encode(true)),
+        ...keyID,
+        ...signature
+    ];
+}
+```
+
+Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
+
+---
+### Variable: verify
+
+```ts
+verify = (message: number[], sig: number[], recipient?: PrivateKey): boolean => {
+    const reader = new Reader(sig);
+    const messageVersion = toHex(reader.read(4));
+    if (messageVersion !== VERSION) {
+        throw new Error(`Message version mismatch: Expected ${VERSION}, received ${messageVersion}`);
+    }
+    const signer = PublicKey.fromString(toHex(reader.read(33)));
+    const [verifierFirst] = reader.read(1);
+    if (verifierFirst === 0) {
+        recipient = new PrivateKey(1);
+    }
+    else {
+        const verifierRest = reader.read(32);
+        const verifierDER = toHex([verifierFirst, ...verifierRest]);
+        if (typeof recipient !== "object") {
+            throw new Error(`This signature can only be verified with knowledge of a specific private key. The associated public key is: ${verifierDER}`);
+        }
+        const recipientDER = recipient.toPublicKey().encode(true, "hex") as string;
+        if (verifierDER !== recipientDER) {
+            throw new Error(`The recipient public key is ${recipientDER} but the signature requres the recipient to have public key ${verifierDER}`);
+        }
+    }
+    const keyID = toBase64(reader.read(32));
+    const signatureDER = toHex(reader.read(reader.bin.length - reader.pos));
+    const signature = Signature.fromDER(signatureDER, "hex");
+    const invoiceNumber = `2-message signing-${keyID}`;
+    const signingKey = signer.deriveChild(recipient, invoiceNumber);
+    const verified = signingKey.verify(message, signature);
+    return verified;
+}
+```
+
+Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
+
+---
+### Variable: encrypt
+
+```ts
+encrypt = (message: number[], sender: PrivateKey, recipient: PublicKey): number[] => {
+    const keyID = Random(32);
+    const keyIDBase64 = toBase64(keyID);
+    const invoiceNumber = `2-message encryption-${keyIDBase64}`;
+    const signingPriv = sender.deriveChild(recipient, invoiceNumber);
+    const recipientPub = recipient.deriveChild(sender, invoiceNumber);
+    const sharedSecret = signingPriv.deriveSharedSecret(recipientPub);
+    const symmetricKey = new SymmetricKey(sharedSecret.encode(true).slice(1));
+    const encrypted = symmetricKey.encrypt(message) as number[];
+    const senderPublicKey = sender.toPublicKey().encode(true);
+    const version = toArray(VERSION, "hex");
+    return [
+        ...version,
+        ...senderPublicKey,
+        ...recipient.encode(true),
+        ...keyID,
+        ...encrypted
+    ];
+}
+```
+
+Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
+
+---
+### Variable: decrypt
+
+```ts
+decrypt = (message: number[], recipient: PrivateKey): number[] => {
+    const reader = new Reader(message);
+    const messageVersion = toHex(reader.read(4));
+    if (messageVersion !== VERSION) {
+        throw new Error(`Message version mismatch: Expected ${VERSION}, received ${messageVersion}`);
+    }
+    const sender = PublicKey.fromString(toHex(reader.read(33)));
+    const expectedRecipientDER = toHex(reader.read(33));
+    const actualRecipientDER = recipient.toPublicKey().encode(true, "hex") as string;
+    if (expectedRecipientDER !== actualRecipientDER) {
+        throw new Error(`The encrypted message expects a recipient public key of ${expectedRecipientDER}, but the provided key is ${actualRecipientDER}`);
+    }
+    const keyID = toBase64(reader.read(32));
+    const encrypted = reader.read(reader.bin.length - reader.pos);
+    const invoiceNumber = `2-message encryption-${keyID}`;
+    const signingPriv = sender.deriveChild(recipient, invoiceNumber);
+    const recipientPub = recipient.deriveChild(sender, invoiceNumber);
+    const sharedSecret = signingPriv.deriveSharedSecret(recipientPub);
+    const symmetricKey = new SymmetricKey(sharedSecret.encode(true).slice(1));
+    return symmetricKey.decrypt(encrypted) as number[];
+}
+```
+
+Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
+
+---