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

package/src/utils/chains/near/signAndSend/keypair.js

@@ -1,127 +0,0 @@
-import { Bitcoin, Cosmos, EVM } from '../../../../chains/index.js';
-import { BTCRpcAdapters } from '../../../../chains/Bitcoin/BTCRpcAdapter';
-import { getNearAccount } from '../../../chains/near/account';
-import { NearChainSignatureContract } from '../../../chains/near/contract';
-export const EVMTransaction = async (req, keyPair) => {
-    try {
-        const account = await getNearAccount({
-            networkId: req.nearAuthentication.networkId,
-            accountId: req.nearAuthentication.accountId,
-            keypair: keyPair,
-        });
-        const contract = new NearChainSignatureContract({
-            networkId: req.nearAuthentication.networkId,
-            contractId: req.chainConfig.contract,
-            accountId: account.accountId,
-            keypair: keyPair,
-        });
-        const evm = new EVM({
-            rpcUrl: req.chainConfig.providerUrl,
-            contract,
-        });
-        const { transaction, mpcPayloads } = await evm.getMPCPayloadAndTransaction(req.transaction);
-        const signature = await contract.sign({
-            payload: mpcPayloads[0].payload,
-            path: req.derivationPath,
-            key_version: 0,
-        });
-        const txSerialized = evm.addSignature({
-            transaction,
-            mpcSignatures: [signature],
-        });
-        const txHash = await evm.broadcastTx(txSerialized);
-        return {
-            transactionHash: txHash,
-            success: true,
-        };
-    }
-    catch (e) {
-        console.error(e);
-        return {
-            success: false,
-            errorMessage: e instanceof Error ? e.message : String(e),
-        };
-    }
-};
-export const BTCTransaction = async (req, keyPair) => {
-    try {
-        const account = await getNearAccount({
-            networkId: req.nearAuthentication.networkId,
-            accountId: req.nearAuthentication.accountId,
-            keypair: keyPair,
-        });
-        const contract = new NearChainSignatureContract({
-            networkId: req.nearAuthentication.networkId,
-            contractId: req.chainConfig.contract,
-            accountId: account.accountId,
-            keypair: keyPair,
-        });
-        const btc = new Bitcoin({
-            btcRpcAdapter: new BTCRpcAdapters.Mempool(req.chainConfig.providerUrl),
-            contract,
-            network: req.chainConfig.network,
-        });
-        const { transaction, mpcPayloads } = await btc.getMPCPayloadAndTransaction(req.transaction);
-        const signatures = await Promise.all(mpcPayloads.map(async ({ payload }) => await contract.sign({
-            payload,
-            path: req.derivationPath,
-            key_version: 0,
-        })));
-        const txSerialized = btc.addSignature({
-            transaction,
-            mpcSignatures: signatures,
-        });
-        const txHash = await btc.broadcastTx(txSerialized);
-        return {
-            transactionHash: txHash,
-            success: true,
-        };
-    }
-    catch (e) {
-        return {
-            success: false,
-            errorMessage: e instanceof Error ? e.message : String(e),
-        };
-    }
-};
-export const CosmosTransaction = async (req, keyPair) => {
-    try {
-        const account = await getNearAccount({
-            networkId: req.nearAuthentication.networkId,
-            accountId: req.nearAuthentication.accountId,
-            keypair: keyPair,
-        });
-        const contract = new NearChainSignatureContract({
-            networkId: req.nearAuthentication.networkId,
-            contractId: req.chainConfig.contract,
-            accountId: account.accountId,
-            keypair: keyPair,
-        });
-        const cosmos = new Cosmos({
-            contract,
-            chainId: req.chainConfig.chainId,
-        });
-        const { transaction, mpcPayloads } = await cosmos.getMPCPayloadAndTransaction(req.transaction);
-        const signatures = await Promise.all(mpcPayloads.map(async ({ payload }) => await contract.sign({
-            payload,
-            path: req.derivationPath,
-            key_version: 0,
-        })));
-        const txSerialized = cosmos.addSignature({
-            transaction,
-            mpcSignatures: signatures,
-        });
-        const txHash = await cosmos.broadcastTx(txSerialized);
-        return {
-            transactionHash: txHash,
-            success: true,
-        };
-    }
-    catch (e) {
-        console.error(e);
-        return {
-            success: false,
-            errorMessage: e instanceof Error ? e.message : String(e),
-        };
-    }
-};

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

@@ -1,26 +0,0 @@
-import type { Action, FinalExecutionOutcome, NetworkId } from '@near-wallet-selector/core';
-import { type RSVSignature, type KeyDerivationPath, type MPCPayloads } from '../../../chains/types';
-import { type NFTKeysContracts, type ChainSignatureContractIds } from '../../chains/near/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/src/utils/chains/near/transactionBuilder.js

