@magnaflow/chain-provider 1.0.1

package/README.md

@@ -0,0 +1,64 @@
+# @magnaflow/chain-provider
+
+Chain provider abstractions for unified EVM and Tron operations.
+
+## What It Provides
+
+- A shared `ChainProvider` interface for balances, transfers, receipts, and gas estimation
+- `EvmProvider` backed by `viem`
+- `TronProvider` backed by `tronweb`
+- Factory helpers for creating providers from backend chain configuration
+
+## Install
+
+```bash
+npm install @magnaflow/chain-provider
+```
+
+## Key Exports
+
+- `createChainProvider`
+- `createEvmProvider`
+- `createTronProvider`
+- `getChainType`
+- `EvmProvider`
+- `TronProvider`
+- `createViemChainFromConfig`
+
+## Example
+
+```ts
+import { createChainProvider } from '@magnaflow/chain-provider';
+
+const provider = createChainProvider(
+  {
+    name: 'BSC Mainnet',
+    chain: 'bsc',
+    rpc_url: 'https://bsc-dataseed.binance.org',
+    rest_url: 'https://bsc-dataseed.binance.org',
+    payout_contract: '0x0000000000000000000000000000000000000000',
+  },
+  process.env.MNEMONIC,
+);
+
+const balances = await provider.getBalances('0x1234...', [
+  '0x55d398326f99059fF775485246999027B3197955',
+]);
+```
+
+## Notes
+
+- The default EVM chain resolver is currently tuned for BSC and BSC testnet style configs.
+- `TronProvider` supports native transfers and balance queries. Advanced Tron contract interaction lives outside this package.
+
+## Development
+
+```bash
+bunx nx run chain-provider:lint
+bunx nx run chain-provider:test
+bunx nx run chain-provider:build
+```
+
+## License
+
+MIT

package/dist/chain-factory.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Chain factory for creating chain providers
+ */
+import type { ChainConfig, ChainType } from './types';
+import type { ChainProvider } from './chain-provider';
+import { EvmProvider } from './evm-provider';
+import { TronProvider } from './tron-provider';
+/**
+ * Determine chain type from chain identifier
+ */
+export declare function getChainType(chainIdentifier: string): ChainType;
+/**
+ * Create chain provider from configuration
+ */
+export declare function createChainProvider(chainConfig: ChainConfig, mnemonic?: string, accountIndex?: number): ChainProvider;
+/**
+ * Create EVM provider
+ */
+export declare function createEvmProvider(chainConfig: ChainConfig, mnemonic?: string, accountIndex?: number): EvmProvider;
+/**
+ * Create Tron provider
+ */
+export declare function createTronProvider(chainConfig: ChainConfig, mnemonic?: string, accountIndex?: number): TronProvider;
+//# sourceMappingURL=chain-factory.d.ts.map

package/dist/chain-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain-factory.d.ts","sourceRoot":"","sources":["../src/chain-factory.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C;;GAEG;AACH,wBAAgB,YAAY,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,CAM/D;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,WAAW,EACxB,QAAQ,CAAC,EAAE,MAAM,EACjB,YAAY,GAAE,MAAU,GACvB,aAAa,CAQf;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,WAAW,EACxB,QAAQ,CAAC,EAAE,MAAM,EACjB,YAAY,GAAE,MAAU,GACvB,WAAW,CAEb;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,WAAW,EACxB,QAAQ,CAAC,EAAE,MAAM,EACjB,YAAY,GAAE,MAAU,GACvB,YAAY,CAEd"}

package/dist/chain-factory.js

@@ -0,0 +1,39 @@
+/**
+ * Chain factory for creating chain providers
+ */
+import { EvmProvider } from './evm-provider';
+import { TronProvider } from './tron-provider';
+/**
+ * Determine chain type from chain identifier
+ */
+export function getChainType(chainIdentifier) {
+    const lower = chainIdentifier.toLowerCase();
+    if (lower.includes('trx') || lower.includes('tron')) {
+        return 'tron';
+    }
+    return 'evm';
+}
+/**
+ * Create chain provider from configuration
+ */
+export function createChainProvider(chainConfig, mnemonic, accountIndex = 0) {
+    const chainType = getChainType(chainConfig.chain);
+    if (chainType === 'evm') {
+        return new EvmProvider(chainConfig, mnemonic, accountIndex);
+    }
+    else {
+        return new TronProvider(chainConfig, mnemonic, accountIndex);
+    }
+}
+/**
+ * Create EVM provider
+ */
+export function createEvmProvider(chainConfig, mnemonic, accountIndex = 0) {
+    return new EvmProvider(chainConfig, mnemonic, accountIndex);
+}
+/**
+ * Create Tron provider
+ */
+export function createTronProvider(chainConfig, mnemonic, accountIndex = 0) {
+    return new TronProvider(chainConfig, mnemonic, accountIndex);
+}

