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

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

@@ -1,101 +0,0 @@
-import { Contract } from '@near-js/accounts';
-import { KeyPair } from '@near-js/crypto';
-import { actionCreators } from '@near-js/transactions';
-import BN from 'bn.js';
-import { base_decode } from 'near-api-js/lib/utils/serialize';
-import { ChainSignatureContract, utils } from '@chains';
-import { chains } from '@utils';
-import { getNearAccount } from '@utils/chains/near/account';
-import { DONT_CARE_ACCOUNT_ID, NEAR_MAX_GAS, } from '@utils/chains/near/constants';
-import { parseSignedDelegateForRelayer } from '@utils/chains/near/relayer';
-const najToUncompressedPubKey = (najPubKey) => {
-    return `04${Buffer.from(base_decode(najPubKey.split(':')[1])).toString('hex')}`;
-};
-const requireAccount = (accountId) => {
-    if (accountId === DONT_CARE_ACCOUNT_ID) {
-        throw new Error('A valid account ID and keypair are required for change methods. Please instantiate a new contract with valid credentials.');
-    }
-};
-/**
- * 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 class NearChainSignatureContract extends ChainSignatureContract {
-    constructor({ networkId, contractId, accountId = DONT_CARE_ACCOUNT_ID, keypair = KeyPair.fromRandom('ed25519'), }) {
-        super();
-        this.networkId = networkId;
-        this.contractId = contractId;
-        this.accountId = accountId;
-        this.keypair = keypair;
-    }
-    async getContract() {
-        const account = await getNearAccount({
-            networkId: this.networkId,
-            accountId: this.accountId,
-            keypair: this.keypair,
-        });
-        return new Contract(account, this.contractId, {
-            viewMethods: [
-                'public_key',
-                'experimental_signature_deposit',
-                'derived_public_key',
-            ],
-            changeMethods: ['sign'],
-            useLocalViewExecution: false,
-        });
-    }
-    async getPublicKey() {
-        const contract = await this.getContract();
-        const najPubKey = await contract.public_key();
-        return najToUncompressedPubKey(najPubKey);
-    }
-    async getCurrentSignatureDeposit() {
-        const contract = await this.getContract();
-        return new BN((await contract.experimental_signature_deposit()).toLocaleString('fullwide', {
-            useGrouping: false,
-        }));
-    }
-    async getDerivedPublicKey(args) {
-        const contract = await this.getContract();
-        const najPubKey = await contract.derived_public_key(args);
-        return najToUncompressedPubKey(najPubKey);
-    }
-    async sign(args) {
-        requireAccount(this.accountId);
-        const contract = await this.getContract();
-        const deposit = await this.getCurrentSignatureDeposit();
-        const signature = await contract.sign({
-            args: { request: args },
-            gas: NEAR_MAX_GAS,
-            amount: deposit,
-        });
-        return utils.toRSV(signature);
-    }
-    static async signWithRelayer({ account, contract, signArgs, deposit, relayerUrl, }) {
-        const functionCall = actionCreators.functionCall('sign', { request: signArgs }, BigInt(NEAR_MAX_GAS.toString()), BigInt(deposit.toString()));
-        const signedDelegate = await account.signedDelegate({
-            receiverId: contract,
-            actions: [functionCall],
-            blockHeightTtl: 60,
-        });
-        // Remove the cached access key to prevent nonce reuse
-        delete account.accessKeyByPublicKeyCache[
-        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-        signedDelegate.delegateAction.publicKey.toString()];
-        const res = await fetch(`${relayerUrl}/send_meta_tx_async`, {
-            method: 'POST',
-            mode: 'cors',
-            body: JSON.stringify(parseSignedDelegateForRelayer(signedDelegate)),
-            headers: new Headers({ 'Content-Type': 'application/json' }),
-        });
-        const txHash = await res.text();
-        const txStatus = await account.connection.provider.txStatus(txHash, account.accountId, 'FINAL');
-        const signature = chains.near.transactionBuilder.responseToMpcSignature({
-            response: txStatus,
-        });
-        if (!signature) {
-            throw new Error('Signature error, please retry');
-        }
-        return signature;
-    }
-}

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

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

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

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

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

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

package/src/utils/chains/near/relayer/index.js

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

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

@@ -1,8 +0,0 @@
-import { type SignedDelegate } from '@near-js/transactions';
-import { type 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/src/utils/chains/near/relayer/relayer.js

@@ -1,33 +0,0 @@
-import bs58 from 'bs58';
-/**
- * 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 function parseSignedDelegateForRelayer(signedDelegate) {
-    return {
-        delegate_action: {
-            actions: signedDelegate.delegateAction.actions
-                .map((action) => {
-                if (action.functionCall) {
-                    return {
-                        FunctionCall: {
-                            method_name: action.functionCall.methodName,
-                            args: Buffer.from(action.functionCall.args).toString('base64'),
-                            gas: Number(action.functionCall.gas),
-                            deposit: action.functionCall.deposit.toString(),
-                        },
-                    };
-                }
-                return undefined;
-            })
-                .flatMap((t) => (t ? [t] : [])),
-            nonce: Number(signedDelegate.delegateAction.nonce),
-            max_block_height: Number(signedDelegate.delegateAction.maxBlockHeight),
-            public_key: signedDelegate.delegateAction.publicKey.toString(),
-            receiver_id: signedDelegate.delegateAction.receiverId,
-            sender_id: signedDelegate.delegateAction.senderId,
-        },
-        signature: `ed25519:${bs58.encode(signedDelegate.signature.data)}`,
-    };
-}

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

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

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

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

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

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

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

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

@@ -1,6 +0,0 @@
-import { type KeyPair } from '@near-js/crypto';
-import { type Response } from '@chains';
-import { type BitcoinRequest, type CosmosRequest, type EVMRequest } from '@utils/chains/near/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/src/utils/chains/near/signAndSend/keypair.js

@@ -1,126 +0,0 @@
-import { Bitcoin, Cosmos, EVM, BTCRpcAdapters } from '@chains';
-import { getNearAccount } from '@utils/chains/near/account';
-import { NearChainSignatureContract } from '@utils/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';
-import { type NFTKeysContracts, type ChainSignatureContractIds } from '@utils/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';
-import { NEAR_MAX_GAS } from '@utils/chains/near/constants';
-import { NearChainSignatureContract } from '@utils/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,47 +0,0 @@
-import { type BTCTransactionRequest, type BTCNetworkIds, type CosmosNetworkIds, type CosmosTransactionRequest, type EVMTransactionRequest, type KeyDerivationPath } from '@chains';
-/**
-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',
-        },
-    },
-});