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

package/src/chains/Bitcoin/Bitcoin.js

@@ -1,198 +0,0 @@
-import * as bitcoin from 'bitcoinjs-lib';
-import { Chain } from '../Chain';
-import { utils } from '../index.js';
-import { parseBTCNetwork } from '../Bitcoin/utils';
-/**
- * Implementation of the Chain interface for Bitcoin network.
- * Handles interactions with both Bitcoin mainnet and testnet, supporting P2WPKH transactions.
- */
-export class Bitcoin extends Chain {
-    /**
-     * Creates a new Bitcoin chain instance
-     * @param params - Configuration parameters
-     * @param params.network - Network identifier (mainnet/testnet)
-     * @param params.contract - Instance of the chain signature contract for MPC operations
-     * @param params.btcRpcAdapter - Bitcoin RPC adapter for network interactions
-     */
-    constructor({ network, contract, btcRpcAdapter, }) {
-        super();
-        this.network = network;
-        this.btcRpcAdapter = btcRpcAdapter;
-        this.contract = contract;
-    }
-    /**
-     * Converts satoshis to BTC
-     * @param satoshis - Amount in satoshis
-     * @returns Amount in BTC
-     */
-    static toBTC(satoshis) {
-        return satoshis / Bitcoin.SATOSHIS_PER_BTC;
-    }
-    /**
-     * Converts BTC to satoshis
-     * @param btc - Amount in BTC
-     * @returns Amount in satoshis (rounded)
-     */
-    static toSatoshi(btc) {
-        return Math.round(btc * Bitcoin.SATOSHIS_PER_BTC);
-    }
-    async fetchTransaction(transactionId) {
-        const data = await this.btcRpcAdapter.getTransaction(transactionId);
-        const tx = new bitcoin.Transaction();
-        data.vout.forEach((vout) => {
-            const scriptPubKey = Buffer.from(vout.scriptpubkey, 'hex');
-            tx.addOutput(scriptPubKey, Number(vout.value));
-        });
-        return tx;
-    }
-    static parseRSVSignature(signature) {
-        const r = signature.r.padStart(64, '0');
-        const s = signature.s.padStart(64, '0');
-        const rawSignature = Buffer.from(r + s, 'hex');
-        if (rawSignature.length !== 64) {
-            throw new Error('Invalid signature length.');
-        }
-        return rawSignature;
-    }
-    /**
-     * Creates a Partially Signed Bitcoin Transaction (PSBT)
-     * @param params - Parameters for creating the PSBT
-     * @param params.transactionRequest - Transaction request containing inputs and outputs
-     * @returns Created PSBT instance
-     */
-    async createPSBT({ transactionRequest, }) {
-        const { inputs, outputs } = transactionRequest.inputs && transactionRequest.outputs
-            ? transactionRequest
-            : await this.btcRpcAdapter.selectUTXOs(transactionRequest.from, [
-                {
-                    address: transactionRequest.to,
-                    value: parseFloat(transactionRequest.value),
-                },
-            ]);
-        const psbt = new bitcoin.Psbt({ network: parseBTCNetwork(this.network) });
-        await Promise.all(inputs.map(async (input) => {
-            if (!input.scriptPubKey) {
-                const transaction = await this.fetchTransaction(input.txid);
-                const prevOut = transaction.outs[input.vout];
-                input.scriptPubKey = prevOut.script;
-            }
-            // Prepare the input as P2WPKH
-            psbt.addInput({
-                hash: input.txid,
-                index: input.vout,
-                witnessUtxo: {
-                    script: input.scriptPubKey,
-                    value: input.value,
-                },
-            });
-        }));
-        outputs.forEach((out) => {
-            if (out.address) {
-                psbt.addOutput({
-                    address: out.address,
-                    value: out.value,
-                });
-            }
-            else if (out.script) {
-                psbt.addOutput({
-                    script: out.script,
-                    value: out.value,
-                });
-            }
-        });
-        return psbt;
-    }
-    async getBalance(address) {
-        const balance = await this.btcRpcAdapter.getBalance(address);
-        return Bitcoin.toBTC(balance).toString();
-    }
-    async deriveAddressAndPublicKey(predecessor, path) {
-        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 publicKeyBuffer = Buffer.from(derivedKey, 'hex');
-        const network = parseBTCNetwork(this.network);
-        const payment = bitcoin.payments.p2wpkh({
-            pubkey: publicKeyBuffer,
-            network,
-        });
-        const { address } = payment;
-        if (!address) {
-            throw new Error('Failed to generate Bitcoin address');
-        }
-        return { address, publicKey: derivedKey };
-    }
-    setTransaction(transaction, storageKey) {
-        window.localStorage.setItem(storageKey, JSON.stringify({
-            psbt: transaction.psbt.toHex(),
-            publicKey: transaction.publicKey,
-        }));
-    }
-    getTransaction(storageKey, options) {
-        const txSerialized = window.localStorage.getItem(storageKey);
-        if (!txSerialized)
-            return undefined;
-        if (options?.remove) {
-            window.localStorage.removeItem(storageKey);
-        }
-        const transactionJSON = JSON.parse(txSerialized);
-        return {
-            psbt: bitcoin.Psbt.fromHex(transactionJSON.psbt),
-            publicKey: transactionJSON.publicKey,
-        };
-    }
-    async getMPCPayloadAndTransaction(transactionRequest) {
-        const publicKeyBuffer = Buffer.from(transactionRequest.publicKey, 'hex');
-        const psbt = await this.createPSBT({
-            transactionRequest,
-        });
-        // We can't double sign a PSBT, therefore we serialize the payload before to return it
-        const psbtHex = psbt.toHex();
-        const mpcPayloads = [];
-        const mockKeyPair = (index) => ({
-            publicKey: publicKeyBuffer,
-            sign: (hash) => {
-                mpcPayloads.push({
-                    index,
-                    payload: Array.from(hash),
-                });
-                // Return dummy signature to satisfy the interface
-                return Buffer.alloc(64);
-            },
-        });
-        for (let index = 0; index < psbt.inputCount; index++) {
-            psbt.signInput(index, mockKeyPair(index));
-        }
-        return {
-            transaction: {
-                psbt: bitcoin.Psbt.fromHex(psbtHex),
-                publicKey: transactionRequest.publicKey,
-            },
-            mpcPayloads: mpcPayloads.sort((a, b) => a.index - b.index),
-        };
-    }
-    addSignature({ transaction: { psbt, publicKey }, mpcSignatures, }) {
-        const publicKeyBuffer = Buffer.from(publicKey, 'hex');
-        const keyPair = (index) => ({
-            publicKey: publicKeyBuffer,
-            sign: () => {
-                const mpcSignature = mpcSignatures[index];
-                return Bitcoin.parseRSVSignature(mpcSignature);
-            },
-        });
-        for (let index = 0; index < psbt.inputCount; index++) {
-            psbt.signInput(index, keyPair(index));
-        }
-        psbt.finalizeAllInputs();
-        return psbt.extractTransaction().toHex();
-    }
-    async broadcastTx(txSerialized) {
-        return await this.btcRpcAdapter.broadcastTransaction(txSerialized);
-    }
-}
-Bitcoin.SATOSHIS_PER_BTC = 100000000;

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

