minara 0.1.0

package/README.md

@@ -0,0 +1,246 @@
+<p align="center">
+  <h1 align="center">Minara CLI</h1>
+  <p align="center">
+    Your AI-powered digital finance assistant — from the terminal.
+    <br />
+    Trade, swap, chat, and manage your portfolio without leaving the command line.
+  </p>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/minara"><img alt="npm version" src="https://img.shields.io/npm/v/minara?color=cb3837&label=npm"></a>
+  <a href="https://github.com/user/minara-cli/blob/main/LICENSE"><img alt="License: MIT" src="https://img.shields.io/badge/license-MIT-blue.svg"></a>
+  <img alt="Node.js" src="https://img.shields.io/badge/node-%3E%3D18-brightgreen">
+  <img alt="TypeScript" src="https://img.shields.io/badge/TypeScript-strict-3178c6">
+</p>
+
+---
+
+## Features
+
+- **Multi-method Login** — Email verification code, Google OAuth, or Apple ID
+- **Deposit & Withdraw** — View deposit addresses across chains, withdraw to external wallets
+- **Asset Management** — View wallet balances across all supported chains
+- **AI Chat** — Stream conversations with Minara AI, with thinking and deep-research modes
+- **Spot Trading** — Cross-chain token swaps with dry-run simulation
+- **Perpetual Futures** — Deposit, withdraw, place/cancel orders, manage leverage (Hyperliquid)
+- **Limit Orders** — Create, list, and cancel price-triggered orders
+- **Copy Trading** — Follow wallet addresses with configurable bots
+- **Market Discovery** — Trending tokens, Fear & Greed Index, Bitcoin metrics
+
+## Installation
+
+```bash
+npm install -g minara
+```
+
+Or run without installing:
+
+```bash
+npx minara --help
+```
+
+**Requires Node.js >= 18**
+
+## Quick Start
+
+```bash
+# Login (interactive — choose email, Google, or Apple)
+minara login
+
+# Check your account
+minara account
+
+# View deposit addresses
+minara deposit
+
+# Chat with Minara AI
+minara chat "What's the best DeFi yield right now?"
+
+# Swap tokens
+minara swap
+
+# View trending tokens
+minara discover trending
+```
+
+## Commands
+
+### Auth & Account
+
+| Command | Description |
+|---------|-------------|
+| `minara login` | Login via email, Google, or Apple ID |
+| `minara logout` | Logout and clear local credentials |
+| `minara account` | View your account info and wallet addresses |
+
+```bash
+minara login                  # Interactive method selection
+minara login -e user@mail.com # Email verification code
+minara login --google         # Google OAuth (opens browser)
+minara login --apple          # Apple ID (opens browser)
+```
+
+### Wallet & Funds
+
+| Command | Description |
+|---------|-------------|
+| `minara assets` | View wallet balances across all chains |
+| `minara deposit` | Show deposit addresses and supported networks |
+| `minara withdraw` | Withdraw tokens to an external wallet |
+
+```bash
+minara deposit
+minara withdraw -c solana -t <token> -a 10 --to <address>
+minara withdraw   # Interactive mode
+```
+
+### Spot Trading
+
+| Command | Description |
+|---------|-------------|
+| `minara swap` | Swap tokens (cross-chain) |
+| `minara transfer` | Transfer tokens to another address |
+
+```bash
+minara swap                        # Interactive
+minara swap -c solana -s buy -t <token> -a 100
+minara swap --dry-run              # Simulate without executing
+```
+
+### Perpetual Futures
+
+| Command | Description |
+|---------|-------------|
+| `minara perps deposit` | Deposit USDC to Hyperliquid perps account |
+| `minara perps withdraw` | Withdraw USDC from perps account |
+| `minara perps positions` | View all open positions |
+| `minara perps order` | Place an order (interactive builder) |
+| `minara perps cancel` | Cancel open orders |
+| `minara perps leverage` | Update leverage for a symbol |
+| `minara perps trades` | View completed trade history |
+| `minara perps fund-records` | View fund deposit/withdrawal records |
+
+```bash
+minara perps deposit -a 100        # Deposit 100 USDC to perps
+minara perps withdraw -a 50        # Withdraw 50 USDC from perps
+minara perps positions             # List current positions
+minara perps order                 # Interactive: choose symbol, side, size, price
+minara perps leverage              # Interactive: set leverage for a trading pair
+```
+
+### Limit Orders
+
+| Command | Description |
+|---------|-------------|
+| `minara limit-order create` | Create a price-triggered limit order |
+| `minara limit-order list` | List all your limit orders |
+| `minara limit-order cancel <id>` | Cancel a specific order by ID |
+
+```bash
+minara limit-order create          # Interactive: token, price, side, amount, expiry
+minara limit-order list            # Show all orders with status
+minara limit-order cancel abc123   # Cancel order by ID
+```
+
+### Copy Trading
+
+| Command | Description |
+|---------|-------------|
+| `minara copy-trade create` | Create a new copy-trade bot |
+| `minara copy-trade list` | List all copy-trade bots |
+| `minara copy-trade start <id>` | Start a paused bot |
+| `minara copy-trade stop <id>` | Pause a running bot |
+| `minara copy-trade delete <id>` | Delete a bot permanently |
+
+```bash
+minara copy-trade create           # Interactive: target wallet, chain, amount, options
+minara copy-trade list             # Show all bots with status
+minara copy-trade start abc123     # Resume a paused bot
+minara copy-trade stop abc123      # Pause a running bot
+```
+
+### AI Chat
+
+| Command | Description |
+|---------|-------------|
+| `minara chat [message]` | Send a message (or enter interactive mode) |
+| `minara chat --list` | List all your conversations |
+| `minara chat --history <chatId>` | View messages in a conversation |
+
+```bash
+minara chat "What is the current BTC price?"   # Single question, streamed answer
+minara chat                                    # Enter interactive REPL mode
+minara chat --thinking "Analyze ETH outlook"   # Enable reasoning mode
+minara chat --deep-research "DeFi yield trends"# Deep research mode
+minara chat --list                             # List past conversations
+minara chat --history <chatId>                 # Replay a specific conversation
+```
+
+### Market Discovery
+
+| Command | Description |
+|---------|-------------|
+| `minara discover trending` | View currently trending tokens |
+| `minara discover search <keyword>` | Search for tokens or stocks by name |
+| `minara discover fear-greed` | View the crypto Fear & Greed Index |
+| `minara discover btc-metrics` | View Bitcoin on-chain and market metrics |
+
+```bash
+minara discover trending           # Top trending tokens right now
+minara discover search SOL         # Search for tokens matching "SOL"
+minara discover fear-greed         # Current market sentiment index
+minara discover btc-metrics        # Bitcoin hashrate, supply, dominance, etc.
+```
+
+### Configuration
+
+| Command | Description |
+|---------|-------------|
+| `minara config` | View or update CLI settings (e.g. API base URL) |
+
+## Supported Chains
+
+Ethereum, Base, Arbitrum, Optimism, Polygon, Avalanche, Solana, BSC, Berachain, Blast, Manta, Mode, Sonic, and more.
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Watch mode
+npm run dev
+
+# Run locally
+node dist/index.js --help
+
+# Link globally for testing
+npm link
+minara --help
+```
+
+## Testing
+
+Test suite built with [Vitest](https://vitest.dev/) — 119 tests covering unit, API, and command integration layers.
+
+```bash
+npm test                # Run all tests
+npm run test:watch      # Watch mode
+npm run test:coverage   # With coverage report
+```
+
+## Security
+
+- Credentials are stored in `~/.minara/credentials.json` with `0600` file permissions
+- The `~/.minara/` directory is created with `0700` permissions
+- Tokens are never logged or printed to the console
+- OAuth login uses a temporary local server that shuts down after the callback
+- Non-TTY environments (CI/pipes) skip interactive prompts and return errors directly
+
+## License
+
+[MIT](LICENSE)

package/bin/minara.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/index.js';

package/dist/api/auth.d.ts

@@ -0,0 +1,30 @@
+import type { EmailCodeDto, EmailVerifyDto, AuthUser, FavoriteTokensPayload, OAuthProvider } from '../types.js';
+/** Send email verification code */
+export declare function sendEmailCode(dto: EmailCodeDto): Promise<import("../types.js").ApiResponse<void>>;
+/** Verify email code → returns user + access_token */
+export declare function verifyEmailCode(dto: EmailVerifyDto): Promise<import("../types.js").ApiResponse<AuthUser>>;
+/** Get current user info */
+export declare function getCurrentUser(token: string): Promise<import("../types.js").ApiResponse<AuthUser>>;
+/** Logout */
+export declare function logout(token: string): Promise<import("../types.js").ApiResponse<void>>;
+/** Get OAuth authorization URL */
+export declare function getOAuthUrl(provider: OAuthProvider, redirectUri: string): Promise<import("../types.js").ApiResponse<{
+    url: string;
+}>>;
+/**
+ * Exchange OAuth callback params for an access token.
+ * Some providers require a separate exchange step.
+ */
+export declare function oauthCallback(provider: OAuthProvider, params: Record<string, string>): Promise<import("../types.js").ApiResponse<AuthUser>>;
+/** Delete account */
+export declare function deleteAccount(token: string): Promise<import("../types.js").ApiResponse<void>>;
+/** Get favorite tokens */
+export declare function getFavoriteTokens(token: string): Promise<import("../types.js").ApiResponse<{
+    tokens: string[];
+}>>;
+/** Add favorite tokens */
+export declare function addFavoriteTokens(token: string, payload: FavoriteTokensPayload): Promise<import("../types.js").ApiResponse<{
+    tokens: string[];
+}>>;
+/** Get invite history */
+export declare function getInviteHistory(token: string): Promise<import("../types.js").ApiResponse<unknown>>;

package/dist/api/auth.js

@@ -0,0 +1,46 @@
+import { get, post, del } from './client.js';
+/** Send email verification code */
+export function sendEmailCode(dto) {
+    return post('/auth/email/code', { body: dto });
+}
+/** Verify email code → returns user + access_token */
+export function verifyEmailCode(dto) {
+    return post('/auth/email/verify', { body: dto });
+}
+/** Get current user info */
+export function getCurrentUser(token) {
+    return get('/auth/me', { token });
+}
+/** Logout */
+export function logout(token) {
+    return post('/auth/logout', { token });
+}
+/** Get OAuth authorization URL */
+export function getOAuthUrl(provider, redirectUri) {
+    return get(`/auth/${provider}/authorize`, {
+        query: { redirect_uri: redirectUri },
+    });
+}
+/**
+ * Exchange OAuth callback params for an access token.
+ * Some providers require a separate exchange step.
+ */
+export function oauthCallback(provider, params) {
+    return get(`/auth/${provider}/callback`, { query: params });
+}
+/** Delete account */
+export function deleteAccount(token) {
+    return del('/auth/delete-account', { token });
+}
+/** Get favorite tokens */
+export function getFavoriteTokens(token) {
+    return get('/auth/favorite-tokens', { token });
+}
+/** Add favorite tokens */
+export function addFavoriteTokens(token, payload) {
+    return post('/auth/favorite-tokens', { token, body: payload });
+}
+/** Get invite history */
+export function getInviteHistory(token) {
+    return get('/auth/invite-history', { token });
+}

package/dist/api/chat.d.ts

@@ -0,0 +1,19 @@
+import type { ChatRequestDTO, ChatInfo, ChatMemory } from '../types.js';
+/** Send chat message — returns SSE stream (raw Response) */
+export declare function sendChatStream(token: string, dto: ChatRequestDTO): Promise<Response>;
+/** Stop a running chat */
+export declare function stopChat(token: string, messageId: string): Promise<import("../types.js").ApiResponse<void>>;
+/** List chats */
+export declare function listChats(token: string, limit?: number, offset?: number): Promise<import("../types.js").ApiResponse<ChatInfo[]>>;
+/** Get chat detail */
+export declare function getChat(token: string, chatId: string): Promise<import("../types.js").ApiResponse<ChatInfo>>;
+/** Get chat memories (messages) */
+export declare function getMemories(token: string, chatId: string, limit?: number, nextCursor?: string): Promise<import("../types.js").ApiResponse<ChatMemory[]>>;
+/** Update chat name */
+export declare function updateChatName(token: string, chatId: string, name: string): Promise<import("../types.js").ApiResponse<void>>;
+/** Delete chat */
+export declare function deleteChat(token: string, chatId: string): Promise<import("../types.js").ApiResponse<void>>;
+/** Search chats */
+export declare function searchChats(token: string, query: string, limit?: number, offset?: number): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Get available chat models */
+export declare function getChatModels(token: string): Promise<import("../types.js").ApiResponse<unknown>>;

package/dist/api/chat.js

@@ -0,0 +1,54 @@
+import { get, post, put, del } from './client.js';
+import { loadConfig } from '../config.js';
+/** Send chat message — returns SSE stream (raw Response) */
+export async function sendChatStream(token, dto) {
+    const config = loadConfig();
+    const base = config.baseUrl.replace(/\/$/, '');
+    const url = `${base}/v1/chat`;
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Accept': 'text/event-stream',
+            'Authorization': `Bearer ${token}`,
+            'origin': 'https://minara.ai',
+        },
+        body: JSON.stringify(dto),
+    });
+    return res;
+}
+/** Stop a running chat */
+export function stopChat(token, messageId) {
+    return post('/v1/chat/stop', { token, query: { messageId } });
+}
+/** List chats */
+export function listChats(token, limit = 20, offset = 0) {
+    return get('/v1/chats', { token, query: { limit, offset } });
+}
+/** Get chat detail */
+export function getChat(token, chatId) {
+    return get(`/v1/chat/${encodeURIComponent(chatId)}`, { token });
+}
+/** Get chat memories (messages) */
+export function getMemories(token, chatId, limit, nextCursor) {
+    return get(`/v1/chat/${encodeURIComponent(chatId)}/memories`, {
+        token,
+        query: { limit, nextCursor },
+    });
+}
+/** Update chat name */
+export function updateChatName(token, chatId, name) {
+    return put(`/v1/chat/${encodeURIComponent(chatId)}`, { token, body: { name } });
+}
+/** Delete chat */
+export function deleteChat(token, chatId) {
+    return del(`/v1/chat/${encodeURIComponent(chatId)}`, { token });
+}
+/** Search chats */
+export function searchChats(token, query, limit = 10, offset = 0) {
+    return get('/v1/chat/search', { token, query: { query, limit, offset } });
+}
+/** Get available chat models */
+export function getChatModels(token) {
+    return get('/v1/chat/models', { token });
+}

package/dist/api/client.d.ts

@@ -0,0 +1,16 @@
+import type { ApiResponse } from '../types.js';
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+interface RequestOptions {
+    method?: HttpMethod;
+    body?: unknown;
+    query?: Record<string, string | number | undefined>;
+    token?: string;
+    headers?: Record<string, string>;
+}
+export declare function request<T>(path: string, opts?: RequestOptions): Promise<ApiResponse<T>>;
+export declare function get<T>(path: string, opts?: Omit<RequestOptions, 'method'>): Promise<ApiResponse<T>>;
+export declare function post<T>(path: string, opts?: Omit<RequestOptions, 'method'>): Promise<ApiResponse<T>>;
+export declare function put<T>(path: string, opts?: Omit<RequestOptions, 'method'>): Promise<ApiResponse<T>>;
+export declare function del<T>(path: string, opts?: Omit<RequestOptions, 'method'>): Promise<ApiResponse<T>>;
+export declare function patch<T>(path: string, opts?: Omit<RequestOptions, 'method'>): Promise<ApiResponse<T>>;
+export {};

package/dist/api/client.js

@@ -0,0 +1,133 @@
+import { loadConfig } from '../config.js';
+function buildUrl(path, query) {
+    const config = loadConfig();
+    const base = config.baseUrl.replace(/\/$/, '');
+    const url = new URL(`${base}${path}`);
+    if (query) {
+        for (const [k, v] of Object.entries(query)) {
+            if (v !== undefined && v !== '') {
+                url.searchParams.set(k, String(v));
+            }
+        }
+    }
+    return url.toString();
+}
+// ── Core request implementation ───────────────────────────────────────────
+/**
+ * @param isRetry  When true, skip the 401 re-auth handler to prevent loops.
+ */
+async function requestImpl(path, opts, isRetry) {
+    const { method = 'GET', body, query, token, headers: extraHeaders } = opts;
+    const url = buildUrl(path, query);
+    const headers = {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        ...extraHeaders,
+    };
+    if (token) {
+        headers['Authorization'] = `Bearer ${token}`;
+    }
+    const init = { method, headers };
+    if (body && method !== 'GET') {
+        init.body = JSON.stringify(body);
+    }
+    try {
+        const res = await fetch(url, init);
+        // ── 401 interception ──────────────────────────────────────────────
+        // Only trigger when: (1) authenticated request, (2) not already a retry,
+        // (3) running in an interactive terminal (not piped / CI).
+        if (res.status === 401 && token && !isRetry) {
+            return handleAuthExpired(path, opts);
+        }
+        const text = await res.text();
+        let json;
+        try {
+            json = JSON.parse(text);
+        }
+        catch {
+            // non-JSON response
+            if (!res.ok) {
+                return { success: false, error: { code: res.status, message: text || res.statusText } };
+            }
+            return { success: true, data: text };
+        }
+        if (!res.ok) {
+            const errBody = json;
+            return {
+                success: false,
+                error: {
+                    code: res.status,
+                    message: (errBody.message ?? errBody.error ?? res.statusText),
+                },
+            };
+        }
+        // Adapt: if the API wraps data in { data: ... } or returns directly
+        const data = json.data ?? json;
+        return { success: true, data: data };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { success: false, error: { code: 0, message } };
+    }
+}
+// ── 401 handler ───────────────────────────────────────────────────────────
+/**
+ * Called when an authenticated request returns 401.
+ *
+ * - In a TTY (interactive terminal): prompts the user to re-login, then
+ *   retries the original request with the fresh token.
+ * - In a non-TTY (pipe / CI): returns a friendly error immediately.
+ *
+ * Uses dynamic `import()` for `auth-refresh.ts` to break the circular
+ * dependency chain: client → auth-refresh → api/auth → client.
+ */
+async function handleAuthExpired(path, opts) {
+    // Non-interactive environments: skip prompts
+    if (!process.stdin.isTTY) {
+        return {
+            success: false,
+            error: {
+                code: 401,
+                message: 'Session expired. Run `minara login` to refresh your credentials.',
+            },
+        };
+    }
+    try {
+        // Dynamic import — only loaded when needed, avoids circular deps
+        const { attemptReAuth } = await import('../auth-refresh.js');
+        const newToken = await attemptReAuth();
+        if (newToken) {
+            // Retry the original request with the new token (isRetry = true)
+            return requestImpl(path, { ...opts, token: newToken }, true);
+        }
+    }
+    catch {
+        // Module load failure or unexpected error — fall through
+    }
+    return {
+        success: false,
+        error: {
+            code: 401,
+            message: 'Session expired. Run `minara login` to refresh your credentials.',
+        },
+    };
+}
+// ── Public API ────────────────────────────────────────────────────────────
+export async function request(path, opts = {}) {
+    return requestImpl(path, opts, false);
+}
+export function get(path, opts) {
+    return request(path, { ...opts, method: 'GET' });
+}
+export function post(path, opts) {
+    return request(path, { ...opts, method: 'POST' });
+}
+export function put(path, opts) {
+    return request(path, { ...opts, method: 'PUT' });
+}
+export function del(path, opts) {
+    return request(path, { ...opts, method: 'DELETE' });
+}
+export function patch(path, opts) {
+    return request(path, { ...opts, method: 'PATCH' });
+}

package/dist/api/copytrade.d.ts

@@ -0,0 +1,19 @@
+import type { CreateCopyTradeDto, UpdateCopyTradeDto, CopyTradeInfo } from '../types.js';
+/** Create copy trade */
+export declare function createCopyTrade(token: string, dto: CreateCopyTradeDto): Promise<import("../types.js").ApiResponse<CopyTradeInfo>>;
+/** List user's copy trades */
+export declare function listCopyTrades(token: string): Promise<import("../types.js").ApiResponse<CopyTradeInfo[]>>;
+/** Get copy trade by ID */
+export declare function getCopyTrade(token: string, id: string): Promise<import("../types.js").ApiResponse<CopyTradeInfo>>;
+/** Update copy trade */
+export declare function updateCopyTrade(token: string, id: string, dto: UpdateCopyTradeDto): Promise<import("../types.js").ApiResponse<CopyTradeInfo>>;
+/** Delete copy trade */
+export declare function deleteCopyTrade(token: string, id: string): Promise<import("../types.js").ApiResponse<void>>;
+/** Start copy trade */
+export declare function startCopyTrade(token: string, id: string): Promise<import("../types.js").ApiResponse<void>>;
+/** Stop copy trade */
+export declare function stopCopyTrade(token: string, id: string): Promise<import("../types.js").ApiResponse<void>>;
+/** Get copy trade activity */
+export declare function getCopyTradeActivity(token: string, id: string): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Get copy trade PnL chart */
+export declare function getCopyTradePnl(token: string, id: string): Promise<import("../types.js").ApiResponse<unknown>>;

package/dist/api/copytrade.js

@@ -0,0 +1,37 @@
+import { get, post, patch, del } from './client.js';
+/** Create copy trade */
+export function createCopyTrade(token, dto) {
+    return post('/copy-trade', { token, body: dto });
+}
+/** List user's copy trades */
+export function listCopyTrades(token) {
+    return get('/copy-trade', { token });
+}
+/** Get copy trade by ID */
+export function getCopyTrade(token, id) {
+    return get(`/copy-trade/${encodeURIComponent(id)}`, { token });
+}
+/** Update copy trade */
+export function updateCopyTrade(token, id, dto) {
+    return patch(`/copy-trade/${encodeURIComponent(id)}`, { token, body: dto });
+}
+/** Delete copy trade */
+export function deleteCopyTrade(token, id) {
+    return del(`/copy-trade/${encodeURIComponent(id)}`, { token });
+}
+/** Start copy trade */
+export function startCopyTrade(token, id) {
+    return patch(`/copy-trade/${encodeURIComponent(id)}/start`, { token });
+}
+/** Stop copy trade */
+export function stopCopyTrade(token, id) {
+    return patch(`/copy-trade/${encodeURIComponent(id)}/stop`, { token });
+}
+/** Get copy trade activity */
+export function getCopyTradeActivity(token, id) {
+    return get(`/copy-trade/${encodeURIComponent(id)}/activity`, { token });
+}
+/** Get copy trade PnL chart */
+export function getCopyTradePnl(token, id) {
+    return get(`/copy-trade/${encodeURIComponent(id)}/pnl/chart`, { token });
+}

package/dist/api/crosschain.d.ts

@@ -0,0 +1,19 @@
+import type { CrossChainSwapDto, CrossChainTransferDto, CrossChainActivitiesDto } from '../types.js';
+/** Get cross-chain account info */
+export declare function getAccount(token: string): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Get wallet assets */
+export declare function getAssets(token: string): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Execute a single swap */
+export declare function swap(token: string, dto: CrossChainSwapDto): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Execute multiple swaps */
+export declare function swaps(token: string, swapList: CrossChainSwapDto[]): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Simulate swaps (dry-run) */
+export declare function swapsSimulate(token: string, swapList: CrossChainSwapDto[]): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Transfer tokens */
+export declare function transfer(token: string, dto: CrossChainTransferDto): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Get activities */
+export declare function getActivities(token: string, dto: CrossChainActivitiesDto): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Get PnL history */
+export declare function getPnlHistory(token: string, type: string): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Check transaction statuses */
+export declare function getStatuses(token: string, transactionIds: string[]): Promise<import("../types.js").ApiResponse<unknown>>;

package/dist/api/crosschain.js

@@ -0,0 +1,43 @@
+import { get, post } from './client.js';
+/** Get cross-chain account info */
+export function getAccount(token) {
+    return get('/v1/tx/cross-chain/account', { token });
+}
+/** Get wallet assets */
+export function getAssets(token) {
+    return get('/v1/tx/cross-chain/assets', { token });
+}
+/** Execute a single swap */
+export function swap(token, dto) {
+    return post('/v1/tx/cross-chain/swap', { token, body: dto });
+}
+/** Execute multiple swaps */
+export function swaps(token, swapList) {
+    return post('/v1/tx/cross-chain/swaps', {
+        token,
+        body: { swaps: swapList },
+    });
+}
+/** Simulate swaps (dry-run) */
+export function swapsSimulate(token, swapList) {
+    return post('/v1/tx/cross-chain/swaps-simulate', {
+        token,
+        body: { swaps: swapList },
+    });
+}
+/** Transfer tokens */
+export function transfer(token, dto) {
+    return post('/v1/tx/cross-chain/transfer', { token, body: dto });
+}
+/** Get activities */
+export function getActivities(token, dto) {
+    return post('/v1/tx/cross-chain/activities', { token, body: dto });
+}
+/** Get PnL history */
+export function getPnlHistory(token, type) {
+    return get('/v1/tx/cross-chain/pnl/history', { token, query: { type } });
+}
+/** Check transaction statuses */
+export function getStatuses(token, transactionIds) {
+    return post('/v1/tx/cross-chain/statuses', { token, body: { transactionIds } });
+}