package/dist/chain-provider.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Chain provider interface
+ * Defines the contract for chain-specific implementations
+ */
+import type { ChainType, BalanceInfo, TransactionOptions, TransactionResult, TransactionReceipt } from './types';
+/**
+ * Chain provider interface
+ */
+export interface ChainProvider {
+    /**
+     * Get chain type
+     */
+    getChainType(): ChainType;
+    /**
+     * Get native balance for an address
+     */
+    getNativeBalance(address: string): Promise<string>;
+    /**
+     * Get token balance for an address
+     */
+    getTokenBalance(tokenAddress: string, address: string, decimals?: number): Promise<string>;
+    /**
+     * Get multiple balances (native + tokens)
+     */
+    getBalances(address: string, tokenAddresses?: string[]): Promise<BalanceInfo>;
+    /**
+     * Send native token transaction
+     */
+    sendTransaction(from: string, to: string, amount: string, options?: TransactionOptions): Promise<TransactionResult>;
+    /**
+     * Wait for transaction confirmation
+     */
+    waitForTransaction(txHash: string, options?: {
+        timeout?: number;
+        confirmations?: number;
+    }): Promise<TransactionReceipt>;
+    /**
+     * Get transaction receipt
+     */
+    getTransactionReceipt(txHash: string): Promise<TransactionReceipt | null>;
+    /**
+     * Estimate gas for a transaction
+     */
+    estimateGas(from: string, to: string, data?: string, value?: bigint): Promise<bigint>;
+}
+//# sourceMappingURL=chain-provider.d.ts.map

package/dist/chain-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain-provider.d.ts","sourceRoot":"","sources":["../src/chain-provider.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,WAAW,EACX,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,YAAY,IAAI,SAAS,CAAC;IAE1B;;OAEG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAEnD;;OAEG;IACH,eAAe,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAE3F;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IAE9E;;OAEG;IACH,eAAe,CACb,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAE9B;;OAEG;IACH,kBAAkB,CAChB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE,GACrD,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAE/B;;OAEG;IACH,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAAC;IAE1E;;OAEG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACvF"}

package/dist/chain-provider.js

@@ -0,0 +1,5 @@
+/**
+ * Chain provider interface
+ * Defines the contract for chain-specific implementations
+ */
+export {};

package/dist/evm-chain-utils.d.ts

@@ -0,0 +1,22 @@
+import type { Chain } from 'viem';
+import type { ChainConfig } from './types';
+/**
+ * Interface layer: strategy type for resolving a runtime EVM chain
+ * configuration from backend-provided ChainConfig.
+ */
+export type EvmChainRuntimeResolver = (config: ChainConfig) => Chain;
+/**
+ * Implementation layer: default resolver that normalizes ChainConfig
+ * into a viem Chain definition.
+ *
+ * Rules:
+ * - BSC testnet detection is based on rest_url and chain identifier.
+ * - Default mainnet id is 56 (BSC mainnet) when not on testnet.
+ * - scan_url, if present, is used as the default block explorer URL.
+ */
+export declare const defaultEvmChainRuntimeResolver: EvmChainRuntimeResolver;
+/**
+ * Convenience export used by application code.
+ */
+export declare const createViemChainFromConfig: EvmChainRuntimeResolver;
+//# sourceMappingURL=evm-chain-utils.d.ts.map

package/dist/evm-chain-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evm-chain-utils.d.ts","sourceRoot":"","sources":["../src/evm-chain-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAClC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C;;;GAGG;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,MAAM,EAAE,WAAW,KAAK,KAAK,CAAC;AAErE;;;;;;;;GAQG;AACH,eAAO,MAAM,8BAA8B,EAAE,uBAyC5C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,yBAAyB,EAAE,uBAAwD,CAAC"}

package/dist/evm-chain-utils.js

@@ -0,0 +1,51 @@
+import { bscTestnet, bsc } from 'viem/chains';
+/**
+ * Implementation layer: default resolver that normalizes ChainConfig
+ * into a viem Chain definition.
+ *
+ * Rules:
+ * - BSC testnet detection is based on rest_url and chain identifier.
+ * - Default mainnet id is 56 (BSC mainnet) when not on testnet.
+ * - scan_url, if present, is used as the default block explorer URL.
+ */
+export const defaultEvmChainRuntimeResolver = (chainConfig) => {
+    const isBscTestnet = chainConfig.rest_url.includes('prebsc') ||
+        chainConfig.rest_url.includes('bsc-testnet') ||
+        chainConfig.chain?.toLowerCase() === 'bsc_test';
+    if (isBscTestnet) {
+        return {
+            ...bscTestnet,
+            rpcUrls: {
+                default: {
+                    http: [chainConfig.rest_url],
+                },
+            },
+            blockExplorers: {
+                default: {
+                    name: 'BscScan',
+                    url: chainConfig.scan_url || bscTestnet.blockExplorers?.default?.url,
+                },
+            },
+        };
+    }
+    return {
+        ...bsc,
+        rpcUrls: {
+            default: {
+                http: [chainConfig.rest_url],
+            },
+        },
+        blockExplorers: chainConfig.scan_url
+            ? {
+                default: {
+                    name: 'Explorer',
+                    url: chainConfig.scan_url,
+                },
+            }
+            : undefined,
+    };
+};
+/**
+ * Convenience export used by application code.
+ */
+export const createViemChainFromConfig = defaultEvmChainRuntimeResolver;

