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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signet.js",
-  "version": "0.0.1-beta.7",
+  "version": "0.0.1-beta.8",
   "description": "",
   "type": "module",
   "exports": {
@@ -22,7 +22,7 @@
     "watch": "vite build --watch",
     "pre:deploy": "npm run build && npm run docs:build",
     "publish-npm": "npm run pre:deploy && npm publish",
-    "publish-npm:beta": "npm run pre:deploy && npm publish --tag beta",
+    "publish-npm:beta": "npm run pre:deploy && cd dist && npm publish --tag beta",
     "test": "jest",
     "docs:dev": "vocs dev",
     "docs:build": "vocs build",

package/utils/chains/index.d.ts

@@ -0,0 +1 @@
+export * as near from './near';

package/utils/chains/near/ChainSignatureContract.d.ts

@@ -0,0 +1,38 @@
+import { Account } from '@near-js/accounts';
+import { KeyPair } from '@near-js/crypto';
+import { default as BN } from 'bn.js';
+import { ChainSignatureContract as AbstractChainSignatureContract, SignArgs } from '../../../chains/ChainSignatureContract';
+import { RSVSignature, UncompressedPubKeySEC1 } from '../../../chains/types';
+import { NearNetworkIds, ChainSignatureContractIds } from './types';
+interface ChainSignatureContractArgs {
+    networkId: NearNetworkIds;
+    contractId: ChainSignatureContractIds;
+    accountId?: string;
+    keypair?: KeyPair;
+}
+/**
+ * This contract will default to view methods only.
+ * If you want to use the change methods, you need to provide an account and keypair.
+ */
+export declare class ChainSignatureContract extends AbstractChainSignatureContract {
+    private readonly networkId;
+    private readonly contractId;
+    private readonly accountId;
+    private readonly keypair;
+    constructor({ networkId, contractId, accountId, keypair, }: ChainSignatureContractArgs);
+    private getContract;
+    getCurrentSignatureDeposit(): Promise<BN>;
+    getDerivedPublicKey(args: {
+        path: string;
+        predecessor: string;
+    }): Promise<UncompressedPubKeySEC1>;
+    sign(args: SignArgs): Promise<RSVSignature>;
+    static signWithRelayer({ account, contract, signArgs, deposit, relayerUrl, }: {
+        account: Account;
+        contract: ChainSignatureContractIds;
+        signArgs: SignArgs;
+        deposit: BN;
+        relayerUrl: string;
+    }): Promise<RSVSignature>;
+}
+export {};

package/utils/chains/near/account.d.ts

@@ -0,0 +1,13 @@
+import { Account } from '@near-js/accounts';
+import { KeyPair } from '@near-js/crypto';
+type SetConnectionArgs = {
+    networkId: string;
+    accountId: string;
+    keypair: KeyPair;
+} | {
+    networkId: string;
+    accountId?: never;
+    keypair?: never;
+};
+export declare const getNearAccount: ({ networkId, accountId, keypair, }: SetConnectionArgs) => Promise<Account>;
+export {};

package/utils/chains/near/constants.d.ts

@@ -0,0 +1,3 @@
+import { default as BN } from 'bn.js';
+export declare const NEAR_MAX_GAS: BN;
+export declare const DONT_CARE_ACCOUNT_ID = "dontcare";

package/utils/chains/near/index.d.ts

@@ -0,0 +1,3 @@
+export * as transactionBuilder from './transactionBuilder';
+export * as signAndSend from './signAndSend';
+export * from './ChainSignatureContract';

package/utils/chains/near/relayer/index.d.ts

@@ -0,0 +1 @@
+export * from './relayer';

package/utils/chains/near/relayer/relayer.d.ts

@@ -0,0 +1,8 @@
+import { SignedDelegate } from '@near-js/transactions';
+import { SignedDelegateRelayerFormat } from './types';
+/**
+ * Parses the signedDelegate object from the Multi-Party Computation (MPC) format to the Relayer format.
+ * @param signedDelegate - The signedDelegate object in MPC format.
+ * @returns The signedDelegate object in Relayer format.
+ */
+export declare function parseSignedDelegateForRelayer(signedDelegate: SignedDelegate): SignedDelegateRelayerFormat;

package/utils/chains/near/relayer/types.d.ts

@@ -0,0 +1,22 @@
+interface FunctionCallRelayer {
+    FunctionCall: {
+        method_name: string;
+        args: string;
+        gas: number;
+        deposit: string;
+    };
+}
+type ActionsRelayer = FunctionCallRelayer;
+interface DelegateActionRelayerFormat {
+    actions: ActionsRelayer[];
+    nonce: number;
+    max_block_height: number;
+    public_key: string;
+    receiver_id: string;
+    sender_id: string;
+}
+export interface SignedDelegateRelayerFormat {
+    delegate_action: DelegateActionRelayerFormat;
+    signature: string;
+}
+export {};

package/utils/chains/near/signAndSend/index.d.ts

@@ -0,0 +1 @@
+export * as keypair from './keypair';

package/utils/chains/near/signAndSend/keypair.d.ts

@@ -0,0 +1,6 @@
+import { KeyPair } from '@near-js/crypto';
+import { Response } from '../../../../chains/types';
+import { BitcoinRequest, CosmosRequest, EVMRequest } from '../types';
+export declare const EVMTransaction: (req: EVMRequest, keyPair: KeyPair) => Promise<Response>;
+export declare const BTCTransaction: (req: BitcoinRequest, keyPair: KeyPair) => Promise<Response>;
+export declare const CosmosTransaction: (req: CosmosRequest, keyPair: KeyPair) => Promise<Response>;

package/utils/chains/near/transactionBuilder.d.ts

@@ -0,0 +1,26 @@
+import { Action, FinalExecutionOutcome, NetworkId } from '@near-wallet-selector/core';
+import { RSVSignature, KeyDerivationPath, MPCPayloads } from '../../../chains/types';
+import { NFTKeysContracts, ChainSignatureContractIds } from './types';
+export declare const mpcPayloadsToChainSigTransaction: ({ networkId, contractId, mpcPayloads, path, }: {
+    networkId: NetworkId;
+    contractId: ChainSignatureContractIds;
+    mpcPayloads: MPCPayloads;
+    path: KeyDerivationPath;
+}) => Promise<{
+    receiverId: string;
+    actions: Action[];
+}>;
+export declare const mpcPayloadsToNFTKeysTransaction: ({ networkId, chainSigContract, nftKeysContract, mpcPayloads, path, tokenId, }: {
+    networkId: NetworkId;
+    chainSigContract: ChainSignatureContractIds;
+    nftKeysContract: NFTKeysContracts;
+    mpcPayloads: MPCPayloads;
+    path: KeyDerivationPath;
+    tokenId: string;
+}) => Promise<{
+    receiverId: string;
+    actions: Action[];
+}>;
+export declare const responseToMpcSignature: ({ response, }: {
+    response: FinalExecutionOutcome;
+}) => RSVSignature | undefined;

package/utils/chains/near/types.d.ts

@@ -0,0 +1,50 @@
+import { BTCTransactionRequest, BTCNetworkIds } from '../../../chains/Bitcoin/types';
+import { CosmosNetworkIds, CosmosTransactionRequest } from '../../../chains/Cosmos/types';
+import { EVMTransactionRequest } from '../../../chains/EVM/types';
+import { KeyDerivationPath } from '../../../chains/types';
+/**
+Available ChainSignature contracts:
+  - Mainnet: v1.signer
+  - Testnet: v1.signer-prod.testnet
+  - Development (unstable): v1.signer-dev.testnet
+*/
+export type ChainSignatureContractIds = string;
+export type NFTKeysContracts = string;
+export type NearNetworkIds = 'mainnet' | 'testnet';
+export interface ChainProvider {
+    providerUrl: string;
+    contract: ChainSignatureContractIds;
+}
+export interface NearAuthentication {
+    networkId: NearNetworkIds;
+    accountId: string;
+}
+export type EVMChainConfigWithProviders = ChainProvider;
+export interface EVMRequest {
+    transaction: EVMTransactionRequest;
+    chainConfig: EVMChainConfigWithProviders;
+    nearAuthentication: NearAuthentication;
+    fastAuthRelayerUrl?: string;
+    derivationPath: KeyDerivationPath;
+}
+export type BTCChainConfigWithProviders = ChainProvider & {
+    network: BTCNetworkIds;
+};
+export interface BitcoinRequest {
+    transaction: BTCTransactionRequest;
+    chainConfig: BTCChainConfigWithProviders;
+    nearAuthentication: NearAuthentication;
+    fastAuthRelayerUrl?: string;
+    derivationPath: KeyDerivationPath;
+}
+export interface CosmosChainConfig {
+    contract: ChainSignatureContractIds;
+    chainId: CosmosNetworkIds;
+}
+export interface CosmosRequest {
+    chainConfig: CosmosChainConfig;
+    transaction: CosmosTransactionRequest;
+    nearAuthentication: NearAuthentication;
+    derivationPath: KeyDerivationPath;
+    fastAuthRelayerUrl?: string;
+}

package/utils/index.d.ts

@@ -0,0 +1 @@
+export * as chains from './chains';

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