@@ -1,72 +0,0 @@
-import BN from 'bn.js';
-import { utils } from '../../../chains/index.js';
-import { NEAR_MAX_GAS } from '../../chains/near/constants';
-import { NearChainSignatureContract } from '../../chains/near/contract';
-export const mpcPayloadsToChainSigTransaction = async ({ networkId, contractId, mpcPayloads, path, }) => {
-    const contract = new NearChainSignatureContract({
-        networkId,
-        contractId,
-    });
-    const currentContractFee = await contract.getCurrentSignatureDeposit();
-    return {
-        receiverId: contractId,
-        actions: mpcPayloads.map(({ payload }) => ({
-            type: 'FunctionCall',
-            params: {
-                methodName: 'sign',
-                args: {
-                    request: {
-                        payload: Array.from(payload),
-                        path,
-                        key_version: 0,
-                    },
-                },
-                gas: NEAR_MAX_GAS.div(new BN(mpcPayloads.length)).toString(),
-                deposit: currentContractFee?.toString() || '1',
-            },
-        })),
-    };
-};
-export const mpcPayloadsToNFTKeysTransaction = async ({ networkId, chainSigContract, nftKeysContract, mpcPayloads, path, tokenId, }) => {
-    const contract = new NearChainSignatureContract({
-        networkId,
-        contractId: chainSigContract,
-    });
-    const currentContractFee = await contract.getCurrentSignatureDeposit();
-    return {
-        receiverId: nftKeysContract,
-        actions: mpcPayloads.map(({ payload }) => ({
-            type: 'FunctionCall',
-            params: {
-                methodName: 'ckt_sign_hash',
-                args: {
-                    token_id: tokenId,
-                    path,
-                    payload: Array.from(payload),
-                },
-                gas: NEAR_MAX_GAS.div(new BN(mpcPayloads.length)).toString(),
-                deposit: currentContractFee?.toString() || '1',
-            },
-        })),
-    };
-};
-export const responseToMpcSignature = ({ response, }) => {
-    const signature = response.receipts_outcome.reduce((acc, curr) => {
-        if (acc) {
-            return acc;
-        }
-        const { status } = curr.outcome;
-        return ((typeof status === 'object' &&
-            status.SuccessValue &&
-            status.SuccessValue !== '' &&
-            Buffer.from(status.SuccessValue, 'base64').toString('utf-8')) ||
-            '');
-    }, '');
-    if (signature) {
-        const parsedJSONSignature = JSON.parse(signature);
-        return utils.toRSV(parsedJSONSignature.Ok);
-    }
-    else {
-        return undefined;
-    }
-};

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

@@ -1,50 +0,0 @@
-import type { KeyDerivationPath } from '../../../chains/types';
-import type { BTCTransactionRequest, BTCNetworkIds } from '../../../chains/Bitcoin/types';
-import type { CosmosNetworkIds, CosmosTransactionRequest } from '../../../chains/Cosmos/types';
-import { type EVMTransactionRequest } from '../../../chains/EVM/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/src/utils/chains/near/types.js

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

package/src/utils/index.d.ts

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

package/src/utils/index.js

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

package/vocs.config.d.ts

@@ -1,3 +0,0 @@
-import { type Config } from 'vocs';
-declare const _default: Config;
-export default _default;

package/vocs.config.js

@@ -1,71 +0,0 @@
-import { defineConfig } from 'vocs';
-export default defineConfig({
-    title: 'Signet.js',
-    description: 'A TypeScript library for handling multi-chain transactions and signatures using MPC',
-    twoslash: {
-        compilerOptions: {
-            strict: true,
-            paths: {
-                'signet.js': ['./src'],
-                '@chains': ['./src/chains'],
-                '@utils': ['./src/utils'],
-                '@chains/*': ['./src/chains/*'],
-                '@utils/*': ['./src/utils/*'],
-            },
-        },
-    },
-    sidebar: [
-        {
-            text: 'Getting Started',
-            items: [
-                { text: 'Overview', link: '/' },
-                { text: 'Sig Network', link: '/sig-net' },
-            ],
-        },
-        {
-            text: 'Supported Chains',
-            items: [
-                { text: 'EVM Chains', link: '/chains/evm' },
-                { text: 'Bitcoin', link: '/chains/bitcoin' },
-                { text: 'Cosmos', link: '/chains/cosmos' },
-            ],
-        },
-        {
-            text: 'Core Concepts',
-            items: [
-                { text: 'Chain Interface', link: '/guides/implementing-new-chain' },
-                { text: 'MPC Overview', link: '/guides/mpc-overview' },
-            ],
-        },
-        {
-            text: 'Implementation Guides',
-            collapsed: true,
-            items: [
-                {
-                    text: 'Creating a New Chain',
-                    link: '/guides/implementing-new-chain',
-                },
-                {
-                    text: 'Bitcoin RPC Adapter',
-                    link: '/guides/implementing-btc-adapter',
-                },
-                {
-                    text: 'Chain Signature Contract',
-                    link: '/guides/implementing-signature-contract',
-                },
-            ],
-        },
-    ],
-    socials: [
-        {
-            icon: 'github',
-            link: 'https://github.com/near/signet.js',
-        },
-    ],
-    theme: {
-        accentColor: {
-            light: '#00C08B',
-            dark: '#00E6A6',
-        },
-    },
-});