package/dist/evm-provider.d.ts

@@ -0,0 +1,207 @@
+/**
+ * EVM chain provider implementation
+ */
+import { type PublicClient, type WalletClient } from 'viem';
+import type { ChainConfig, BalanceInfo, TransactionOptions, TransactionResult, TransactionReceipt } from './types';
+import type { ChainProvider } from './chain-provider';
+/**
+ * EVM chain provider
+ */
+export declare class EvmProvider implements ChainProvider {
+    private chainConfig;
+    private publicClient;
+    private chain;
+    private account?;
+    constructor(chainConfig: ChainConfig, mnemonic?: string, accountIndex?: number);
+    getChainType(): 'evm';
+    getNativeBalance(address: string): Promise<string>;
+    getTokenBalance(tokenAddress: string, address: string, decimals?: number): Promise<string>;
+    getBalances(address: string, tokenAddresses?: string[]): Promise<BalanceInfo>;
+    sendTransaction(_from: string, to: string, amount: string, options?: TransactionOptions): Promise<TransactionResult>;
+    waitForTransaction(txHash: string, options?: {
+        timeout?: number;
+        confirmations?: number;
+    }): Promise<TransactionReceipt>;
+    getTransactionReceipt(txHash: string): Promise<TransactionReceipt | null>;
+    estimateGas(from: string, to: string, data?: string, value?: bigint): Promise<bigint>;
+    /**
+     * Get block number (using viem)
+     */
+    getBlockNumber(): Promise<bigint>;
+    /**
+     * Get block (using viem)
+     */
+    getBlock(blockNumber?: bigint): Promise<{
+        number: bigint;
+        nonce: `0x${string}`;
+        hash: `0x${string}`;
+        gasUsed: bigint;
+        logsBloom: `0x${string}`;
+        baseFeePerGas: bigint | null;
+        blobGasUsed: bigint;
+        difficulty: bigint;
+        excessBlobGas: bigint;
+        extraData: import("viem").Hex;
+        gasLimit: bigint;
+        miner: import("viem").Address;
+        mixHash: import("viem").Hash;
+        parentBeaconBlockRoot?: `0x${string}` | undefined;
+        parentHash: import("viem").Hash;
+        receiptsRoot: import("viem").Hex;
+        sealFields: import("viem").Hex[];
+        sha3Uncles: import("viem").Hash;
+        size: bigint;
+        stateRoot: import("viem").Hash;
+        timestamp: bigint;
+        totalDifficulty: bigint | null;
+        transactionsRoot: import("viem").Hash;
+        uncles: import("viem").Hash[];
+        withdrawals?: import("viem").Withdrawal[] | undefined | undefined;
+        withdrawalsRoot?: `0x${string}` | undefined;
+        transactions: `0x${string}`[];
+    }>;
+    /**
+     * Get transaction (using viem)
+     */
+    getTransaction(txHash: string): Promise<{
+        from: import("viem").Address;
+        gas: bigint;
+        nonce: number;
+        to: import("viem").Address | null;
+        type: "legacy";
+        value: bigint;
+        r: import("viem").Hex;
+        s: import("viem").Hex;
+        v: bigint;
+        yParity?: undefined | undefined;
+        blobVersionedHashes?: undefined | undefined;
+        gasPrice: bigint;
+        maxFeePerBlobGas?: undefined | undefined;
+        maxFeePerGas?: undefined | undefined;
+        maxPriorityFeePerGas?: undefined | undefined;
+        chainId?: number | undefined;
+        accessList?: undefined | undefined;
+        authorizationList?: undefined | undefined;
+        hash: import("viem").Hash;
+        input: import("viem").Hex;
+        typeHex: import("viem").Hex | null;
+        blockNumber: bigint;
+        blockHash: `0x${string}`;
+        transactionIndex: number;
+    } | {
+        from: import("viem").Address;
+        gas: bigint;
+        nonce: number;
+        to: import("viem").Address | null;
+        type: "eip2930";
+        value: bigint;
+        r: import("viem").Hex;
+        s: import("viem").Hex;
+        v: bigint;
+        yParity: number;
+        blobVersionedHashes?: undefined | undefined;
+        gasPrice: bigint;
+        maxFeePerBlobGas?: undefined | undefined;
+        maxFeePerGas?: undefined | undefined;
+        maxPriorityFeePerGas?: undefined | undefined;
+        chainId: number;
+        accessList: import("viem").AccessList;
+        authorizationList?: undefined | undefined;
+        hash: import("viem").Hash;
+        input: import("viem").Hex;
+        typeHex: import("viem").Hex | null;
+        blockNumber: bigint;
+        blockHash: `0x${string}`;
+        transactionIndex: number;
+    } | {
+        from: import("viem").Address;
+        gas: bigint;
+        nonce: number;
+        to: import("viem").Address | null;
+        type: "eip1559";
+        value: bigint;
+        r: import("viem").Hex;
+        s: import("viem").Hex;
+        v: bigint;
+        yParity: number;
+        blobVersionedHashes?: undefined | undefined;
+        gasPrice?: undefined | undefined;
+        maxFeePerBlobGas?: undefined | undefined;
+        maxFeePerGas: bigint;
+        maxPriorityFeePerGas: bigint;
+        chainId: number;
+        accessList: import("viem").AccessList;
+        authorizationList?: undefined | undefined;
+        hash: import("viem").Hash;
+        input: import("viem").Hex;
+        typeHex: import("viem").Hex | null;
+        blockNumber: bigint;
+        blockHash: `0x${string}`;
+        transactionIndex: number;
+    } | {
+        from: import("viem").Address;
+        gas: bigint;
+        nonce: number;
+        to: import("viem").Address | null;
+        type: "eip4844";
+        value: bigint;
+        r: import("viem").Hex;
+        s: import("viem").Hex;
+        v: bigint;
+        yParity: number;
+        blobVersionedHashes: readonly import("viem").Hex[];
+        gasPrice?: undefined | undefined;
+        maxFeePerBlobGas: bigint;
+        maxFeePerGas: bigint;
+        maxPriorityFeePerGas: bigint;
+        chainId: number;
+        accessList: import("viem").AccessList;
+        authorizationList?: undefined | undefined;
+        hash: import("viem").Hash;
+        input: import("viem").Hex;
+        typeHex: import("viem").Hex | null;
+        blockNumber: bigint;
+        blockHash: `0x${string}`;
+        transactionIndex: number;
+    } | {
+        from: import("viem").Address;
+        gas: bigint;
+        nonce: number;
+        to: import("viem").Address | null;
+        type: "eip7702";
+        value: bigint;
+        r: import("viem").Hex;
+        s: import("viem").Hex;
+        v: bigint;
+        yParity: number;
+        blobVersionedHashes?: undefined | undefined;
+        gasPrice?: undefined | undefined;
+        maxFeePerBlobGas?: undefined | undefined;
+        maxFeePerGas: bigint;
+        maxPriorityFeePerGas: bigint;
+        chainId: number;
+        accessList: import("viem").AccessList;
+        authorizationList: import("viem").SignedAuthorizationList;
+        hash: import("viem").Hash;
+        input: import("viem").Hex;
+        typeHex: import("viem").Hex | null;
+        blockNumber: bigint;
+        blockHash: `0x${string}`;
+        transactionIndex: number;
+    }>;
+    /**
+     * Get fee data (using viem)
+     */
+    getFeeData(): Promise<import("viem").FeeValuesEIP1559>;
+    /**
+     * Get public client (for advanced usage)
+     */
+    getPublicClient(): PublicClient;
+    /**
+     * Get wallet client (for advanced usage)
+     * Uses lazy initialization to avoid creating multiple instances
+     */
+    private _walletClient;
+    getWalletClient(): WalletClient | null;
+}
+//# sourceMappingURL=evm-provider.d.ts.map

