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

package/.eslintrc.json

@@ -0,0 +1,55 @@
+{
+  "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

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

package/LICENSE

@@ -0,0 +1,19 @@
+The MIT License (MIT)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -28,38 +28,66 @@ pnpm add signet.js
 ## Quick Example
 
 ```ts twoslash
-import { EVM, near } from 'signet.js'
+import { EVM, utils } from 'signet.js'
+import { KeyPair, type KeyPairString } from '@near-js/crypto'
 
-// Initialize MPC contract
-const contract = new near.contract.ChainSignaturesContract({
+// Initialize NEAR connection with credentials from environment
+const accountId = process.env.NEAR_ACCOUNT_ID
+const privateKey = process.env.NEAR_PRIVATE_KEY as KeyPairString
+
+if (!accountId || !privateKey) {
+  throw new Error(
+    'NEAR_ACCOUNT_ID and NEAR_PRIVATE_KEY must be set in environment'
+  )
+}
+
+const keypair = KeyPair.fromString(privateKey)
+
+const contract = new utils.chains.near.ChainSignatureContract({
   networkId: 'testnet',
-  contractId: 'mpc.testnet',
+  contractId: 'v1.signer-prod.testnet',
+  accountId,
+  keypair,
 })
 
-// Initialize chain
-const chain = new EVM({
+const evmChain = new EVM({
   rpcUrl: 'https://mainnet.infura.io/v3/YOUR-PROJECT-ID',
   contract,
 })
 
-// Create and sign transaction
-const { transaction, mpcPayloads } = await chain.getMPCPayloadAndTransaction({
-  to: '0x1234...',
-  value: '1000000000000000000', // 1 ETH
-})
+// Derive address and public key
+const { address, publicKey } = await evmChain.deriveAddressAndPublicKey(
+  accountId,
+  'any_string'
+)
+
+// Check balance
+const balance = await evmChain.getBalance(address)
 
+// Create and sign transaction
+const { transaction, mpcPayloads } = await evmChain.getMPCPayloadAndTransaction(
+  {
+    from: '0x...',
+    to: '0x...',
+    value: '1000000000000000000',
+  }
+)
+
+// Sign with MPC
 const signature = await contract.sign({
   payload: mpcPayloads[0].payload,
   path: 'any_string',
   key_version: 0,
 })
 
-const signedTx = chain.addSignature({
+// Add signature
+const signedTx = evmChain.addSignature({
   transaction,
   mpcSignatures: [signature],
 })
 
-const txHash = await chain.broadcastTx(signedTx)
+// Broadcast transaction
+const txHash = await evmChain.broadcastTx(signedTx)
 ```
 
 ## Documentation
@@ -72,4 +100,4 @@ For detailed documentation, including:
 - Implementation guides
 - API reference
 
-Visit our [documentation site](https://near.github.io/signet.js).
+Visit our [documentation site](https://signet-js.vercel.app/).

package/babel.config.js

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

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

@@ -0,0 +1,56 @@
+# 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

@@ -0,0 +1,45 @@
+# 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

@@ -0,0 +1,191 @@
+# 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