signet.js 0.0.7 → 0.0.9-retry

package/docs/pages/examples/arbitrary-hash.mdx

@@ -1,73 +0,0 @@
-## Signing an Arbitrary Hash
-
-Below is a **working example** of how to **request** and **retrieve** a signature for an arbitrary 32-byte hash from the **ChainSignatures** contract **deployed on Sepolia**.
-
-> **Assumption**:
->
-> - The ChainSignatures contract is deployed at `0x69C6b28Fdc74618817fa380De29a653060e14009` (example).
-> - You have a web3 provider (e.g., viem) pointing to Sepolia.
-
-### Prepare Your Ethers Contract Instance
-
-```ts twoslash filename="init-contract.ts"
-import { contracts, constants } from 'signet.js'
-// [!include ~/snippets/code/evm/env.ts]
-
-const evmChainSigContract = new contracts.evm.ChainSignatureContract({
-  publicClient,
-  walletClient,
-  contractAddress: constants.CONTRACT_ADDRESSES.ETHEREUM
-    .TESTNET_DEV as `0x${string}`,
-})
-```
-
-### Request a Signature on an Arbitrary Hash
-
-```ts twoslash filename="request-signature.ts"
-// [!include init-contract.ts]
-// ---cut---
-
-// Suppose you have a 32-byte hash you'd like to have signed:
-const hashToSign = Array.from(new Uint8Array(32).fill(1)) // Must be exactly 32 bytes
-
-// Derive the path you want (could be any string)
-const path = 'myArbitraryPath'
-
-// Key version (check chainSignatures.latestKeyVersion() if needed)
-const keyVersion = 0
-
-const signature = await evmChainSigContract.sign({
-  path,
-  key_version: keyVersion,
-  payload: hashToSign,
-})
-```
-
-- At this point, the mpc network sees the `SignatureRequested` event, does the off-chain ECDSA signing, and calls `respond(...)`.
-
-### Retrieve the Signature Once Responded
-
-The MPC network will call:
-
-```solidity
-chainSignatures.respond(
-  requestId,
-  SignatureResponse({
-    bigR: AffinePoint({ x: rPointX, y: rPointY }),
-    s: sValue,
-    recoveryId: vValue
-  })
-);
-```
-
-After that transaction is confirmed, a `SignatureResponded` event is emitted. The `sign` methods will handle the event polling internally and return the signature components to you:
-
-```ts twoslash filename="retrieve-signature.ts"
-// [!include request-signature.ts]
-// ---cut---
-console.log('r:', signature.r)
-console.log('s:', signature.s)
-console.log('v:', signature.v)
-```
-
-You now have the ECDSA components (`r`, `s`, `v`) to do whatever you need with them. The deposit is refunded automatically to `msg.sender` of the original `sign` call if there's any excess.

package/docs/pages/examples/sponsor-foreign-chain-gas.mdx

@@ -1 +0,0 @@
-## TODO

package/docs/pages/index.mdx

@@ -1,36 +0,0 @@
-## Introduction
-
-Managing multiple accounts across different blockchains is a headache. Every chain has its own wallets, private keys, and authentication systems, making cross-chain interactions complex and fragmented. But what if a single abstract account could seamlessly control multiple accounts across different chains—without compromising security? That's now possible through Chain Signatures.
-
-### What Are Chain Signatures?
-
-Chain Signatures are programmable digital signatures that enable cross-chain control, allowing one account on one blockchain to securely manage accounts and assets on entirely different chains.
-The system:
-
-- **Derives keys** from a single base key.
-- Allows third parties (e.g., dApps, wallets, or protocols) to **request signatures** on-chain.
-- Introduces **flexible usage controls**, such as daily spending limits or rate limits, by combining these keys with custom on-chain logic.
-
-### Benefits & Use Cases:
-
-- **One Identity, Many Chains**: Instead of juggling multiple wallets, a single signature from your Ethereum account could authorize actions on any other supported EVM or non-EVM chain, without needing to manage separate private keys.
-- **Seamless Cross-Chain Transactions**: Move assets or execute smart contract functions across different chains, without relying on third-party bridges or centralized custodians.
-- **Usage Controls**: rate or time-based restrictions can be enforced by the on-chain contract that manages key usage (e.g., "this key can only send up to 1 ETH per day").
-- **Recovery or Fallback Conditions**: Instead of storing private keys in a single hardware device, you can use a multi-party computation (MPC) setup that offers user-friendly ways to recover accounts.
-- **Signs the Arbitrary State of a Foreign Chain**: Gives your smart contract awareness of whether a transaction it signed went through so that it can perform actions accordingly. For example, it allows for a smart contract to keep track of local chain assets based on the foreign chain's state.
-
-## How It Works?
-
-### Contract Background
-
-The **ChainSignatures** contract:
-
-- Holds a base public key (`publicKey`), expressed in affine coordinates on the secp256k1 curve.
-- Derives new public keys for each `(user, path)` combination by computing an integer `epsilon` (based on a `path` string and user’s address) and performing an EC point addition:
-
-  ```
-  DerivedPubKey = BasePubKey + (epsilon × G)
-  ```
-
-- Allows a user to request a signature on a 32-byte payload by calling `sign(...)`. A minimal deposit may be required to discourage spam; any unused deposit is refunded once the request is completed.
-- Awaits the **MPC network** to compute the actual ECDSA signature offline, then call `respond(...)` with that signature. The contract then emits an event with the signature, and refunds the deposit.

