signet.js 0.0.1-beta.7 → 0.0.1-beta.9

package/.eslintrc.json

@@ -1,55 +0,0 @@
-{
-  "env": {
-    "browser": true,
-    "es2021": true
-  },
-  "extends": [
-    "standard-with-typescript",
-    "plugin:import/typescript",
-    "plugin:prettier/recommended"
-  ],
-  "parserOptions": {
-    "project": ["./tsconfig.json", "./tsconfig.eslint.json"]
-  },
-  "rules": {
-    "@typescript-eslint/strict-boolean-expressions": "off",
-    "@typescript-eslint/prefer-nullish-coalescing": "off",
-    "import/order": [
-      "error",
-      {
-        "groups": [
-          "builtin",
-          "external",
-          "internal",
-          "parent",
-          "sibling",
-          "index"
-        ],
-        "pathGroups": [
-          {
-            "pattern": "@chains",
-            "group": "internal"
-          },
-          {
-            "pattern": "@chains/**",
-            "group": "internal"
-          },
-          {
-            "pattern": "@utils",
-            "group": "internal"
-          },
-          {
-            "pattern": "@utils/**",
-            "group": "internal"
-          }
-        ],
-        "pathGroupsExcludedImportTypes": ["builtin"],
-        "newlines-between": "always",
-        "alphabetize": {
-          "order": "asc",
-          "caseInsensitive": true
-        }
-      }
-    ]
-  }
-}

package/.prettierrc

@@ -1 +0,0 @@
-{ "singleQuote": true, "trailingComma": "es5", "semi": false }

package/babel.config.js

@@ -1,6 +0,0 @@
-module.exports = {
-  presets: [
-    ['@babel/preset-env', { targets: { node: 'current' } }],
-    '@babel/preset-typescript',
-  ],
-}

package/docs/pages/chain-signatures-contract.mdx

@@ -1,56 +0,0 @@
-# Implementing a Custom Chain Signature Contract
-
-This guide explains how to implement a custom Chain Signature Contract to provide as argument when instantiating a Chain instance.
-
-## Overview
-
-The `ChainSignatureContract` is an abstract class that defines the interface for interacting with the Sig Network infrastructure.
-
-- Key Derivation: Derive the child key from the root key using Sig Network key derivation function
-- Sign: Sigs the given payload using Sig Network MPC
-- Current Fee: Gets the current signature deposit that handles network congestion
-
-While the library includes a default implementation for the NEAR protocol, you have the flexibility to implement your own contract for other blockchain networks.
-
-## Using the NEAR Implementation
-
-```ts twoslash
-// [!include ~/snippets/env.ts]
-// ---cut---
-import { utils, EVM } from 'signet.js'
-
-const contract = new utils.chains.near.ChainSignatureContract({
-  networkId: 'testnet',
-  contractId: 'v1.signer-prod.testnet',
-  accountId,
-  keypair,
-})
-
-const evmChain = new EVM({
-  rpcUrl: 'https://mainnet.infura.io/v3/YOUR-PROJECT-ID',
-  contract,
-})
-```
-
-Currently the contracts are available on the following Near addresses:
-
-- Mainnet:
-  - `v1.signer`
-- Testnet:
-  - `v1.signer-prod.testnet`
-
-## Implementing a Custom Chain Signature Contract
-
-To create your own implementation, your contract must implement the `ChainSignatureContract` interface.
-
-```ts twoslash
-// [!include ~/../src/chains/ChainSignatureContract.ts]
-```
-
-### Example: NEAR Implementation
-
-Below is the reference implementation for the NEAR, which you can use as a guide for implementing your own chain signature contract:
-
-```ts twoslash
-// [!include ~/../src/utils/chains/near/ChainSignatureContract.ts]
-```

package/docs/pages/chain.mdx

@@ -1,45 +0,0 @@
-# Chain
-
-Chain is the most basic interface of the signet.js library. It provides a standard set of methods that all chains must implement.
-
-With this interface you will be able to interact with Sig Network smart contracts in a standard way to:
-
-- getBalance
-- deriveAddressAndPublicKey
-- setTransaction
-- getTransaction
-- getMPCPayloadAndTransaction
-- addSignature
-- broadcastTx
-
-If you wanna have a look this is the chain interface with a brief description of each method:
-
-```ts twoslash
-// [!include ~/../src/chains/Chain.ts]
-```
-
-# Implementing a New Chain
-
-This guide explains how to implement support for a new blockchain network in the signet.js library.
-
-## Overview
-
-To add support for a new blockchain, you need to implement the `Chain` interface:
-
-## Step-by-Step Guide
-
-### 1. Create the Chain Types
-
-First, define the transaction types for your chain:
-
-```ts twoslash
-// [!include ~/../src/chains/EVM/types.ts]
-```
-
-### 2. Implement the Chain Interface
-
-Create a new class that implements the `Chain` interface:
-
-```ts twoslash
-// [!include ~/../src/chains/EVM/EVM.ts]
-```