@@ -1,42 +0,0 @@
-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/src/chains/Bitcoin/types.js

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

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

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

package/src/chains/Bitcoin/utils.js

@@ -1,13 +0,0 @@
-import * as bitcoin from 'bitcoinjs-lib';
-export function parseBTCNetwork(network) {
-    switch (network.toLowerCase()) {
-        case 'mainnet':
-            return bitcoin.networks.bitcoin;
-        case 'testnet':
-            return bitcoin.networks.testnet;
-        case 'regtest':
-            return bitcoin.networks.regtest;
-        default:
-            throw new Error(`Unknown Bitcoin network: ${network}`);
-    }
-}

package/src/chains/Chain.d.ts

@@ -1,89 +0,0 @@
-import type { KeyDerivationPath, MPCPayloads, RSVSignature } from './types';
-/**
- * Core interface for blockchain implementations.
- * Provides a standardized way to interact with different blockchain networks through a common set of methods.
- *
- * @typeParam TransactionRequest - The type of transaction request specific to the blockchain
- * @typeParam UnsignedTransaction - The type of unsigned transaction specific to the blockchain
- */
-export declare abstract class Chain<TransactionRequest, UnsignedTransaction> {
-    /**
-     * Gets the native token balance for a given address
-     *
-     * @param address - The blockchain address to check
-     * @returns Promise resolving to the balance as a string, formatted according to the chain's decimal places (e.g. ETH, BTC, etc.)
-     * @throws Error if the balance fetch fails or the address is invalid
-     */
-    abstract getBalance(address: string): Promise<string>;
-    /**
-     * Derives an address and public key from a signer ID and derivation path.
-     * Uses MPC (Multi-Party Computation) to derive the key pair securely.
-     *
-     * @param predecessor - The signer ID used to call the sign function on ChainSignatureContract
-     * @param path - The derivation path that uniquely identifies this key pair
-     * @returns Promise resolving to the derived address and its corresponding public key
-     * @throws Error if key derivation fails or the signer ID is invalid
-     */
-    abstract deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath): Promise<{
-        address: string;
-        publicKey: string;
-    }>;
-    /**
-     * Stores an unsigned transaction in local storage for later use.
-     * This method persists transaction data between page reloads and browser sessions.
-     * Particularly useful for browser-based wallets that need to maintain transaction state.
-     *
-     * @param transaction - The unsigned transaction to store
-     * @param storageKey - Unique key to identify the stored transaction
-     */
-    abstract setTransaction(transaction: UnsignedTransaction, storageKey: string): void;
-    /**
-     * Retrieves a previously stored transaction from local storage.
-     *
-     * @param storageKey - The key used to store the transaction
-     * @param options - Additional options
-     * @param options.remove - If true, removes the transaction from storage after retrieval
-     * @returns The stored transaction or undefined if not found
-     */
-    abstract getTransaction(storageKey: string, options?: {
-        remove?: boolean;
-    }): UnsignedTransaction | undefined;
-    /**
-     * Prepares a transaction for MPC signing by creating the necessary payloads.
-     * This method handles chain-specific transaction preparation including:
-     * - Fee calculation
-     * - Nonce/sequence management
-     * - UTXO selection (for UTXO-based chains)
-     * - Transaction encoding
-     *
-     * @param transactionRequest - The transaction request containing parameters like recipient, amount, etc.
-     * @returns Promise resolving to the unsigned transaction and MPC payloads for signing
-     * @throws Error if transaction preparation fails
-     */
-    abstract getMPCPayloadAndTransaction(transactionRequest: TransactionRequest): Promise<{
-        transaction: UnsignedTransaction;
-        mpcPayloads: MPCPayloads;
-    }>;
-    /**
-     * Adds MPC-generated signatures to an unsigned transaction.
-     * The signatures are applied according to the chain's specific signing scheme.
-     *
-     * @param params - Parameters for adding signatures
-     * @param params.transaction - The unsigned transaction to sign
-     * @param params.mpcSignatures - Array of RSV signatures generated through MPC
-     * @returns The serialized signed transaction ready for broadcast
-     * @throws Error if signature application fails
-     */
-    abstract addSignature(params: {
-        transaction: UnsignedTransaction;
-        mpcSignatures: RSVSignature[];
-    }): string;
-    /**
-     * Broadcasts a signed transaction to the network.
-     *
-     * @param txSerialized - The serialized signed transaction
-     * @returns Promise resolving to the transaction hash/ID
-     * @throws Error if broadcast fails or transaction is rejected
-     */
-    abstract broadcastTx(txSerialized: string): Promise<string>;
-}