package/dist/evm-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evm-provider.d.ts","sourceRoot":"","sources":["../src/evm-provider.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAIL,KAAK,YAAY,EAEjB,KAAK,YAAY,EAElB,MAAM,MAAM,CAAC;AAEd,OAAO,KAAK,EACV,WAAW,EACX,WAAW,EACX,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAItD;;GAEG;AACH,qBAAa,WAAY,YAAW,aAAa;IAC/C,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,OAAO,CAAC,CAAU;gBAEd,WAAW,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU;IAgBjF,YAAY,IAAI,KAAK;IAIf,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAOlD,eAAe,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAuB1F,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,GAAE,MAAM,EAAO,GAAG,OAAO,CAAC,WAAW,CAAC;IAuCjF,eAAe,CACnB,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,iBAAiB,CAAC;IAmCvB,kBAAkB,CACtB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE,GACrD,OAAO,CAAC,kBAAkB,CAAC;IAmBxB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAoBzE,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAU3F;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC;IAIvC;;OAEG;IACG,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAOnC;;OAEG;IACG,cAAc,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAMnC;;OAEG;IACG,UAAU;IAIhB;;OAEG;IACH,eAAe,IAAI,YAAY;IAI/B;;;OAGG;IACH,OAAO,CAAC,aAAa,CAA6B;IAClD,eAAe,IAAI,YAAY,GAAG,IAAI;CAavC"}