package/docs/pages/chains/bitcoin/bitcoin.mdx

@@ -1,191 +0,0 @@
-# Bitcoin Chain Implementation
-
-The Bitcoin chain implementation supports both Bitcoin mainnet and testnet networks, with a focus on P2WPKH (Native SegWit) transactions.
-
-## Configuration
-
-```ts twoslash filename="base.ts"
-// [!include ~/snippets/contract.ts]
-// ---cut---
-import { Bitcoin, BTCRpcAdapters } from 'signet.js'
-
-// Initialize the RPC adapter using Mempool
-const btcRpcAdapter = new BTCRpcAdapters.Mempool('https://mempool.space/api')
-
-// Initialize the chain
-const bitcoinChain = new Bitcoin({
-  network: 'testnet', // 'mainnet' | 'testnet' | 'regtest'
-  contract,
-  btcRpcAdapter,
-})
-```
-
-## RPC Adapter
-
-The RPC adapter is a class that provides an interface for interacting with the Bitcoin network. It handles essential operations such as:
-
-- Fetching UTXOs (Unspent Transaction Outputs)
-- Retrieving transaction details
-- Getting current network fees
-- Broadcasting transactions
-- Querying address balances
-
-The adapter abstracts away the complexity of different Bitcoin API providers, allowing you to easily switch between services like Mempool.space, BlockCypher, or your own Bitcoin node.
-
-For detailed implementation and configuration options, see the [RPC Adapter](./btc-rpc-adapter) documentation.
-
-## Methods
-
-### getBalance
-
-Gets the BTC balance of an address.
-
-```ts twoslash
-// [!include base.ts]
-// ---cut---
-const balance = await bitcoinChain.getBalance(
-  'bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh'
-)
-```
-
-**Parameters:**
-
-- `address`: The Bitcoin address to check
-
-**Returns:**
-
-- The balance in BTC as a string
-
-### deriveAddressAndPublicKey
-
-Derives a Bitcoin address and public key for a given path.
-
-```ts twoslash
-// [!include base.ts]
-// ---cut---
-const { address, publicKey } = await bitcoinChain.deriveAddressAndPublicKey(
-  'predecessor_id',
-  'any_string'
-)
-```
-
-**Parameters:**
-
-- `predecessor`: The ID of the signer to derive from
-- `path`: The derivation path to use
-
-**Returns:**
-
-- Object containing:
-  - `address`: The derived Bitcoin P2WPKH address
-  - `publicKey`: The corresponding compressed public key
-
-### getMPCPayloadAndTransaction
-
-Prepares a transaction for MPC signing.
-
-```ts twoslash filename="unsigned-transaction.ts"
-// [!include base.ts]
-// ---cut---
-import { BTCTransactionRequest } from 'signet.js'
-
-// Simple transfer format
-const transactionRequest: BTCTransactionRequest = {
-  from: 'bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh',
-  to: 'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4',
-  value: '0.001', // 0.001 BTC
-  publicKey: '0235a3...',
-}
-
-const { transaction: unsignedTransaction, mpcPayloads } =
-  await bitcoinChain.getMPCPayloadAndTransaction(transactionRequest)
-```
-
-**Parameters:**
-
-- `transactionRequest`: Either:
-  - Simple format:
-    ```ts
-    {
-      from: string // Source address
-      to: string // Destination address
-      value: string // Amount in BTC
-      publicKey: string // Signer's public key
-    }
-    ```
-  - Advanced format (manual UTXO selection):
-    ```ts
-    {
-      inputs: BTCInput[]   // Selected UTXOs
-      outputs: BTCOutput[] // Transaction outputs
-      publicKey: string    // Signer's public key
-    }
-    ```
-
-**Returns:**
-
-- Object containing:
-  - `transaction`: The unsigned transaction with PSBT
-  - `mpcPayloads`: Array of payloads to be signed
-
-### addSignature
-
-Adds signatures to a PSBT.
-
-```ts twoslash filename="add-signature.ts"
-// [!include unsigned-transaction.ts]
-// ---cut---
-import { RSVSignature } from 'signet.js'
-
-// Ideally it would be a request to the Sig Network Smart Contract
-const mpcSignatures: RSVSignature[] = [
-  {
-    r: '0x...',
-    s: '0x...',
-    v: 27,
-  },
-]
-
-const signedTx = bitcoinChain.addSignature({
-  transaction: unsignedTransaction,
-  mpcSignatures,
-})
-```
-
-**Parameters:**
-
-- `transaction`: The unsigned transaction with PSBT
-- `mpcSignatures`: Array of RSV signatures from MPC
-
-**Returns:**
-
-- The serialized signed transaction in hex format
-
-### broadcastTx
-
-Broadcasts a signed transaction to the network.
-
-```ts twoslash filename="broadcast-tx.ts"
-// [!include add-signature.ts]
-// ---cut---
-const txid = await bitcoinChain.broadcastTx(signedTx)
-```
-
-**Parameters:**
-
-- `txSerialized`: The serialized transaction in hex format
-
-**Returns:**
-
-- The transaction ID (txid)
-
-## Technical Details
-
-The implementation:
-
-- Uses `bitcoinjs-lib` for transaction handling
-- Supports P2WPKH (Native SegWit) addresses
-- Handles automatic UTXO selection and change outputs
-- Supports custom fee rates through the RPC adapter
-- Uses PSBT (Partially Signed Bitcoin Transactions)
-- Supports both mainnet and testnet networks