package/src/chains/Chain.js

@@ -1,9 +0,0 @@
-/**
- * Core interface for blockchain implementations.
- * Provides a standardized way to interact with different blockchain networks through a common set of methods.
- *
- * @typeParam TransactionRequest - The type of transaction request specific to the blockchain
- * @typeParam UnsignedTransaction - The type of unsigned transaction specific to the blockchain
- */
-export class Chain {
-}

package/src/chains/ChainSignatureContract.d.ts

@@ -1,62 +0,0 @@
-import type BN from 'bn.js';
-import type { RSVSignature, UncompressedPubKeySEC1 } from './types';
-/**
- * Arguments for the sign method
- */
-export interface SignArgs {
-    /** The payload to sign as an array of 32 bytes */
-    payload: number[];
-    /** The derivation path for key generation */
-    path: string;
-    /** Version of the key to use */
-    key_version: number;
-}
-/**
- * Abstract class defining the interface for chain signature contracts.
- * This contract handles MPC (Multi-Party Computation) operations for secure key derivation and signing.
- * It serves as a bridge between the blockchain implementations and the MPC infrastructure.
- */
-export declare abstract class ChainSignatureContract {
-    /**
-     * Gets the current signature deposit required by the contract.
-     * This deposit amount helps manage network congestion.
-     *
-     * @returns Promise resolving to the required deposit amount as a BigNumber
-     * @throws Error if the deposit check fails
-     */
-    abstract getCurrentSignatureDeposit(): Promise<BN>;
-    /**
-     * Gets the public key associated with this contract.
-     * This is the root public key from which child keys can be derived.
-     *
-     * @returns Promise resolving to the uncompressed public key
-     * @throws Error if public key retrieval fails
-     */
-    abstract getPublicKey(): Promise<UncompressedPubKeySEC1>;
-    /**
-     * Signs a payload using MPC.
-     * This is the core signing operation that coordinates with the MPC infrastructure.
-     *
-     * @param args - Arguments for the signing operation
-     * @param args.payload - The data to sign
-     * @param args.path - Derivation path for the signing key
-     * @param args.key_version - Version of the key to use
-     * @returns Promise resolving to the RSV signature
-     * @throws Error if signing fails or is rejected
-     */
-    abstract sign(args: SignArgs & Record<string, unknown>): Promise<RSVSignature>;
-    /**
-     * Derives a child public key using a derivation path and predecessor.
-     * This method implements hierarchical deterministic key derivation.
-     *
-     * @param args - Arguments for key derivation
-     * @param args.path - The derivation path to use
-     * @param args.predecessor - The predecessor key (usually a NEAR account) that controls this derived key
-     * @returns Promise resolving to the derived uncompressed public key
-     * @throws Error if key derivation fails
-     */
-    abstract getDerivedPublicKey(args: {
-        path: string;
-        predecessor: string;
-    } & Record<string, unknown>): Promise<UncompressedPubKeySEC1>;
-}

