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

package/package.json

@@ -1,28 +1,34 @@
 {
   "name": "signet.js",
-  "version": "0.0.1-beta.7",
+  "version": "0.0.1-beta.9",
   "description": "",
   "type": "module",
   "exports": {
     ".": {
-      "types": "./src/index.d.ts",
-      "import": {
-        "browser": "./index.js",
-        "node": "./index.js"
+      "types": "./types/index.d.ts",
+      "browser": {
+        "import": "./browser/index.browser.js",
+        "require": "./browser/index.browser.cjs"
       },
-      "require": "./index.cjs"
+      "node": {
+        "import": "./node/index.node.js",
+        "require": "./node/index.node.cjs"
+      },
+      "default": "./browser/index.browser.js"
     }
   },
-  "main": "./index.cjs",
-  "module": "./index.js",
-  "browser": "./index.js",
-  "types": "./src/index.d.ts",
+  "main": "./node/index.node.cjs",
+  "module": "./node/index.node.js",
+  "browser": "./browser/index.browser.js",
+  "types": "./types/index.d.ts",
   "scripts": {
-    "build": "rm -rf dist && vite build && cp package.json README.md LICENSE dist/",
     "watch": "vite build --watch",
+    "build": "rm -rf dist && npm run build:browser && npm run build:node && cp package.json README.md LICENSE dist/",
+    "build:browser": "vite build --mode browser",
+    "build:node": "vite build --mode node",
     "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/types/chains/Bitcoin/BTCRpcAdapter/BTCRpcAdapter.d.ts

@@ -0,0 +1,10 @@
+import { BTCTransaction, BTCInput, BTCOutput } from '../types';
+export declare abstract class BTCRpcAdapter {
+    abstract selectUTXOs(from: string, targets: BTCOutput[]): Promise<{
+        inputs: BTCInput[];
+        outputs: BTCOutput[];
+    }>;
+    abstract broadcastTransaction(transactionHex: string): Promise<string>;
+    abstract getBalance(address: string): Promise<number>;
+    abstract getTransaction(txid: string): Promise<BTCTransaction>;
+}

package/types/chains/Bitcoin/BTCRpcAdapter/Mempool/Mempool.d.ts

@@ -0,0 +1,15 @@
+import { BTCRpcAdapter } from '../BTCRpcAdapter';
+import { BTCTransaction, BTCInput, BTCOutput } from '../../types';
+export declare class Mempool extends BTCRpcAdapter {
+    private readonly providerUrl;
+    constructor(providerUrl: string);
+    private fetchFeeRate;
+    private fetchUTXOs;
+    selectUTXOs(from: string, targets: BTCOutput[], confirmationTarget?: number): Promise<{
+        inputs: BTCInput[];
+        outputs: BTCOutput[];
+    }>;
+    broadcastTransaction(transactionHex: string): Promise<string>;
+    getBalance(address: string): Promise<number>;
+    getTransaction(txid: string): Promise<BTCTransaction>;
+}

package/types/chains/Bitcoin/BTCRpcAdapter/Mempool/index.d.ts

@@ -0,0 +1 @@
+export { Mempool } from './Mempool';

package/types/chains/Bitcoin/BTCRpcAdapter/Mempool/types.d.ts

@@ -0,0 +1,69 @@
+export interface BTCFeeRecommendation {
+    fastestFee: number;
+    halfHourFee: number;
+    hourFee: number;
+    economyFee: number;
+    minimumFee: number;
+}
+interface BTCAddressStats {
+    funded_txo_count: number;
+    funded_txo_sum: number;
+    spent_txo_count: number;
+    spent_txo_sum: number;
+    tx_count: number;
+}
+export interface BTCAddressInfo {
+    address: string;
+    chain_stats: BTCAddressStats;
+    mempool_stats: BTCAddressStats;
+}
+export interface Transaction {
+    txid: string;
+    version: number;
+    locktime: number;
+    vin: Array<{
+        txid: string;
+        vout: number;
+        prevout: {
+            scriptpubkey: string;
+            scriptpubkey_asm: string;
+            scriptpubkey_type: string;
+            scriptpubkey_address: string;
+            value: number;
+        };
+        scriptsig: string;
+        scriptsig_asm: string;
+        witness: string[];
+        is_coinbase: boolean;
+        sequence: number;
+    }>;
+    vout: Array<{
+        scriptpubkey: string;
+        scriptpubkey_asm: string;
+        scriptpubkey_type: string;
+        scriptpubkey_address: string;
+        value: number;
+    }>;
+    size: number;
+    weight: number;
+    sigops?: number;
+    fee: number;
+    status: {
+        confirmed: boolean;
+        block_height: number;
+        block_hash: string;
+        block_time: number;
+    };
+}
+export interface UTXO {
+    txid: string;
+    vout: number;
+    status: {
+        confirmed: boolean;
+        block_height: number;
+        block_hash: string;
+        block_time: number;
+    };
+    value: number;
+}
+export {};

package/types/chains/Bitcoin/BTCRpcAdapter/index.d.ts

@@ -0,0 +1,5 @@
+import { Mempool } from './Mempool';
+export { BTCRpcAdapter } from './BTCRpcAdapter';
+export declare const BTCRpcAdapters: {
+    Mempool: typeof Mempool;
+};

package/types/chains/Bitcoin/Bitcoin.d.ts

@@ -0,0 +1,42 @@
+import { BTCRpcAdapter } from './BTCRpcAdapter';
+import { BTCNetworkIds, BTCTransactionRequest, BTCUnsignedTransaction } from './types';
+import { Chain } from '../Chain';
+import { BaseChainSignatureContract } from '../ChainSignatureContract';
+import { MPCPayloads, RSVSignature, KeyDerivationPath } from '../types';
+import * as bitcoin from 'bitcoinjs-lib';
+export declare class Bitcoin extends Chain<BTCTransactionRequest, BTCUnsignedTransaction> {
+    private static readonly SATOSHIS_PER_BTC;
+    private readonly network;
+    private readonly btcRpcAdapter;
+    private readonly contract;
+    constructor({ network, contract, btcRpcAdapter, }: {
+        network: BTCNetworkIds;
+        contract: BaseChainSignatureContract;
+        btcRpcAdapter: BTCRpcAdapter;
+    });
+    static toBTC(satoshis: number): number;
+    static toSatoshi(btc: number): number;
+    private fetchTransaction;
+    private static parseRSVSignature;
+    createPSBT({ transactionRequest, }: {
+        transactionRequest: BTCTransactionRequest;
+    }): Promise<bitcoin.Psbt>;
+    getBalance(address: string): Promise<string>;
+    deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath): Promise<{
+        address: string;
+        publicKey: string;
+    }>;
+    setTransaction(transaction: BTCUnsignedTransaction, storageKey: string): void;
+    getTransaction(storageKey: string, options?: {
+        remove?: boolean;
+    }): BTCUnsignedTransaction | undefined;
+    getMPCPayloadAndTransaction(transactionRequest: BTCTransactionRequest): Promise<{
+        transaction: BTCUnsignedTransaction;
+        mpcPayloads: MPCPayloads;
+    }>;
+    addSignature({ transaction: { psbt, publicKey }, mpcSignatures, }: {
+        transaction: BTCUnsignedTransaction;
+        mpcSignatures: RSVSignature[];
+    }): string;
+    broadcastTx(txSerialized: string): Promise<string>;
+}

package/types/chains/Bitcoin/types.d.ts

@@ -0,0 +1,42 @@
+import type * as bitcoin from 'bitcoinjs-lib';
+export interface BTCTransaction {
+    vout: Array<{
+        scriptpubkey: string;
+        value: number;
+    }>;
+}
+export interface BTCInput {
+    txid: string;
+    vout: number;
+    value: number;
+    scriptPubKey: Buffer;
+}
+export type BTCOutput = {
+    value: number;
+} & ({
+    address: string;
+    script?: never;
+} | {
+    address?: never;
+    script: Buffer;
+});
+export type BTCTransactionRequest = {
+    publicKey: string;
+} & ({
+    inputs: BTCInput[];
+    outputs: BTCOutput[];
+    from?: never;
+    to?: never;
+    value?: never;
+} | {
+    inputs?: never;
+    outputs?: never;
+    from: string;
+    to: string;
+    value: string;
+});
+export interface BTCUnsignedTransaction {
+    psbt: bitcoin.Psbt;
+    publicKey: string;
+}
+export type BTCNetworkIds = 'mainnet' | 'testnet' | 'regtest';

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

@@ -0,0 +1,2 @@
+import * as bitcoin from 'bitcoinjs-lib';
+export declare function parseBTCNetwork(network: string): bitcoin.networks.Network;

package/types/chains/Chain.d.ts

@@ -0,0 +1,21 @@
+import { KeyDerivationPath, MPCPayloads, RSVSignature } from './types';
+export declare abstract class Chain<TransactionRequest, UnsignedTransaction> {
+    abstract getBalance(address: string): Promise<string>;
+    abstract deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath): Promise<{
+        address: string;
+        publicKey: string;
+    }>;
+    abstract setTransaction(transaction: UnsignedTransaction, storageKey: string): void;
+    abstract getTransaction(storageKey: string, options?: {
+        remove?: boolean;
+    }): UnsignedTransaction | undefined;
+    abstract getMPCPayloadAndTransaction(transactionRequest: TransactionRequest): Promise<{
+        transaction: UnsignedTransaction;
+        mpcPayloads: MPCPayloads;
+    }>;
+    abstract addSignature(params: {
+        transaction: UnsignedTransaction;
+        mpcSignatures: RSVSignature[];
+    }): string;
+    abstract broadcastTx(txSerialized: string): Promise<string>;
+}

package/types/chains/ChainSignatureContract.d.ts

@@ -0,0 +1,18 @@
+import { default as BN } from 'bn.js';
+import { RSVSignature, UncompressedPubKeySEC1 } from './types';
+export interface SignArgs {
+    payload: number[];
+    path: string;
+    key_version: number;
+}
+export declare abstract class BaseChainSignatureContract {
+    abstract getCurrentSignatureDeposit(): Promise<BN>;
+    abstract getDerivedPublicKey(args: {
+        path: string;
+        predecessor: string;
+    } & Record<string, unknown>): Promise<UncompressedPubKeySEC1>;
+}
+export declare abstract class ChainSignatureContract extends BaseChainSignatureContract {
+    abstract sign(args: SignArgs & Record<string, unknown>): Promise<RSVSignature>;
+    abstract getPublicKey(): Promise<UncompressedPubKeySEC1>;
+}

package/types/chains/Cosmos/Cosmos.d.ts

@@ -0,0 +1,38 @@
+import { Chain } from '../Chain';
+import { BaseChainSignatureContract } from '../ChainSignatureContract';
+import { CosmosNetworkIds, CosmosTransactionRequest, CosmosUnsignedTransaction } from './types';
+import { MPCPayloads, RSVSignature, KeyDerivationPath } from '../types';
+export declare class Cosmos extends Chain<CosmosTransactionRequest, CosmosUnsignedTransaction> {
+    private readonly registry;
+    private readonly chainId;
+    private readonly contract;
+    private readonly endpoints?;
+    constructor({ chainId, contract, endpoints, }: {
+        contract: BaseChainSignatureContract;
+        chainId: CosmosNetworkIds;
+        endpoints?: {
+            rpcUrl?: string;
+            restUrl?: string;
+        };
+    });
+    private parseRSVSignature;
+    private getChainInfo;
+    getBalance(address: string): Promise<string>;
+    deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath): Promise<{
+        address: string;
+        publicKey: string;
+    }>;
+    setTransaction(transaction: CosmosUnsignedTransaction, storageKey: string): void;
+    getTransaction(storageKey: string, options?: {
+        remove?: boolean;
+    }): CosmosUnsignedTransaction | undefined;
+    getMPCPayloadAndTransaction(transactionRequest: CosmosTransactionRequest): Promise<{
+        transaction: CosmosUnsignedTransaction;
+        mpcPayloads: MPCPayloads;
+    }>;
+    addSignature({ transaction, mpcSignatures, }: {
+        transaction: CosmosUnsignedTransaction;
+        mpcSignatures: RSVSignature[];
+    }): string;
+    broadcastTx(txSerialized: string): Promise<string>;
+}