package/dist/evm-provider.js

@@ -0,0 +1,218 @@
+/**
+ * EVM chain provider implementation
+ */
+import { createPublicClient, createWalletClient, http, } from 'viem';
+import { mnemonicToAccount } from 'viem/accounts';
+import { DERIVATION_PATH_BASE, buildDerivationPath } from '@magnaflow/eoa-wallet';
+import { createViemChainFromConfig } from './evm-chain-utils';
+/**
+ * EVM chain provider
+ */
+export class EvmProvider {
+    constructor(chainConfig, mnemonic, accountIndex = 0) {
+        /**
+         * Get wallet client (for advanced usage)
+         * Uses lazy initialization to avoid creating multiple instances
+         */
+        this._walletClient = null;
+        this.chainConfig = chainConfig;
+        this.chain = createViemChainFromConfig(chainConfig);
+        this.publicClient = createPublicClient({
+            chain: this.chain,
+            transport: http(chainConfig.rest_url),
+        });
+        if (mnemonic) {
+            const path = buildDerivationPath(DERIVATION_PATH_BASE.evm, accountIndex);
+            this.account = mnemonicToAccount(mnemonic, {
+                path: path,
+            });
+        }
+    }
+    getChainType() {
+        return 'evm';
+    }
+    async getNativeBalance(address) {
+        const balance = await this.publicClient.getBalance({
+            address: address,
+        });
+        return balance.toString();
+    }
+    async getTokenBalance(tokenAddress, address, decimals) {
+        // decimals parameter is kept for API consistency but not used
+        // Token decimals are handled by the caller if needed
+        void decimals;
+        // Use viem's readContract with standard ERC20 ABI
+        const balance = await this.publicClient.readContract({
+            address: tokenAddress,
+            abi: [
+                {
+                    type: 'function',
+                    name: 'balanceOf',
+                    inputs: [{ name: 'account', type: 'address' }],
+                    outputs: [{ name: '', type: 'uint256' }],
+                    stateMutability: 'view',
+                },
+            ],
+            functionName: 'balanceOf',
+            args: [address],
+        });
+        return balance.toString();
+    }
+    async getBalances(address, tokenAddresses = []) {
+        // Use viem's multicall for batch reads (more efficient)
+        const erc20Abi = [
+            {
+                type: 'function',
+                name: 'balanceOf',
+                inputs: [{ name: 'account', type: 'address' }],
+                outputs: [{ name: '', type: 'uint256' }],
+                stateMutability: 'view',
+            },
+        ];
+        const calls = tokenAddresses.map((tokenAddress) => ({
+            address: tokenAddress,
+            abi: erc20Abi,
+            functionName: 'balanceOf',
+            args: [address],
+        }));
+        // Get native balance and token balances in parallel
+        const [native, tokenBalances] = await Promise.all([
+            this.getNativeBalance(address),
+            calls.length > 0 ? this.publicClient.multicall({ contracts: calls }) : Promise.resolve([]),
+        ]);
+        // Build tokens record
+        const tokens = {};
+        tokenAddresses.forEach((tokenAddress, index) => {
+            const result = tokenBalances[index];
+            if (result && 'status' in result && result.status === 'success') {
+                tokens[tokenAddress] = result.result.toString();
+            }
+            else {
+                tokens[tokenAddress] = '0';
+            }
+        });
+        return { native, tokens };
+    }
+    async sendTransaction(_from, to, amount, options) {
+        if (!this.account) {
+            throw new Error('Account not initialized. Provide mnemonic in constructor.');
+        }
+        // Use cached wallet client or create new one
+        const walletClient = this.getWalletClient();
+        if (!walletClient) {
+            throw new Error('Wallet client not available');
+        }
+        // Use viem's sendTransaction with all options
+        // Note: gasPrice and maxFeePerGas/maxPriorityFeePerGas are mutually exclusive
+        const txParams = {
+            to: to,
+            value: BigInt(amount),
+            gas: options?.gasLimit,
+        };
+        // Use EIP-1559 fees if provided, otherwise fall back to gasPrice
+        if (options?.maxFeePerGas || options?.maxPriorityFeePerGas) {
+            txParams.maxFeePerGas = options?.maxFeePerGas;
+            txParams.maxPriorityFeePerGas = options?.maxPriorityFeePerGas;
+        }
+        else if (options?.gasPrice) {
+            txParams.gasPrice = options.gasPrice;
+        }
+        const hash = await walletClient.sendTransaction(txParams);
+        return {
+            hash,
+            chainType: 'evm',
+        };
+    }
+    async waitForTransaction(txHash, options) {
+        // Use viem's waitForTransactionReceipt directly
+        const receipt = await this.publicClient.waitForTransactionReceipt({
+            hash: txHash,
+            timeout: options?.timeout,
+            confirmations: options?.confirmations,
+        });
+        // Map viem receipt to our receipt format
+        return {
+            hash: receipt.transactionHash,
+            status: receipt.status === 'success' ? 'success' : 'failed',
+            blockNumber: Number(receipt.blockNumber),
+            blockHash: receipt.blockHash,
+            gasUsed: receipt.gasUsed,
+            effectiveGasPrice: receipt.effectiveGasPrice,
+        };
+    }
+    async getTransactionReceipt(txHash) {
+        // Use viem's getTransactionReceipt directly
+        try {
+            const receipt = await this.publicClient.getTransactionReceipt({
+                hash: txHash,
+            });
+            return {
+                hash: receipt.transactionHash,
+                status: receipt.status === 'success' ? 'success' : 'failed',
+                blockNumber: Number(receipt.blockNumber),
+                blockHash: receipt.blockHash,
+                gasUsed: receipt.gasUsed,
+                effectiveGasPrice: receipt.effectiveGasPrice,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async estimateGas(from, to, data, value) {
+        // Use viem's estimateGas directly
+        return await this.publicClient.estimateGas({
+            account: from,
+            to: to,
+            data: data,
+            value,
+        });
+    }
+    /**
+     * Get block number (using viem)
+     */
+    async getBlockNumber() {
+        return await this.publicClient.getBlockNumber();
+    }
+    /**
+     * Get block (using viem)
+     */
+    async getBlock(blockNumber) {
+        if (blockNumber) {
+            return await this.publicClient.getBlock({ blockNumber });
+        }
+        return await this.publicClient.getBlock();
+    }
+    /**
+     * Get transaction (using viem)
+     */
+    async getTransaction(txHash) {
+        return await this.publicClient.getTransaction({
+            hash: txHash,
+        });
+    }
+    /**
+     * Get fee data (using viem)
+     */
+    async getFeeData() {
+        return await this.publicClient.estimateFeesPerGas();
+    }
+    /**
+     * Get public client (for advanced usage)
+     */
+    getPublicClient() {
+        return this.publicClient;
+    }
+    getWalletClient() {
+        if (!this.account)
+            return null;
+        if (!this._walletClient) {
+            this._walletClient = createWalletClient({
+                account: this.account,
+                chain: this.chain,
+                transport: http(this.chainConfig.rest_url),
+            });
+        }
+        return this._walletClient;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @magnaflow/chain-provider
+ * Chain provider abstraction library for unified blockchain interactions
+ */
+export type { ChainType, ChainConfig, TokenConfig, BalanceInfo, TransactionOptions, TransactionResult, TransactionReceipt, } from './types';
+export type { ChainProvider } from './chain-provider';
+export { EvmProvider } from './evm-provider';
+export { TronProvider } from './tron-provider';
+export { createViemChainFromConfig } from './evm-chain-utils';
+export { getChainType, createChainProvider, createEvmProvider, createTronProvider, } from './chain-factory';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,YAAY,EACV,SAAS,EACT,WAAW,EACX,WAAW,EACX,WAAW,EACX,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,SAAS,CAAC;AAGjB,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGtD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAG9D,OAAO,EACL,YAAY,EACZ,mBAAmB,EACnB,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,10 @@
+/**
+ * @magnaflow/chain-provider
+ * Chain provider abstraction library for unified blockchain interactions
+ */
+// Providers
+export { EvmProvider } from './evm-provider';
+export { TronProvider } from './tron-provider';
+export { createViemChainFromConfig } from './evm-chain-utils';
+// Factory
+export { getChainType, createChainProvider, createEvmProvider, createTronProvider, } from './chain-factory';

package/dist/tron-provider.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Tron chain provider implementation
+ */
+import { TronWeb } from 'tronweb';
+import type { ChainConfig, BalanceInfo, TransactionOptions, TransactionResult, TransactionReceipt } from './types';
+import type { ChainProvider } from './chain-provider';
+/**
+ * Tron chain provider
+ */
+export declare class TronProvider implements ChainProvider {
+    private chainConfig;
+    private tronWeb;
+    private privateKey?;
+    constructor(chainConfig: ChainConfig, mnemonic?: string, accountIndex?: number);
+    getChainType(): 'tron';
+    getNativeBalance(address: string): Promise<string>;
+    getTokenBalance(tokenAddress: string, address: string, _decimals?: number): Promise<string>;
+    getBalances(address: string, tokenAddresses?: string[]): Promise<BalanceInfo>;
+    sendTransaction(_from: string, to: string, amount: string, _options?: TransactionOptions): Promise<TransactionResult>;
+    waitForTransaction(txHash: string, options?: {
+        timeout?: number;
+        confirmations?: number;
+    }): Promise<TransactionReceipt>;
+    getTransactionReceipt(txHash: string): Promise<TransactionReceipt | null>;
+    estimateGas(_from: string, _to: string, _data?: string, _value?: bigint): Promise<bigint>;
+    /**
+     * Get TronWeb instance (for advanced usage)
+     */
+    getTronWeb(): TronWeb;
+}
+//# sourceMappingURL=tron-provider.d.ts.map

package/dist/tron-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tron-provider.d.ts","sourceRoot":"","sources":["../src/tron-provider.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAClC,OAAO,KAAK,EACV,WAAW,EACX,WAAW,EACX,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGtD;;GAEG;AACH,qBAAa,YAAa,YAAW,aAAa;IAChD,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,UAAU,CAAC,CAAS;gBAEhB,WAAW,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU;IAsBjF,YAAY,IAAI,MAAM;IAIhB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAKlD,eAAe,CACnB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC;IAMZ,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,GAAE,MAAM,EAAO,GAAG,OAAO,CAAC,WAAW,CAAC;IAkBjF,eAAe,CACnB,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,MAAM,EACd,QAAQ,CAAC,EAAE,kBAAkB,GAC5B,OAAO,CAAC,iBAAiB,CAAC;IAuCvB,kBAAkB,CACtB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE,GACrD,OAAO,CAAC,kBAAkB,CAAC;IA0BxB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAiBzE,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAM/F;;OAEG;IACH,UAAU,IAAI,OAAO;CAGtB"}

package/dist/tron-provider.js

@@ -0,0 +1,130 @@
+/**
+ * Tron chain provider implementation
+ */
+import { TronWeb } from 'tronweb';
+import { DERIVATION_PATH_BASE, buildDerivationPath } from '@magnaflow/eoa-wallet';
+/**
+ * Tron chain provider
+ */
+export class TronProvider {
+    constructor(chainConfig, mnemonic, accountIndex = 0) {
+        this.chainConfig = chainConfig;
+        // Create TronWeb instance
+        let fullHost = chainConfig.rest_url;
+        if (typeof fullHost === 'string') {
+            fullHost = fullHost.replace(/\/jsonrpc\/?$/i, '');
+        }
+        this.tronWeb = new TronWeb({
+            fullHost,
+        });
+        // Set private key if mnemonic provided
+        if (mnemonic) {
+            const path = buildDerivationPath(DERIVATION_PATH_BASE.tron, accountIndex);
+            const { privateKey } = TronWeb.fromMnemonic(mnemonic, path);
+            this.privateKey = privateKey;
+            this.tronWeb.setPrivateKey(privateKey);
+        }
+    }
+    getChainType() {
+        return 'tron';
+    }
+    async getNativeBalance(address) {
+        const balance = await this.tronWeb.trx.getBalance(address);
+        return balance.toString();
+    }
+    async getTokenBalance(tokenAddress, address, _decimals) {
+        const contract = await this.tronWeb.contract().at(tokenAddress);
+        const balance = await contract.balanceOf(address).call();
+        return balance.toString();
+    }
+    async getBalances(address, tokenAddresses = []) {
+        const native = await this.getNativeBalance(address);
+        const tokens = {};
+        for (const tokenAddress of tokenAddresses) {
+            const tokenConfig = this.chainConfig.tokens?.find((t) => t.contract_addr.toLowerCase() === tokenAddress.toLowerCase());
+            tokens[tokenAddress] = await this.getTokenBalance(tokenAddress, address, tokenConfig?.decimal);
+        }
+        return { native, tokens };
+    }
+    async sendTransaction(_from, to, amount, _options) {
+        if (!this.privateKey) {
+            throw new Error('Private key not initialized. Provide mnemonic in constructor.');
+        }
+        // Amount is expected to be in sun (base units), provided as a decimal string.
+        // TronWeb.sendTrx currently accepts a JavaScript number, so we:
+        // - parse the value as BigInt to validate it is a non-negative integer
+        // - ensure it fits safely in Number without precision loss
+        let sunAmount;
+        try {
+            sunAmount = BigInt(amount);
+        }
+        catch {
+            throw new Error(`Invalid amount for Tron transaction: "${amount}"`);
+        }
+        if (sunAmount < 0n) {
+            throw new Error('Amount for Tron transaction must be non-negative');
+        }
+        const maxSafe = BigInt(Number.MAX_SAFE_INTEGER);
+        if (sunAmount > maxSafe) {
+            throw new Error(`Amount in sun (${sunAmount.toString()}) exceeds JavaScript Number safe range; ` +
+                'please split into smaller transfers or use a lower amount.');
+        }
+        // sendTrx uses the address from setPrivateKey, so we only need to pass target and amount.
+        const tx = await this.tronWeb.trx.sendTrx(to, Number(sunAmount));
+        // TronWeb sendTrx returns BroadcastReturn which has txid property
+        const txHash = typeof tx === 'string' ? tx : tx.txid || tx.hash || String(tx);
+        return {
+            hash: txHash,
+            chainType: 'tron',
+        };
+    }
+    async waitForTransaction(txHash, options) {
+        const maxRetries = options?.timeout ? Math.floor(options.timeout / 2000) : 30;
+        let retryCount = 0;
+        while (retryCount < maxRetries) {
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+            try {
+                const txInfo = await this.tronWeb.trx.getTransactionInfo(txHash);
+                if (txInfo?.receipt) {
+                    return {
+                        hash: txHash,
+                        status: txInfo.receipt.result === 'SUCCESS' ? 'success' : 'failed',
+                        blockNumber: txInfo.blockNumber,
+                    };
+                }
+            }
+            catch {
+                // Continue retrying
+            }
+            retryCount++;
+        }
+        throw new Error('Transaction confirmation timeout');
+    }
+    async getTransactionReceipt(txHash) {
+        try {
+            const txInfo = await this.tronWeb.trx.getTransactionInfo(txHash);
+            if (!txInfo?.receipt) {
+                return null;
+            }
+            return {
+                hash: txHash,
+                status: txInfo.receipt.result === 'SUCCESS' ? 'success' : 'failed',
+                blockNumber: txInfo.blockNumber,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async estimateGas(_from, _to, _data, _value) {
+        // Tron doesn't have gas estimation in the same way
+        // Return a default fee limit
+        return BigInt(10000000); // 10 TRX in sun
+    }
+    /**
+     * Get TronWeb instance (for advanced usage)
+     */
+    getTronWeb() {
+        return this.tronWeb;
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Chain type identifier
+ */
+export type ChainType = 'evm' | 'tron';
+/**
+ * Chain configuration
+ */
+export interface ChainConfig {
+    name: string;
+    chain: string;
+    rpc_url: string;
+    rest_url: string;
+    payout_contract: string;
+    scan_url?: string;
+    tokens?: TokenConfig[];
+}
+/**
+ * Token configuration
+ */
+export interface TokenConfig {
+    name: string;
+    symbol: string;
+    contract_addr: string;
+    decimal: number;
+}
+/**
+ * Balance information
+ */
+export interface BalanceInfo {
+    native: string;
+    tokens: Record<string, string>;
+}
+/**
+ * Transaction options
+ *
+ * Cross-chain semantics:
+ * - EVM chains:
+ *   - gasLimit / gasPrice / maxFeePerGas / maxPriorityFeePerGas are used as-is.
+ *   - value is the native token amount in base units (for example, wei).
+ * - Tron:
+ *   - feeLimit is used as the max TRX fee in sun.
+ *   - value is ignored by the built-in TronProvider sendTransaction implementation.
+ */
+export interface TransactionOptions {
+    gasLimit?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    feeLimit?: number;
+    value?: bigint;
+}
+/**
+ * Transaction result
+ */
+export interface TransactionResult {
+    hash: string;
+    chainType: ChainType;
+}
+/**
+ * Transaction receipt
+ */
+export interface TransactionReceipt {
+    hash: string;
+    status: 'success' | 'failed';
+    blockNumber?: number;
+    blockHash?: string;
+    gasUsed?: bigint;
+    effectiveGasPrice?: bigint;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,MAAM,CAAC;AAEvC;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,WAAW,EAAE,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,SAAS,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,SAAS,GAAG,QAAQ,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B"}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@magnaflow/chain-provider",
+  "version": "1.0.1",
+  "description": "Chain provider abstraction library for unified blockchain interactions",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "node ../../scripts/verify-package-dist.cjs"
+  },
+  "keywords": [
+    "blockchain",
+    "chain-provider",
+    "ethereum",
+    "tron",
+    "web3",
+    "viem",
+    "tronweb"
+  ],
+  "author": "",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@magnaflow/eoa-wallet": "workspace:*",
+    "tronweb": "^6.1.0",
+    "viem": "^2.39.2"
+  },
+  "devDependencies": {
+    "typescript": "~5.9.3",
+    "vitest": "^2.1.9",
+    "@vitest/coverage-v8": "^2.1.9"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/magnaflowlabs/merchant-v2-sdk.git",
+    "directory": "packages/chain-provider"
+  }
+}