package/docs/pages/introduction/signet-quick-start.mdx

@@ -1,88 +0,0 @@
-# Quick Start
-
-## Installation
-
-```bash
-npm install signet.js
-# or
-yarn add signet.js
-# or
-pnpm add signet.js
-```
-
-## Signing a Transaction
-
-Here's a basic example using the EVM implementation:
-
-```ts twoslash
-import { contracts, constants, chainAdapters } from 'signet.js'
-// [!include ~/snippets/code/evm/env.ts]
-
-const evmChainSigContract = new contracts.evm.ChainSignatureContract({
-  publicClient,
-  walletClient,
-  contractAddress: constants.CONTRACT_ADDRESSES.ETHEREUM
-    .TESTNET_DEV as `0x${string}`,
-})
-
-const evm = new chainAdapters.evm.EVM({
-  rpcUrl: 'https://sepolia.infura.io/v3/YOUR-PROJECT-ID',
-  contract: evmChainSigContract,
-})
-
-const path = 'eth'
-const predecessorId = walletClient.account.address
-
-const { address: from, publicKey } = await evm.deriveAddressAndPublicKey(
-  predecessorId,
-  path
-)
-
-const { balance, decimals } = await evm.getBalance(from)
-
-const { transaction, hashesToSign } = await evm.prepareTransactionForSigning({
-  from: from as `0x${string}`,
-  to: '0x4174678c78fEaFd778c1ff319D5D326701449b25',
-  value: 1n, // Amount in wei (1 wei in this example)
-})
-
-const rsvSignature = await evmChainSigContract?.sign({
-  payload: hashesToSign[0],
-  path,
-  key_version: 0, // The version of the key to use (usually 0)
-})
-
-const tx = evm.finalizeTransactionSigning({
-  transaction,
-  rsvSignatures: [rsvSignature],
-})
-
-const txHash = await evm.broadcastTx(tx)
-```
-
-## Supported Chains
-
-- [EVM Chains](/signetjs/chain-adapters/evm) - Ethereum and compatible networks
-- [Bitcoin](/signetjs/chain-adapters/bitcoin) - Bitcoin network
-- [Cosmos Chains](/signetjs/chain-adapters/cosmos) - Cosmos SDK-based networks
-
-## Architecture
-
-The library is built around a core `ChainAdapter` interface that defines common functionality across all supported blockchain networks. Each specific chain implementation extends this interface with network-specific features while maintaining a consistent API.
-
-For more details check the [ChainAdapter](/primitives/chain-adapter-interface.mdx) page.
-
-## Utility Functions
-
-Besides the ChainAdapter classes the library also provide utility functions to assist you on building transactions, requesting signature in wrapped methods.
-
-Currently we support:
-
-- Near
-- EVM
-
-## Repositories
-
-- Signet.js: [https://github.com/sig-net/signet.js](https://github.com/sig-net/signet.js).
-- Examples: [https://github.com/sig-net/signet-examples](https://github.com/sig-net/signet-examples).
-- MPC: [https://github.com/sig-net/mpc](https://github.com/sig-net/mpc).

package/docs/pages/primitives/chain-adapter-interface.mdx

@@ -1,45 +0,0 @@
-# ChainAdapter
-
-ChainAdapter 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
-- serializeTransaction
-- deserializeTransaction
-- prepareTransactionForSigning
-- finalizeTransactionSigning
-- broadcastTx
-
-If you wanna have a look this is the chain interface with a brief description of each method:
-
-```ts twoslash
-// [!include ~/../src/chain-adapters/ChainAdapter.ts]
-```
-
-# Implementing a New ChainAdapter
-
-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 `ChainAdapter` interface:
-
-## Step-by-Step Guide
-
-### 1. Create the ChainAdapter Types
-
-First, define the transaction types for your chain:
-
-```ts twoslash
-// [!include ~/../src/types.ts]
-```
-
-### 2. Implement the ChainAdapter Interface
-
-Create a new class that implements the `ChainAdapter` interface:
-
-```ts twoslash
-// [!include ~/../src/chain-adapters/EVM/EVM.ts]
-```

package/docs/pages/primitives/chain-contract-interface.mdx

@@ -1,52 +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
-- Root Public Key: Gets the root public key of the Smart Contract on Sig Network MPC
-
-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/code/near/env.ts]
-// ---cut---
-import { contracts, chainAdapters } from 'signet.js'
-
-const contract = new contracts.near.ChainSignatureContract({
-  networkId: 'testnet',
-  contractId: 'v1.signer-prod.testnet',
-  accountId,
-  keypair,
-})
-
-const evmChain = new chainAdapters.evm.EVM({
-  rpcUrl: 'https://mainnet.infura.io/v3/YOUR-PROJECT-ID',
-  contract,
-})
-```
-
-## Implementing a Custom Chain Signature Contract
-
-To create your own implementation to use on the [Chain Adapter](/primitives/chain-adapter-interface.mdx) Instance, your contract must implement the `BaseChainSignatureContract` interface.
-
-In case you need you want all Sig Network Smart Contract capabilities, you can implement the `ChainSignatureContract` interface.
-
-```ts twoslash
-// [!include ~/../src/contracts/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/contracts/near/ChainSignatureContract.ts]
-```

package/docs/pages/primitives/contract-addresses.mdx

@@ -1,27 +0,0 @@
-# Contract Addresses
-
-All the necessary constants to interact with the Sig Network are exported from the `constants.ts` file.
-
-## Using the Constants in your code
-
-You can import and use them in your code as follows:
-
-```ts twoslash
-import { constants } from 'signet.js'
-
-const evmTestnetAddress = constants.CONTRACT_ADDRESSES.ETHEREUM.TESTNET
-
-console.log(evmTestnetAddress) // '0x83458E8Bf8206131Fe5c05127007FA164c0948A2'
-
-const testnetPublicKey = constants.ROOT_PUBLIC_KEYS.TESTNET
-
-console.log(testnetPublicKey) // 'secp256k1:3Ww8iFjqTHufye5aRGUvrQqETegR4gVUcW8FX5xzscaN9ENhpkffojsxJwi6N1RbbHMTxYa9UyKeqK3fsMuwxjR5'
-```
-
-## Constants file
-
-For reference, here is the file with the full list of constants and their explanations:
-
-```ts twoslash
-// [!include ~/../src/constants.ts]
-```

package/docs/pages/signetjs/chain-adapters/bitcoin/btc-rpc-adapter.mdx

@@ -1,26 +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 API provider
-- Implementing specialized UTXO selection strategies
-
-## Base Class
-
-In order to implement a custom adapter, you need to implement the `BTCRpcAdapter` abstract class:
-
-```ts twoslash
-// [!include ~/../src/chain-adapters/Bitcoin/BTCRpcAdapter/BTCRpcAdapter.ts]
-```
-
-### 2. Example
-
-There is an example implementation of the `BTCRpcAdapter` abstract class in the `Mempool` class:
-
-```ts twoslash
-// [!include ~/../src/chain-adapters/Bitcoin/BTCRpcAdapter/Mempool/Mempool.ts]
-```

package/docs/pages/signetjs/chain-adapters/bitcoin/finalize-transaction-signing.mdx

@@ -1,47 +0,0 @@
-import './prepare-transaction-for-signing.mdx'
-
-# finalizeTransactionSigning
-
-The `finalizeTransactionSigning` method adds signatures to a Bitcoin PSBT and finalizes it for broadcasting to the network.
-
-## Usage
-
-```ts twoslash
-// [!include ~/snippets/code/chains.ts]
-// ---cut---
-const { transaction, hashesToSign } =
-  await btcChain.prepareTransactionForSigning({
-    from: 'bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh',
-    to: 'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4',
-    value: '0.001', // 0.001 BTC
-    publicKey: '0235a3...',
-  })
-// ---cut---
-import { RSVSignature } from 'signet.js'
-
-const rsvSignatures: RSVSignature[] = [
-  {
-    r: '0x123...',
-    s: '0x123...',
-    v: 27,
-  },
-]
-
-const signedTx = btcChain.finalizeTransactionSigning({
-  transaction,
-  rsvSignatures,
-})
-```
-
-## Parameters
-
-| Parameter       | Type                     | Description                                                |
-| --------------- | ------------------------ | ---------------------------------------------------------- |
-| `transaction`   | `BTCUnsignedTransaction` | The unsigned PSBT returned by prepareTransactionForSigning |
-| `rsvSignatures` | `RSVSignature[]`         | Array of RSV signatures from the MPC network               |
-
-## Returns
-
-| Type     | Description                                                             |
-| -------- | ----------------------------------------------------------------------- |
-| `string` | The serialized signed transaction in hex format, ready for broadcasting |

package/docs/pages/signetjs/chain-adapters/bitcoin/index.mdx

@@ -1,119 +0,0 @@
-# Bitcoin Chain
-
-The Bitcoin chain implementation in Signet.js provides support for both Bitcoin mainnet and testnet networks, with a focus on P2WPKH (Native SegWit) transactions.
-
-## Overview
-
-The Bitcoin implementation allows you to:
-
-- Generate addresses and public keys
-- Check balances
-- Prepare, sign, and broadcast transactions
-- Work with UTXOs (Unspent Transaction Outputs)
-
-## Complete Transaction Example
-
-Below is a complete example of sending a transaction on the Bitcoin network using Signet.js:
-
-```ts twoslash
-import { chainAdapters } from 'signet.js'
-// [!include ~/snippets/code/evm/contract.ts]
-
-const btcRpcAdapter = new chainAdapters.btc.BTCRpcAdapters.Mempool(
-  'https://mempool.space/api'
-)
-
-const bitcoin = new chainAdapters.btc.Bitcoin({
-  network: 'testnet',
-  contract: evmChainSigContract,
-  btcRpcAdapter,
-})
-
-const path = 'btc'
-const predecessorId = walletClient.account.address
-
-const { address: from, publicKey } = await bitcoin.deriveAddressAndPublicKey(
-  predecessorId,
-  path
-)
-
-const { balance, decimals } = await bitcoin.getBalance(from)
-
-const { transaction, hashesToSign } =
-  await bitcoin.prepareTransactionForSigning({
-    from,
-    to: 'tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx',
-    value: '0.001', // 0.001 BTC
-    publicKey,
-  })
-
-const rsvSignature = await evmChainSigContract.sign({
-  payload: hashesToSign[0],
-  path,
-  key_version: 0,
-})
-
-const tx = bitcoin.finalizeTransactionSigning({
-  transaction,
-  rsvSignatures: [rsvSignature],
-})
-
-const txHash = await bitcoin.broadcastTx(tx)
-```
-
-### Supported Networks
-
-You can use different Bitcoin networks by specifying the network parameter:
-
-```ts twoslash
-// [!include ~/snippets/code/contract.ts]
-// ---cut---
-import { chainAdapters } from 'signet.js'
-
-const btcRpcAdapter = new chainAdapters.btc.BTCRpcAdapters.Mempool(
-  'https://mempool.space/api'
-)
-
-// Bitcoin Mainnet
-const mainnetBitcoin = new chainAdapters.btc.Bitcoin({
-  network: 'mainnet',
-  contract: evmChainSigContract,
-  btcRpcAdapter,
-})
-
-// Bitcoin Testnet
-const testnetBitcoin = new chainAdapters.btc.Bitcoin({
-  network: 'testnet',
-  contract: evmChainSigContract,
-  btcRpcAdapter,
-})
-
-// Bitcoin Regtest (for local development)
-const regtestBitcoin = new chainAdapters.btc.Bitcoin({
-  network: 'regtest',
-  contract: evmChainSigContract,
-  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](/signetjs/chain-adapters/bitcoin/btc-rpc-adapter) documentation.
-
-## Types
-
-The following types are used on the Bitcoin chain:
-
-```ts twoslash
-// [!include ~/../src/chain-adapters/Bitcoin/types.ts]
-```

package/docs/pages/signetjs/chain-adapters/bitcoin/prepare-transaction-for-signing.mdx

@@ -1,30 +0,0 @@
-# prepareTransactionForSigning
-
-The `prepareTransactionForSigning` method prepares a Bitcoin transaction for MPC signing by creating a PSBT (Partially Signed Bitcoin Transaction) and computing the hash that needs to be signed.
-
-## Usage
-
-```ts twoslash
-// [!include ~/snippets/code/chains.ts]
-// ---cut---
-const { transaction, hashesToSign } =
-  await btcChain.prepareTransactionForSigning({
-    from: 'bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh',
-    to: 'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4',
-    value: '0.001', // 0.001 BTC
-    publicKey: '0235a3...',
-  })
-```
-
-## Parameters
-
-| Parameter            | Type                    | Description                                                                                          |
-| -------------------- | ----------------------- | ---------------------------------------------------------------------------------------------------- |
-| `transactionRequest` | `BTCTransactionRequest` | The transaction request object containing from, to, value, publicKey, and optional feeRate and utxos |
-
-## Returns
-
-| Property       | Type                     | Description                            |
-| -------------- | ------------------------ | -------------------------------------- |
-| `transaction`  | `BTCUnsignedTransaction` | Object containing the unsigned PSBT    |
-| `hashesToSign` | `string[]`               | Array of hashes that need to be signed |

package/docs/pages/signetjs/chain-adapters/broadcast-tx.mdx

@@ -1,23 +0,0 @@
-# broadcastTx
-
-The `broadcastTx` method broadcasts a signed transaction.
-
-## Usage
-
-```ts twoslash
-// [!include ~/snippets/code/chains.ts]
-// ---cut---
-const txHash = await evmChain.broadcastTx('0x02f8...')
-```
-
-## Parameters
-
-| Parameter      | Type     | Description                       |
-| -------------- | -------- | --------------------------------- |
-| `txSerialized` | `string` | The serialized signed transaction |
-
-## Returns
-
-| Type     | Description          |
-| -------- | -------------------- |
-| `string` | The transaction hash |

package/docs/pages/signetjs/chain-adapters/cosmos/finalize-transaction-signing.mdx

@@ -1,53 +0,0 @@
-# finalizeTransactionSigning
-
-The `finalizeTransactionSigning` method adds signatures to a Cosmos transaction and finalizes it for broadcasting to the network.
-
-## Usage
-
-```ts twoslash
-// [!include ~/snippets/code/chains.ts]
-const { transaction, hashesToSign } =
-  await cosmosChain.prepareTransactionForSigning({
-    address: 'cosmos1...',
-    publicKey: '0350e8...',
-    messages: [
-      {
-        typeUrl: '/cosmos.bank.v1beta1.MsgSend',
-        value: {
-          fromAddress: 'cosmos1...',
-          toAddress: 'cosmos1...',
-          amount: [{ denom: 'uatom', amount: '1000000' }],
-        },
-      },
-    ],
-    memo: 'Token transfer',
-  })
-// ---cut---
-import { RSVSignature } from 'signet.js'
-
-const rsvSignatures: RSVSignature[] = [
-  {
-    r: '0x123...',
-    s: '0x123...',
-    v: 27,
-  },
-]
-
-const signedTx = cosmosChain.finalizeTransactionSigning({
-  transaction,
-  rsvSignatures,
-})
-```
-
-## Parameters
-
-| Parameter       | Type                        | Description                                                       |
-| --------------- | --------------------------- | ----------------------------------------------------------------- |
-| `transaction`   | `CosmosUnsignedTransaction` | The unsigned transaction object from prepareTransactionForSigning |
-| `rsvSignatures` | `RSVSignature[]`            | Array of RSV signatures from the MPC network                      |
-
-## Returns
-
-| Type     | Description                                                             |
-| -------- | ----------------------------------------------------------------------- |
-| `string` | The serialized signed transaction in hex format, ready for broadcasting |