package/types/chains/Cosmos/types.d.ts

@@ -0,0 +1,30 @@
+import { EncodeObject } from '@cosmjs/proto-signing';
+import { TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx';
+export type CosmosNetworkIds = string;
+export type CosmosUnsignedTransaction = TxRaw;
+export interface CosmosTransactionRequest {
+    address: string;
+    publicKey: string;
+    messages: EncodeObject[];
+    memo?: string;
+    gas?: number;
+}
+export interface BalanceResponse {
+    balances: Array<{
+        denom: string;
+        amount: string;
+    }>;
+    pagination: {
+        next_key: string | null;
+        total: string;
+    };
+}
+export interface ChainInfo {
+    prefix: string;
+    denom: string;
+    rpcUrl: string;
+    restUrl: string;
+    expectedChainId: string;
+    gasPrice: number;
+    decimals: number;
+}

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

@@ -0,0 +1,2 @@
+import { ChainInfo } from './types';
+export declare const fetchChainInfo: (chainId: string) => Promise<ChainInfo>;

package/types/chains/EVM/EVM.d.ts

@@ -0,0 +1,32 @@
+import { Chain } from '../Chain';
+import { BaseChainSignatureContract } from '../ChainSignatureContract';
+import { EVMTransactionRequest, EVMUnsignedTransaction } from './types';
+import { MPCPayloads, RSVSignature, KeyDerivationPath } from '../types';
+export declare class EVM extends Chain<EVMTransactionRequest, EVMUnsignedTransaction> {
+    private readonly provider;
+    private readonly contract;
+    constructor({ rpcUrl, contract, }: {
+        rpcUrl: string;
+        contract: BaseChainSignatureContract;
+    });
+    private attachGasAndNonce;
+    private parseSignature;
+    deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath): Promise<{
+        address: string;
+        publicKey: string;
+    }>;
+    getBalance(address: string): Promise<string>;
+    setTransaction(transaction: EVMUnsignedTransaction, storageKey: string): void;
+    getTransaction(storageKey: string, options?: {
+        remove?: boolean;
+    }): EVMUnsignedTransaction | undefined;
+    getMPCPayloadAndTransaction(transactionRequest: EVMTransactionRequest): Promise<{
+        transaction: EVMUnsignedTransaction;
+        mpcPayloads: MPCPayloads;
+    }>;
+    addSignature({ transaction, mpcSignatures, }: {
+        transaction: EVMUnsignedTransaction;
+        mpcSignatures: RSVSignature[];
+    }): string;
+    broadcastTx(txSerialized: string): Promise<string>;
+}

