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

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,42 +0,0 @@
-import type { MPCPayloads, RSVSignature, KeyDerivationPath } from '../types';
-import type { EVMTransactionRequest, EVMUnsignedTransaction } from '../EVM/types';
-import type { ChainSignatureContract } from '../ChainSignatureContract';
-import { Chain } from '../Chain';
-/**
- * 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,109 +0,0 @@
-import { fromHex } from '@cosmjs/encoding';
-import { ethers, keccak256 } from 'ethers';
-import { Chain } from '../Chain';
-import { fetchEVMFeeProperties } from '../EVM/utils';
-/**
- * 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 './ChainSignatureContract';
-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 './types';
-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 '../../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,40 +0,0 @@
-import { type Account } from '@near-js/accounts';
-import { KeyPair } from '@near-js/crypto';
-import BN from 'bn.js';
-import { ChainSignatureContract } from '../../../chains/ChainSignatureContract';
-import type { RSVSignature, UncompressedPubKeySEC1 } from '../../../chains/types';
-import type { SignArgs } from '../../../chains/ChainSignatureContract';
-import { type NearNetworkIds, type ChainSignatureContractIds } from '../../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 {};

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

@@ -1,102 +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 } from '../../../chains/ChainSignatureContract';
-import { utils } from '../../../chains/index.js';
-import { chains } from '../../index.js';
-import { getNearAccount } from '../../chains/near/account';
-import { DONT_CARE_ACCOUNT_ID, NEAR_MAX_GAS, } from '../../chains/near/constants';
-import { parseSignedDelegateForRelayer } from '../../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/types';
-import { type BitcoinRequest, type CosmosRequest, type EVMRequest } from '../../../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>;