signet.js 0.0.1-beta.1 → 0.0.1-beta.11

package/src/chains/Cosmos/Cosmos.js

@@ -1,156 +0,0 @@
-import { encodeSecp256k1Pubkey } from '@cosmjs/amino';
-import { ripemd160, sha256 } from '@cosmjs/crypto';
-import { toBase64, fromBase64, fromHex } from '@cosmjs/encoding';
-import { Registry, makeSignBytes, encodePubkey, makeAuthInfoBytes, makeSignDoc, } from '@cosmjs/proto-signing';
-import { GasPrice, StargateClient, calculateFee } from '@cosmjs/stargate';
-import { bech32 } from 'bech32';
-import { SignMode } from 'cosmjs-types/cosmos/tx/signing/v1beta1/signing';
-import { TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx';
-import { Chain, utils } from '@chains';
-import { fetchChainInfo } from '@chains/Cosmos/utils';
-/**
- * Implementation of the Chain interface for Cosmos-based networks.
- * Handles interactions with Cosmos SDK chains like Cosmos Hub, Osmosis, etc.
- */
-export class Cosmos extends Chain {
-    /**
-     * Creates a new Cosmos chain instance
-     * @param params - Configuration parameters
-     * @param params.chainId - Chain id for the Cosmos network
-     * @param params.contract - Instance of the chain signature contract for MPC operations
-     * @param params.endpoints - Optional RPC and REST endpoints
-     * @param params.endpoints.rpcUrl - Optional RPC endpoint URL
-     * @param params.endpoints.restUrl - Optional REST endpoint URL
-     */
-    constructor({ chainId, contract, endpoints, }) {
-        super();
-        this.contract = contract;
-        this.registry = new Registry();
-        this.chainId = chainId;
-        this.endpoints = endpoints;
-    }
-    parseRSVSignature(rsvSignature) {
-        return new Uint8Array([
-            ...fromHex(rsvSignature.r),
-            ...fromHex(rsvSignature.s),
-        ]);
-    }
-    async getChainInfo() {
-        return {
-            ...(await fetchChainInfo(this.chainId)),
-            ...this.endpoints,
-        };
-    }
-    async getBalance(address) {
-        try {
-            const { restUrl, denom, decimals } = await this.getChainInfo();
-            const response = await fetch(`${restUrl}/cosmos/bank/v1beta1/balances/${address}`);
-            if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status}`);
-            }
-            const data = (await response.json());
-            const balance = data.balances.find((b) => b.denom === denom);
-            const amount = balance?.amount ?? '0';
-            const formattedBalance = (parseInt(amount) / Math.pow(10, decimals)).toString();
-            return formattedBalance;
-        }
-        catch (error) {
-            console.error('Failed to fetch Cosmos balance:', error);
-            throw new Error('Failed to fetch Cosmos balance');
-        }
-    }
-    async deriveAddressAndPublicKey(predecessor, path) {
-        const { prefix } = await this.getChainInfo();
-        const uncompressedPubKey = await this.contract.getDerivedPublicKey({
-            path,
-            predecessor,
-        });
-        if (!uncompressedPubKey) {
-            throw new Error('Failed to get derived public key');
-        }
-        const derivedKey = utils.compressPubKey(uncompressedPubKey);
-        const pubKeySha256 = sha256(fromHex(derivedKey));
-        const ripemd160Hash = ripemd160(pubKeySha256);
-        const address = bech32.encode(prefix, bech32.toWords(ripemd160Hash));
-        return { address, publicKey: derivedKey };
-    }
-    setTransaction(transaction, storageKey) {
-        const serialized = TxRaw.encode(transaction).finish();
-        window.localStorage.setItem(storageKey, toBase64(serialized));
-    }
-    getTransaction(storageKey, options) {
-        const serialized = window.localStorage.getItem(storageKey);
-        if (!serialized)
-            return undefined;
-        if (options?.remove) {
-            window.localStorage.removeItem(storageKey);
-        }
-        return TxRaw.decode(fromBase64(serialized));
-    }
-    async getMPCPayloadAndTransaction(transactionRequest) {
-        const { denom, rpcUrl, gasPrice } = await this.getChainInfo();
-        const publicKeyBytes = fromHex(transactionRequest.publicKey);
-        const gasLimit = transactionRequest.gas || 200000;
-        const fee = calculateFee(gasLimit, GasPrice.fromString(`${gasPrice}${denom}`));
-        const client = await StargateClient.connect(rpcUrl);
-        const accountOnChain = await client.getAccount(transactionRequest.address);
-        if (!accountOnChain) {
-            throw new Error(`Account ${transactionRequest.address} does not exist on chain`);
-        }
-        const { accountNumber, sequence } = accountOnChain;
-        const txBodyEncodeObject = {
-            typeUrl: '/cosmos.tx.v1beta1.TxBody',
-            value: {
-                messages: transactionRequest.messages,
-                memo: transactionRequest.memo || '',
-            },
-        };
-        const txBodyBytes = this.registry.encode(txBodyEncodeObject);
-        const pubkey = encodePubkey(encodeSecp256k1Pubkey(publicKeyBytes));
-        // TODO: Allow caller to provide: multiple signers, fee payer, fee granter
-        const authInfoBytes = makeAuthInfoBytes([
-            {
-                pubkey,
-                sequence,
-            },
-        ], fee.amount, Number(fee.gas), undefined, undefined, SignMode.SIGN_MODE_DIRECT);
-        const signDoc = makeSignDoc(txBodyBytes, authInfoBytes, this.chainId, accountNumber);
-        const signBytes = makeSignBytes(signDoc);
-        const payload = Array.from(sha256(signBytes));
-        return {
-            transaction: TxRaw.fromPartial({
-                bodyBytes: txBodyBytes,
-                authInfoBytes,
-                signatures: [],
-            }),
-            mpcPayloads: [
-                {
-                    index: 0,
-                    payload,
-                },
-            ],
-        };
-    }
-    addSignature({ transaction, mpcSignatures, }) {
-        // Allow support for multi-sig but the package only supports single-sig
-        transaction.signatures = mpcSignatures.map((sig) => this.parseRSVSignature(sig));
-        const txBytes = TxRaw.encode(transaction).finish();
-        return Buffer.from(txBytes).toString('hex');
-    }
-    async broadcastTx(txSerialized) {
-        try {
-            const { rpcUrl } = await this.getChainInfo();
-            const client = await StargateClient.connect(rpcUrl);
-            const txBytes = fromHex(txSerialized);
-            const broadcastResponse = await client.broadcastTx(txBytes);
-            if (broadcastResponse.code !== 0) {
-                throw new Error(`Broadcast error: ${broadcastResponse.rawLog}`);
-            }
-            return broadcastResponse.transactionHash;
-        }
-        catch (error) {
-            console.error('Transaction broadcast failed:', error);
-            throw new Error('Failed to broadcast transaction.');
-        }
-    }
-}

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

@@ -1,30 +0,0 @@
-import { type EncodeObject } from '@cosmjs/proto-signing';
-import { type 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/src/chains/Cosmos/types.js

@@ -1 +0,0 @@
-export {};

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

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

package/src/chains/Cosmos/utils.js

@@ -1,27 +0,0 @@
-import { chains, assets } from 'chain-registry';
-export const fetchChainInfo = async (chainId) => {
-    const chainInfo = chains.find((chain) => chain.chain_id === chainId);
-    if (!chainInfo) {
-        throw new Error(`Chain info not found for chainId: ${chainId}`);
-    }
-    const { bech32_prefix: prefix, chain_id: expectedChainId } = chainInfo;
-    const denom = chainInfo.staking?.staking_tokens?.[0]?.denom;
-    const rpcUrl = chainInfo.apis?.rpc?.[0]?.address;
-    const restUrl = chainInfo.apis?.rest?.[0]?.address;
-    const gasPrice = chainInfo.fees?.fee_tokens?.[0]?.average_gas_price;
-    if (!prefix ||
-        !denom ||
-        !rpcUrl ||
-        !restUrl ||
-        !expectedChainId ||
-        gasPrice === undefined) {
-        throw new Error(`Missing required chain information for ${chainInfo.chain_name}`);
-    }
-    const assetList = assets.find((asset) => asset.chain_name === chainInfo.chain_name);
-    const asset = assetList?.assets.find((asset) => asset.base === denom);
-    const decimals = asset?.denom_units.find((unit) => unit.denom === asset.display)?.exponent;
-    if (decimals === undefined) {
-        throw new Error(`Could not find decimals for ${denom} on chain ${chainInfo.chain_name}`);
-    }
-    return { prefix, denom, rpcUrl, restUrl, expectedChainId, gasPrice, decimals };
-};

package/src/chains/EVM/EVM.d.ts

@@ -1,40 +0,0 @@
-import { type MPCPayloads, type RSVSignature, type KeyDerivationPath, type EVMTransactionRequest, type EVMUnsignedTransaction, type ChainSignatureContract } from '@chains';
-import { Chain } from '@chains';
-/**
- * Implementation of the Chain interface for EVM-compatible networks.
- * Handles interactions with Ethereum Virtual Machine based blockchains like Ethereum, BSC, Polygon, etc.
- */
-export declare class EVM extends Chain<EVMTransactionRequest, EVMUnsignedTransaction> {
-    private readonly provider;
-    private readonly contract;
-    /**
-     * Creates a new EVM chain instance
-     * @param params - Configuration parameters
-     * @param params.rpcUrl - URL of the EVM JSON-RPC provider (e.g., Infura endpoint)
-     * @param params.contract - Instance of the chain signature contract for MPC operations
-     */
-    constructor({ rpcUrl, contract, }: {
-        rpcUrl: string;
-        contract: ChainSignatureContract;
-    });
-    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/src/chains/EVM/EVM.js

@@ -1,108 +0,0 @@
-import { fromHex } from '@cosmjs/encoding';
-import { ethers, keccak256 } from 'ethers';
-import { Chain, fetchEVMFeeProperties } from '@chains';
-/**
- * Implementation of the Chain interface for EVM-compatible networks.
- * Handles interactions with Ethereum Virtual Machine based blockchains like Ethereum, BSC, Polygon, etc.
- */
-export class EVM extends Chain {
-    /**
-     * Creates a new EVM chain instance
-     * @param params - Configuration parameters
-     * @param params.rpcUrl - URL of the EVM JSON-RPC provider (e.g., Infura endpoint)
-     * @param params.contract - Instance of the chain signature contract for MPC operations
-     */
-    constructor({ rpcUrl, contract, }) {
-        super();
-        this.contract = contract;
-        this.provider = new ethers.JsonRpcProvider(rpcUrl);
-    }
-    async attachGasAndNonce(transaction) {
-        const fees = await fetchEVMFeeProperties(this.provider._getConnection().url, transaction);
-        const nonce = await this.provider.getTransactionCount(transaction.from, 'latest');
-        const { from, ...rest } = transaction;
-        return {
-            ...fees,
-            chainId: this.provider._network.chainId,
-            nonce,
-            type: 2,
-            ...rest,
-        };
-    }
-    parseSignature(signature) {
-        return ethers.Signature.from({
-            r: `0x${signature.r}`,
-            s: `0x${signature.s}`,
-            v: signature.v,
-        });
-    }
-    async deriveAddressAndPublicKey(predecessor, path) {
-        const uncompressedPubKey = await this.contract.getDerivedPublicKey({
-            path,
-            predecessor,
-        });
-        if (!uncompressedPubKey) {
-            throw new Error('Failed to get derived public key');
-        }
-        const publicKeyNoPrefix = uncompressedPubKey.startsWith('04')
-            ? uncompressedPubKey.substring(2)
-            : uncompressedPubKey;
-        const hash = ethers.keccak256(fromHex(publicKeyNoPrefix));
-        return {
-            address: `0x${hash.substring(hash.length - 40)}`,
-            publicKey: uncompressedPubKey,
-        };
-    }
-    async getBalance(address) {
-        try {
-            const balance = await this.provider.getBalance(address);
-            return ethers.formatEther(balance);
-        }
-        catch (error) {
-            console.error(`Failed to fetch balance for address ${address}:`, error);
-            throw new Error('Failed to fetch balance.');
-        }
-    }
-    setTransaction(transaction, storageKey) {
-        const serializedTransaction = JSON.stringify(transaction, (_, value) => typeof value === 'bigint' ? value.toString() : value);
-        window.localStorage.setItem(storageKey, serializedTransaction);
-    }
-    getTransaction(storageKey, options) {
-        const txSerialized = window.localStorage.getItem(storageKey);
-        if (options?.remove) {
-            window.localStorage.removeItem(storageKey);
-        }
-        return txSerialized ? JSON.parse(txSerialized) : undefined;
-    }
-    async getMPCPayloadAndTransaction(transactionRequest) {
-        const transaction = await this.attachGasAndNonce(transactionRequest);
-        const txSerialized = ethers.Transaction.from(transaction).unsignedSerialized;
-        const transactionHash = keccak256(txSerialized);
-        const txHash = Array.from(ethers.getBytes(transactionHash));
-        return {
-            transaction,
-            mpcPayloads: [
-                {
-                    index: 0,
-                    payload: txHash,
-                },
-            ],
-        };
-    }
-    addSignature({ transaction, mpcSignatures, }) {
-        return ethers.Transaction.from({
-            ...transaction,
-            signature: this.parseSignature(mpcSignatures[0]),
-        }).serialized;
-    }
-    async broadcastTx(txSerialized) {
-        try {
-            const txResponse = await this.provider.broadcastTransaction(txSerialized);
-            return txResponse.hash;
-        }
-        catch (error) {
-            console.error('Transaction broadcast failed:', error);
-            throw new Error('Failed to broadcast transaction.');
-        }
-    }
-}

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

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

package/src/chains/EVM/types.js

@@ -1 +0,0 @@
-export {};

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

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

package/src/chains/EVM/utils.js

@@ -1,14 +0,0 @@
-import { ethers } from 'ethers';
-export async function fetchEVMFeeProperties(providerUrl, transaction) {
-    const provider = new ethers.JsonRpcProvider(providerUrl);
-    const gasLimit = await provider.estimateGas(transaction);
-    const feeData = await provider.getFeeData();
-    const maxFeePerGas = feeData.maxFeePerGas ?? ethers.parseUnits('10', 'gwei');
-    const maxPriorityFeePerGas = feeData.maxPriorityFeePerGas ?? ethers.parseUnits('10', 'gwei');
-    return {
-        gasLimit,
-        maxFeePerGas,
-        maxPriorityFeePerGas,
-        maxFee: maxFeePerGas * gasLimit,
-    };
-}

package/src/chains/index.d.ts

@@ -1,12 +0,0 @@
-export { Chain } from './Chain';
-export { ChainSignatureContract, type SignArgs } from './ChainSignatureContract';
-export * from './types';
-export * as utils from './utils';
-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/src/chains/index.js

@@ -1,12 +0,0 @@
-export { Chain } from './Chain';
-export { ChainSignatureContract } from './ChainSignatureContract';
-export * from './types';
-export * as utils from './utils';
-// EVM
-export { EVM } from './EVM/EVM';
-export { fetchEVMFeeProperties } from './EVM/utils';
-// Bitcoin
-export { Bitcoin } from './Bitcoin/Bitcoin';
-export { BTCRpcAdapters, BTCRpcAdapter } from './Bitcoin/BTCRpcAdapter';
-// Cosmos
-export { Cosmos } from './Cosmos/Cosmos';

package/src/chains/types.d.ts

@@ -1,31 +0,0 @@
-import { type SignArgs } from '@chains';
-interface SuccessResponse {
-    transactionHash: string;
-    success: true;
-}
-interface FailureResponse {
-    success: false;
-    errorMessage: string;
-}
-export type Response = SuccessResponse | FailureResponse;
-export type MPCPayloads = Array<{
-    index: number;
-    payload: 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;
-}
-export {};

package/src/chains/types.js

@@ -1 +0,0 @@
-export {};

package/src/chains/utils.d.ts

@@ -1,12 +0,0 @@
-import { type MPCSignature, type RSVSignature, type UncompressedPubKeySEC1 } from '@chains';
-export declare const toRSV: (signature: MPCSignature) => RSVSignature;
-/**
- * Compresses an uncompressed public key to its compressed format following SEC1 standards.
- * In SEC1, a compressed public key consists of a prefix (02 or 03) followed by the x-coordinate.
- * The prefix indicates whether the y-coordinate is even (02) or odd (03).
- *
- * @param uncompressedPubKeySEC1 - The uncompressed public key in hex format, with or without '04' prefix
- * @returns The compressed public key in hex format
- * @throws Error if the uncompressed public key length is invalid
- */
-export declare const compressPubKey: (uncompressedPubKeySEC1: UncompressedPubKeySEC1) => string;

package/src/chains/utils.js

@@ -1,27 +0,0 @@
-export const toRSV = (signature) => {
-    return {
-        r: signature.big_r.affine_point.substring(2),
-        s: signature.s.scalar,
-        v: signature.recovery_id,
-    };
-};
-/**
- * Compresses an uncompressed public key to its compressed format following SEC1 standards.
- * In SEC1, a compressed public key consists of a prefix (02 or 03) followed by the x-coordinate.
- * The prefix indicates whether the y-coordinate is even (02) or odd (03).
- *
- * @param uncompressedPubKeySEC1 - The uncompressed public key in hex format, with or without '04' prefix
- * @returns The compressed public key in hex format
- * @throws Error if the uncompressed public key length is invalid
- */
-export const compressPubKey = (uncompressedPubKeySEC1) => {
-    const slicedPubKey = uncompressedPubKeySEC1.slice(2);
-    if (slicedPubKey.length !== 128) {
-        throw new Error('Invalid uncompressed public key length');
-    }
-    const x = slicedPubKey.slice(0, 64);
-    const y = slicedPubKey.slice(64);
-    const isEven = parseInt(y.slice(-1), 16) % 2 === 0;
-    const prefix = isEven ? '02' : '03';
-    return prefix + x;
-};

package/src/index.d.ts

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

package/src/index.js

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

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

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

package/src/utils/chains/index.js

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

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

@@ -1,13 +0,0 @@
-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/src/utils/chains/near/account.js

@@ -1,22 +0,0 @@
-import { Account, Connection } from '@near-js/accounts';
-import { KeyPair } from '@near-js/crypto';
-import { InMemoryKeyStore } from '@near-js/keystores';
-import { DONT_CARE_ACCOUNT_ID } from '@utils/chains/near/constants';
-export const getNearAccount = async ({ networkId, accountId = DONT_CARE_ACCOUNT_ID, keypair = KeyPair.fromRandom('ed25519'), }) => {
-    const keyStore = new InMemoryKeyStore();
-    await keyStore.setKey(networkId, accountId, keypair);
-    const connection = Connection.fromConfig({
-        networkId,
-        provider: {
-            type: 'JsonRpcProvider',
-            args: {
-                url: {
-                    testnet: 'https://rpc.testnet.near.org',
-                    mainnet: 'https://rpc.mainnet.near.org',
-                }[networkId],
-            },
-        },
-        signer: { type: 'InMemorySigner', keyStore },
-    });
-    return new Account(connection, accountId);
-};

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

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

package/src/utils/chains/near/constants.js

@@ -1,3 +0,0 @@
-import BN from 'bn.js';
-export const NEAR_MAX_GAS = new BN('300000000000000');
-export const DONT_CARE_ACCOUNT_ID = 'dontcare';

package/src/utils/chains/near/contract.d.ts

@@ -1,39 +0,0 @@
-import { type Account } from '@near-js/accounts';
-import { KeyPair } from '@near-js/crypto';
-import BN from 'bn.js';
-import { ChainSignatureContract } from '@chains';
-import type { RSVSignature, UncompressedPubKeySEC1, SignArgs } from '@chains';
-import { type NearNetworkIds, type ChainSignatureContractIds } from '@utils/chains/near/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 NearChainSignatureContract extends ChainSignatureContract {
-    private readonly networkId;
-    private readonly contractId;
-    private readonly accountId;
-    private readonly keypair;
-    constructor({ networkId, contractId, accountId, keypair, }: ChainSignatureContractArgs);
-    private getContract;
-    getPublicKey(): Promise<UncompressedPubKeySEC1>;
-    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 {};