package/types/chains/EVM/types.d.ts

@@ -0,0 +1,5 @@
+import type * as ethers from 'ethers';
+export type EVMUnsignedTransaction = ethers.TransactionLike;
+export type EVMTransactionRequest = Omit<ethers.TransactionLike, 'from'> & {
+    from: string;
+};

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

@@ -0,0 +1,7 @@
+import { ethers } from 'ethers';
+export declare function fetchEVMFeeProperties(providerUrl: string, transaction: ethers.TransactionLike): Promise<{
+    gasLimit: bigint;
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+    maxFee: bigint;
+}>;

package/types/chains/index.d.ts

@@ -0,0 +1,11 @@
+export { Chain } from './Chain';
+export { ChainSignatureContract, type SignArgs } from './ChainSignatureContract';
+export * from './types';
+export { EVM } from './EVM/EVM';
+export { fetchEVMFeeProperties } from './EVM/utils';
+export type { EVMTransactionRequest, EVMUnsignedTransaction } from './EVM/types';
+export { Bitcoin } from './Bitcoin/Bitcoin';
+export { BTCRpcAdapters, BTCRpcAdapter } from './Bitcoin/BTCRpcAdapter';
+export type { BTCTransactionRequest, BTCUnsignedTransaction, BTCTransaction, BTCOutput, BTCInput, BTCNetworkIds, } from './Bitcoin/types';
+export { Cosmos } from './Cosmos/Cosmos';
+export type { CosmosNetworkIds, CosmosTransactionRequest, CosmosUnsignedTransaction, } from './Cosmos/types';