package/docs/pages/chains/bitcoin/btc-rpc-adapter.mdx

@@ -1,307 +0,0 @@
-# Implementing a Bitcoin RPC Adapter
-
-This guide explains how to implement a custom RPC adapter for interacting with Bitcoin nodes or services.
-
-## Overview
-
-The `BTCRpcAdapter` provides an abstraction layer for Bitcoin-specific operations like UTXO management, balance queries, and transaction broadcasting. You might want to implement a custom adapter when:
-
-- Using a different Bitcoin node implementation
-- Integrating with a specific blockchain service
-- Adding support for custom transaction types
-- Implementing specialized UTXO selection strategies
-
-## Step-by-Step Guide
-
-### 1. Define the Required Types
-
-First, ensure you have the necessary types defined:
-
-```typescript
-interface BTCInput {
-  txid: string
-  vout: number
-  value: number
-  address: string
-  scriptPubKey: string
-}
-
-interface BTCOutput {
-  address: string
-  value: number
-}
-
-interface BTCTransaction {
-  txid: string
-  vout: Array<{
-    scriptpubkey: string
-    value: number
-  }>
-}
-```
-
-### 2. Implement the BTCRpcAdapter
-
-Create a new class that extends the `BTCRpcAdapter` abstract class:
-
-```typescript
-import { BTCRpcAdapter } from '../BTCRpcAdapter'
-import { BTCInput, BTCOutput, BTCTransaction } from '../types'
-
-export class CustomBTCAdapter extends BTCRpcAdapter {
-  constructor(
-    private readonly config: {
-      url: string
-      apiKey?: string
-    }
-  ) {
-    super()
-  }
-
-  async getBalance(address: string): Promise<number> {
-    // Implement balance fetching
-    const response = await fetch(
-      `${this.config.url}/address/${address}/balance`,
-      {
-        headers: this.getHeaders(),
-      }
-    )
-
-    if (!response.ok) {
-      throw new Error(`Failed to fetch balance: ${await response.text()}`)
-    }
-
-    const data = await response.json()
-    return data.balance // Return balance in satoshis
-  }
-
-  async getTransaction(txid: string): Promise<BTCTransaction> {
-    // Implement transaction fetching
-    const response = await fetch(`${this.config.url}/tx/${txid}`, {
-      headers: this.getHeaders(),
-    })
-
-    if (!response.ok) {
-      throw new Error(`Failed to fetch transaction: ${await response.text()}`)
-    }
-
-    return await response.json()
-  }
-
-  async selectUTXOs(
-    from: string,
-    outputs: BTCOutput[],
-    confirmationTarget = 6
-  ): Promise<{
-    inputs: BTCInput[]
-    outputs: BTCOutput[]
-  }> {
-    // 1. Fetch available UTXOs
-    const utxos = await this.fetchUTXOs(from)
-
-    // 2. Get current fee rate
-    const feeRate = await this.getFeeRate(confirmationTarget)
-
-    // 3. Use coinselect for UTXO selection
-    const { inputs, outputs } = coinselect(utxos, outputs, feeRate)
-
-    if (!inputs || !outputs) {
-      throw new Error('Failed to select UTXOs')
-    }
-
-    return { inputs, outputs }
-  }
-
-  async broadcastTransaction(txHex: string): Promise<string> {
-    // Implement transaction broadcasting
-    const response = await fetch(`${this.config.url}/tx`, {
-      method: 'POST',
-      headers: this.getHeaders(),
-      body: txHex,
-    })
-
-    if (!response.ok) {
-      throw new Error(
-        `Failed to broadcast transaction: ${await response.text()}`
-      )
-    }
-
-    return await response.text() // Return txid
-  }
-
-  // Helper methods
-  private getHeaders(): Record<string, string> {
-    const headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-    }
-
-    if (this.config.apiKey) {
-      headers['Authorization'] = `Bearer ${this.config.apiKey}`
-    }
-
-    return headers
-  }
-
-  private async fetchUTXOs(address: string): Promise<BTCInput[]> {
-    const response = await fetch(`${this.config.url}/address/${address}/utxo`, {
-      headers: this.getHeaders(),
-    })
-
-    if (!response.ok) {
-      throw new Error(`Failed to fetch UTXOs: ${await response.text()}`)
-    }
-
-    return await response.json()
-  }
-
-  private async getFeeRate(confirmationTarget: number): Promise<number> {
-    const response = await fetch(`${this.config.url}/fees/recommended`, {
-      headers: this.getHeaders(),
-    })
-
-    if (!response.ok) {
-      throw new Error(`Failed to fetch fee rate: ${await response.text()}`)
-    }
-
-    const fees = await response.json()
-    return fees[`${confirmationTarget}BlockFee`]
-  }
-}
-```
-
-### 3. Implement Error Handling
-
-Add proper error handling for your adapter:
-
-```typescript
-class BTCAdapterError extends Error {
-  constructor(
-    message: string,
-    public readonly code: string,
-    public readonly httpStatus?: number
-  ) {
-    super(message)
-    this.name = 'BTCAdapterError'
-  }
-}
-
-// Usage in adapter methods
-private async handleResponse<T>(
-  response: Response,
-  errorContext: string
-): Promise<T> {
-  if (!response.ok) {
-    throw new BTCAdapterError(
-      `${errorContext}: ${await response.text()}`,
-      'API_ERROR',
-      response.status
-    )
-  }
-
-  return await response.json()
-}
-```
-
-### 4. Add UTXO Selection Strategy
-
-Implement a custom UTXO selection strategy if needed:
-
-```typescript
-interface UTXOSelectionStrategy {
-  select(
-    utxos: BTCInput[],
-    outputs: BTCOutput[],
-    feeRate: number
-  ): {
-    inputs: BTCInput[]
-    outputs: BTCOutput[]
-  }
-}
-
-class LargestFirstStrategy implements UTXOSelectionStrategy {
-  select(
-    utxos: BTCInput[],
-    outputs: BTCOutput[],
-    feeRate: number
-  ): {
-    inputs: BTCInput[]
-    outputs: BTCOutput[]
-  } {
-    // Sort UTXOs by value (largest first)
-    const sortedUtxos = [...utxos].sort((a, b) => b.value - a.value)
-
-    // Implement selection logic
-    // ...
-
-    return { inputs, outputs }
-  }
-}
-```
-
-## Example Usage
-
-```typescript
-// Initialize the adapter
-const btcAdapter = new CustomBTCAdapter({
-  url: 'https://api.bitcoin-service.com',
-  apiKey: 'your-api-key',
-})
-
-// Use in Bitcoin chain implementation
-const bitcoinChain = new Bitcoin({
-  network: 'mainnet',
-  contract: new ChainSignatureContract(...),
-  btcRpcAdapter: btcAdapter,
-})
-
-// Direct usage
-const balance = await btcAdapter.getBalance('bc1...')
-
-const { inputs, outputs } = await btcAdapter.selectUTXOs(
-  'bc1...',
-  [{ address: 'bc1...', value: 100000 }]
-)
-
-const txid = await btcAdapter.broadcastTransaction(signedTxHex)
-```
-
-## Testing
-
-Create comprehensive tests for your adapter:
-
-```typescript
-describe('CustomBTCAdapter', () => {
-  let adapter: CustomBTCAdapter
-  let mockFetch: jest.Mock
-
-  beforeEach(() => {
-    mockFetch = jest.fn()
-    global.fetch = mockFetch
-    adapter = new CustomBTCAdapter({
-      url: 'https://test.api',
-      apiKey: 'test-key',
-    })
-  })
-
-  describe('getBalance', () => {
-    it('should return balance in satoshis', async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: () => Promise.resolve({ balance: 100000 }),
-      })
-
-      const balance = await adapter.getBalance('bc1...')
-      expect(balance).toBe(100000)
-    })
-
-    it('should handle errors', async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: false,
-        text: () => Promise.resolve('API Error'),
-      })
-
-      await expect(adapter.getBalance('bc1...')).rejects.toThrow()
-    })
-  })
-})
-```