package/src/chains/ChainSignatureContract.js

@@ -1,7 +0,0 @@
-/**
- * Abstract class defining the interface for chain signature contracts.
- * This contract handles MPC (Multi-Party Computation) operations for secure key derivation and signing.
- * It serves as a bridge between the blockchain implementations and the MPC infrastructure.
- */
-export class ChainSignatureContract {
-}

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

@@ -1,51 +0,0 @@
-import type { CosmosNetworkIds, CosmosTransactionRequest, CosmosUnsignedTransaction } from '../Cosmos/types';
-import type { ChainSignatureContract } from '../ChainSignatureContract';
-import type { MPCPayloads, RSVSignature, KeyDerivationPath } from '../types';
-import { Chain } from '../Chain';
-/**
- * Implementation of the Chain interface for Cosmos-based networks.
- * Handles interactions with Cosmos SDK chains like Cosmos Hub, Osmosis, etc.
- */
-export declare class Cosmos extends Chain<CosmosTransactionRequest, CosmosUnsignedTransaction> {
-    private readonly registry;
-    private readonly chainId;
-    private readonly contract;
-    private readonly endpoints?;
-    /**
-     * 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, }: {
-        contract: ChainSignatureContract;
-        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/src/chains/Cosmos/Cosmos.js

@@ -1,157 +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 } from '../Chain';
-import { utils } from '../index.js';
-import { fetchChainInfo } from '../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 '../Cosmos/types';
-export declare const fetchChainInfo: (chainId: string) => Promise<ChainInfo>;