package/types/chains/types.d.ts

@@ -0,0 +1,18 @@
+import { SignArgs } from './ChainSignatureContract';
+export type MPCPayloads = Array<SignArgs['payload']>;
+export type UncompressedPubKeySEC1 = `04${string}`;
+export type KeyDerivationPath = string;
+export interface RSVSignature {
+    r: string;
+    s: string;
+    v: number;
+}
+export interface MPCSignature {
+    big_r: {
+        affine_point: string;
+    };
+    s: {
+        scalar: string;
+    };
+    recovery_id: number;
+}

package/types/index.d.ts

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

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

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

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

@@ -0,0 +1,35 @@
+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;
+}
+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>;
+    getPublicKey(): 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/types/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/types/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/types/utils/chains/near/index.d.ts

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

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

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

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

@@ -0,0 +1,3 @@
+import { SignedDelegate } from '@near-js/transactions';
+import { SignedDelegateRelayerFormat } from './types';
+export declare function parseSignedDelegateForRelayer(signedDelegate: SignedDelegate): SignedDelegateRelayerFormat;

package/types/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/types/utils/chains/near/signAndSend/index.d.ts

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

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

@@ -0,0 +1,5 @@
+import { KeyPair } from '@near-js/crypto';
+import { Response, 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/types/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/types/utils/chains/near/types.d.ts

@@ -0,0 +1,54 @@
+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';
+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;
+}
+interface SuccessResponse {
+    transactionHash: string;
+    success: true;
+}
+interface FailureResponse {
+    success: false;
+    errorMessage: string;
+}
+export type Response = SuccessResponse | FailureResponse;
+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;
+}
+export {};

package/types/utils/cryptography.d.ts

@@ -0,0 +1,3 @@
+import { MPCSignature, RSVSignature, UncompressedPubKeySEC1 } from '../chains/types';
+export declare const toRSV: (signature: MPCSignature) => RSVSignature;
+export declare const compressPubKey: (uncompressedPubKeySEC1: UncompressedPubKeySEC1) => string;

package/types/utils/index.d.ts

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