@vultisig/rujira 1.0.0

package/dist/modules/deposit.js

@@ -0,0 +1,233 @@
+/**
+ * Deposit module for securing L1 assets on THORChain
+ * @module modules/deposit
+ */
+import { findAssetByFormat } from '../assets/index.js';
+import { CHAIN_PROCESSING_TIMES } from '../config.js';
+import { RujiraError, RujiraErrorCode, wrapError } from '../errors.js';
+import { denomToAsset as sharedDenomToAsset, extractSymbol as sharedExtractSymbol, parseAsset as sharedParseAsset, } from '../utils/denom-conversion.js';
+import { fromBaseUnits } from '../utils/format.js';
+import { buildSecureMintMemo, validateMemoComponent } from '../utils/memo.js';
+import { thornodeRateLimiter } from '../utils/rate-limiter.js';
+import { isFinAsset } from '../utils/type-guards.js';
+import { validateThorAddress as validateThorAddressStrict } from '../validation/address-validator.js';
+// MODULE
+/**
+ * Deposit module for securing L1 assets on THORChain
+ *
+ * @example
+ * ```typescript
+ * const client = new RujiraClient({ network: 'mainnet' });
+ *
+ * // Prepare a BTC deposit
+ * const deposit = await client.deposit.prepare({
+ *   fromAsset: 'BTC.BTC',
+ *   amount: '1000000',  // 0.01 BTC in sats
+ *   thorAddress: 'thor1...'
+ * });
+ *
+ * // Use the returned details to send an L1 transaction
+ * console.log(`Send ${deposit.amount} to ${deposit.inboundAddress}`);
+ * console.log(`With memo: ${deposit.memo}`);
+ * ```
+ */
+export class RujiraDeposit {
+    constructor(client) {
+        this.client = client;
+        this.inboundCache = null;
+        // Short TTL: inbound addresses change during vault churn
+        this.CACHE_TTL_MS = 15000; // 15 seconds
+        this.thornodeUrl = client.config.restEndpoint;
+    }
+    // PUBLIC API
+    /**
+     * Prepare a deposit transaction
+     * Returns all details needed to send an L1 transaction
+     */
+    async prepare(params) {
+        // Validate inputs
+        this.validateDepositParams(params);
+        // Parse asset to get chain
+        const { chain } = sharedParseAsset(params.fromAsset);
+        // Get inbound address for the chain
+        const inbound = await this.getInboundAddress(chain);
+        if (!inbound) {
+            throw new RujiraError(RujiraErrorCode.INVALID_ASSET, `No inbound address available for chain: ${chain}`);
+        }
+        // Build the deposit memo
+        const memo = this.buildDepositMemo(params.thorAddress, params.affiliate, params.affiliateBps);
+        // Determine resulting secured denom on THORChain (FIN denom when known)
+        let resultingDenom = params.fromAsset.toLowerCase().replace('.', '-');
+        const assetData = findAssetByFormat(params.fromAsset);
+        if (isFinAsset(assetData)) {
+            resultingDenom = assetData.formats.fin;
+        }
+        // Build warning if applicable
+        let warning;
+        if (inbound.halted) {
+            warning = `Chain ${chain} is currently halted. Deposits will not be processed.`;
+        }
+        else if (inbound.chain_trading_paused) {
+            warning = `Trading is paused for ${chain}. Deposits may be delayed.`;
+        }
+        else if (inbound.global_trading_paused) {
+            warning = 'Global trading is paused. Deposits may be delayed.';
+        }
+        return {
+            chain,
+            inboundAddress: inbound.address,
+            memo,
+            amount: params.amount,
+            asset: params.fromAsset,
+            resultingDenom,
+            estimatedTimeMinutes: this.estimateDepositTime(chain),
+            minimumAmount: inbound.dust_threshold,
+            gasRate: inbound.gas_rate,
+            gasRateUnits: inbound.gas_rate_units,
+            warning,
+        };
+    }
+    /**
+     * Get secured balances for a THORChain address
+     */
+    async getBalances(thorAddress) {
+        this.validateThorAddress(thorAddress);
+        try {
+            const response = await thornodeRateLimiter.fetch(`${this.thornodeUrl}/cosmos/bank/v1beta1/balances/${thorAddress}`);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const data = (await response.json());
+            const balances = [];
+            for (const balance of data.balances || []) {
+                // Map denom back to asset (best effort)
+                const asset = sharedDenomToAsset(balance.denom);
+                // THORChain secured assets always use 8 decimals for storage
+                const decimals = 8;
+                const formatted = fromBaseUnits(balance.amount, decimals);
+                const symbol = sharedExtractSymbol(asset || balance.denom);
+                balances.push({
+                    denom: balance.denom,
+                    asset: asset || balance.denom,
+                    amount: balance.amount,
+                    formatted,
+                    decimals,
+                    symbol,
+                });
+            }
+            return balances;
+        }
+        catch (error) {
+            throw wrapError(error, RujiraErrorCode.NETWORK_ERROR);
+        }
+    }
+    /**
+     * Get balance for a specific asset
+     */
+    async getBalance(thorAddress, asset) {
+        const balances = await this.getBalances(thorAddress);
+        // Try to find by FIN denom from registry
+        const assetData = findAssetByFormat(asset);
+        if (isFinAsset(assetData)) {
+            return balances.find(b => b.denom === assetData.formats.fin) || null;
+        }
+        // Fallback to computed denom
+        const denom = asset.toLowerCase().replace('.', '-');
+        return balances.find(b => b.denom === denom) || null;
+    }
+    /**
+     * Get inbound address for a specific chain
+     */
+    async getInboundAddress(chain) {
+        const addresses = await this.getInboundAddresses();
+        return addresses.find(a => a.chain === chain.toUpperCase()) || null;
+    }
+    /**
+     * Get all inbound addresses
+     * @param forceRefresh Bypass cache and fetch fresh data (use before executing deposits)
+     */
+    async getInboundAddresses(forceRefresh = false) {
+        // Check cache (skip if forceRefresh)
+        if (!forceRefresh && this.inboundCache && Date.now() - this.inboundCache.timestamp < this.CACHE_TTL_MS) {
+            return this.inboundCache.data;
+        }
+        try {
+            const response = await thornodeRateLimiter.fetch(`${this.thornodeUrl}/thorchain/inbound_addresses`);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const data = (await response.json());
+            // Cache the result
+            this.inboundCache = {
+                data,
+                timestamp: Date.now(),
+            };
+            return data;
+        }
+        catch (error) {
+            throw wrapError(error, RujiraErrorCode.NETWORK_ERROR);
+        }
+    }
+    /**
+     * Build deposit memo for L1 transaction
+     */
+    buildDepositMemo(thorAddress, affiliate, affiliateBps) {
+        // Format: secure+:THORADDR for L1 → Secured deposits
+        // This mints secured assets on THORChain without swapping
+        let memo = buildSecureMintMemo(thorAddress);
+        if (affiliate && affiliateBps !== undefined && affiliateBps > 0) {
+            validateMemoComponent(affiliate, 'affiliate');
+            memo += `:${affiliate}:${affiliateBps}`;
+        }
+        return memo;
+    }
+    /**
+     * Estimate deposit confirmation time in minutes
+     */
+    estimateDepositTime(chain) {
+        return CHAIN_PROCESSING_TIMES[chain.toUpperCase()] || 15;
+    }
+    /**
+     * Get supported chains for deposits
+     */
+    getSupportedChains() {
+        return Object.keys(CHAIN_PROCESSING_TIMES);
+    }
+    /**
+     * Check if a chain is supported
+     */
+    isChainSupported(chain) {
+        return chain.toUpperCase() in CHAIN_PROCESSING_TIMES;
+    }
+    /**
+     * Check if an asset can be deposited
+     */
+    canDeposit(asset) {
+        const { chain } = sharedParseAsset(asset);
+        return this.isChainSupported(chain);
+    }
+    // INTERNAL HELPERS
+    validateDepositParams(params) {
+        // Validate asset
+        if (!params.fromAsset || !params.fromAsset.includes('.')) {
+            throw new RujiraError(RujiraErrorCode.INVALID_ASSET, `Invalid asset format: ${params.fromAsset}. Expected format: CHAIN.SYMBOL`);
+        }
+        const { chain } = sharedParseAsset(params.fromAsset);
+        if (!this.isChainSupported(chain)) {
+            throw new RujiraError(RujiraErrorCode.INVALID_ASSET, `Unsupported chain: ${chain}. Supported: ${this.getSupportedChains().join(', ')}`);
+        }
+        // Validate amount
+        if (!params.amount || !/^\d+$/.test(params.amount)) {
+            throw new RujiraError(RujiraErrorCode.INVALID_AMOUNT, 'Amount must be a positive integer in base units');
+        }
+        const amountBigInt = BigInt(params.amount);
+        if (amountBigInt <= 0n) {
+            throw new RujiraError(RujiraErrorCode.INVALID_AMOUNT, 'Amount must be greater than zero');
+        }
+        // Validate thor address
+        this.validateThorAddress(params.thorAddress);
+    }
+    validateThorAddress(address) {
+        validateThorAddressStrict(address);
+    }
+}

package/dist/modules/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Module exports
+ * @module modules
+ */
+export { RujiraAssets } from './assets.js';
+export { RujiraDeposit } from './deposit.js';
+export { RujiraOrderbook } from './orderbook.js';
+export { RujiraSwap } from './swap.js';
+export { RujiraWithdraw } from './withdraw.js';
+export type { DepositParams, InboundAddress, PreparedDeposit, SecuredBalance } from './deposit.js';
+export type { PreparedWithdraw, WithdrawParams, WithdrawResult } from './withdraw.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/modules/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/modules/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AACtC,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAG9C,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAGlG,YAAY,EAAE,gBAAgB,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA"}

package/dist/modules/index.js

@@ -0,0 +1,9 @@
+/**
+ * Module exports
+ * @module modules
+ */
+export { RujiraAssets } from './assets.js';
+export { RujiraDeposit } from './deposit.js';
+export { RujiraOrderbook } from './orderbook.js';
+export { RujiraSwap } from './swap.js';
+export { RujiraWithdraw } from './withdraw.js';

package/dist/modules/orderbook.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Orderbook module for limit orders on Rujira DEX
+ */
+import type { RujiraClient } from '../client.js';
+import type { LimitOrderParams, Order, OrderBook, OrderResult, OrderSide } from '../types.js';
+/**
+ * Orderbook module for managing limit orders.
+ *
+ * @example
+ * ```typescript
+ * const client = new RujiraClient({ network: 'mainnet', signer });
+ * await client.connect();
+ *
+ * const book = await client.orderbook.getOrderBook('RUNE/BTC');
+ * console.log('Best bid:', book.bids[0]?.price);
+ * console.log('Best ask:', book.asks[0]?.price);
+ *
+ * const order = await client.orderbook.placeOrder({
+ *   pair: 'RUNE/BTC',
+ *   side: 'buy',
+ *   price: '0.000025',
+ *   amount: '100000000',
+ * });
+ * ```
+ */
+export declare class RujiraOrderbook {
+    private readonly client;
+    constructor(client: RujiraClient);
+    /**
+     * Convenience alias used by older examples/tests.
+     *
+     * Accepts two asset identifiers (any format supported by the asset registry)
+     * and resolves the FIN contract key as "<baseDenom>/<quoteDenom>".
+     */
+    getBook(baseAsset: string, quoteAsset: string, limit?: number): Promise<OrderBook>;
+    /**
+     * Get the order book for a trading pair.
+     *
+     * @param pairOrContract - Trading pair string or contract address
+     * @param limit - Maximum entries per side (default: 50)
+     */
+    getOrderBook(pairOrContract: string, limit?: number): Promise<OrderBook>;
+    /**
+     * Get contract configuration including pair info.
+     * @internal
+     */
+    private getContractConfig;
+    /**
+     * Convert denom to asset identifier.
+     * @internal
+     */
+    private denomToAsset;
+    /**
+     * Place a limit order.
+     */
+    placeOrder(params: LimitOrderParams): Promise<OrderResult>;
+    /**
+     * Cancel an open order.
+     */
+    cancelOrder(contractAddress: string, side: OrderSide, price: string): Promise<{
+        txHash: string;
+    }>;
+    /**
+     * Get user's open orders.
+     */
+    getOrders(contractAddress: string, owner?: string, side?: OrderSide, limit?: number, offset?: number): Promise<Order[]>;
+    /**
+     * Get a specific order.
+     */
+    getOrder(contractAddress: string, owner: string, side: OrderSide, price: string): Promise<Order | null>;
+    private resolveContract;
+    /**
+     * Uses string-based decimal arithmetic to avoid floating-point precision loss.
+     */
+    private transformBookEntries;
+    private validateOrderParams;
+    private getOfferAsset;
+    private calculateOfferAmount;
+}
+//# sourceMappingURL=orderbook.d.ts.map

package/dist/modules/orderbook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orderbook.d.ts","sourceRoot":"","sources":["../../src/modules/orderbook.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAGhD,OAAO,KAAK,EAIV,gBAAgB,EAChB,KAAK,EACL,SAAS,EAET,WAAW,EACX,SAAS,EACV,MAAM,aAAa,CAAA;AAIpB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,eAAe;IACd,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,YAAY;IAEjD;;;;;OAKG;IACG,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,OAAO,CAAC,SAAS,CAAC;IAcpF;;;;;OAKG;IACG,YAAY,CAAC,cAAc,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,OAAO,CAAC,SAAS,CAAC;IAuC1E;;;OAGG;YACW,iBAAiB;IAiC/B;;;OAGG;IACH,OAAO,CAAC,YAAY;IAIpB;;OAEG;IACG,UAAU,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,WAAW,CAAC;IAsDhE;;OAEG;IACG,WAAW,CAAC,eAAe,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAcvG;;OAEG;IACG,SAAS,CAAC,eAAe,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,SAAS,EAAE,KAAK,SAAK,EAAE,MAAM,SAAI,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;IAiEpH;;OAEG;IACG,QAAQ,CAAC,eAAe,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;YAgD/F,eAAe;IAa7B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAsB5B,OAAO,CAAC,mBAAmB;YAcb,aAAa;IAyB3B,OAAO,CAAC,oBAAoB;CAS7B"}

package/dist/modules/orderbook.js

@@ -0,0 +1,320 @@
+/**
+ * Orderbook module for limit orders on Rujira DEX
+ */
+import Big from 'big.js';
+import { findAssetByFormat } from '../assets/index.js';
+import { DEFAULT_MAKER_FEE, DEFAULT_TAKER_FEE } from '../config/constants.js';
+import { RujiraError, RujiraErrorCode } from '../errors.js';
+import { fromContractSide, toContractSide } from '../types.js';
+import { denomToAsset as sharedDenomToAsset } from '../utils/denom-conversion.js';
+/**
+ * Orderbook module for managing limit orders.
+ *
+ * @example
+ * ```typescript
+ * const client = new RujiraClient({ network: 'mainnet', signer });
+ * await client.connect();
+ *
+ * const book = await client.orderbook.getOrderBook('RUNE/BTC');
+ * console.log('Best bid:', book.bids[0]?.price);
+ * console.log('Best ask:', book.asks[0]?.price);
+ *
+ * const order = await client.orderbook.placeOrder({
+ *   pair: 'RUNE/BTC',
+ *   side: 'buy',
+ *   price: '0.000025',
+ *   amount: '100000000',
+ * });
+ * ```
+ */
+export class RujiraOrderbook {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Convenience alias used by older examples/tests.
+     *
+     * Accepts two asset identifiers (any format supported by the asset registry)
+     * and resolves the FIN contract key as "<baseDenom>/<quoteDenom>".
+     */
+    async getBook(baseAsset, quoteAsset, limit = 10) {
+        const base = findAssetByFormat(baseAsset);
+        const quote = findAssetByFormat(quoteAsset);
+        const baseDenom = base?.formats?.fin;
+        const quoteDenom = quote?.formats?.fin;
+        if (!baseDenom || !quoteDenom) {
+            throw new RujiraError(RujiraErrorCode.INVALID_ASSET, `Unknown asset(s): ${baseAsset}, ${quoteAsset}`);
+        }
+        return this.getOrderBook(`${baseDenom}/${quoteDenom}`, limit);
+    }
+    /**
+     * Get the order book for a trading pair.
+     *
+     * @param pairOrContract - Trading pair string or contract address
+     * @param limit - Maximum entries per side (default: 50)
+     */
+    async getOrderBook(pairOrContract, limit = 50) {
+        const contractAddress = await this.resolveContract(pairOrContract);
+        const [response, config] = await Promise.all([
+            this.client.getOrderBook(contractAddress, limit),
+            this.getContractConfig(contractAddress),
+        ]);
+        const bids = this.transformBookEntries(response.base, 'desc');
+        const asks = this.transformBookEntries(response.quote, 'asc');
+        const bestBid = bids[0]?.price ? parseFloat(bids[0].price) : 0;
+        const bestAsk = asks[0]?.price ? parseFloat(asks[0].price) : 0;
+        let spread = '0';
+        if (bestBid > 0 && bestAsk > 0) {
+            const midPrice = (bestAsk + bestBid) / 2;
+            spread = (((bestAsk - bestBid) / midPrice) * 100).toFixed(4);
+        }
+        const lastPrice = config.lastPrice || bids[0]?.price || asks[0]?.price || '0';
+        return {
+            pair: {
+                base: config.base,
+                quote: config.quote,
+                contractAddress,
+                tick: config.tick || '0',
+                takerFee: config.takerFee || DEFAULT_TAKER_FEE,
+                makerFee: config.makerFee || DEFAULT_MAKER_FEE,
+            },
+            bids,
+            asks,
+            spread,
+            lastPrice,
+            timestamp: Date.now(),
+        };
+    }
+    /**
+     * Get contract configuration including pair info.
+     * @internal
+     */
+    async getContractConfig(contractAddress) {
+        try {
+            const query = { config: {} };
+            const response = await this.client.queryContract(contractAddress, query);
+            const base = this.denomToAsset(response.denoms.base);
+            const quote = this.denomToAsset(response.denoms.quote);
+            return {
+                base,
+                quote,
+                tick: response.tick,
+                takerFee: response.fee?.taker,
+                makerFee: response.fee?.maker,
+                lastPrice: response.last_price,
+            };
+        }
+        catch {
+            return { base: '', quote: '' };
+        }
+    }
+    /**
+     * Convert denom to asset identifier.
+     * @internal
+     */
+    denomToAsset(denom) {
+        return sharedDenomToAsset(denom) ?? denom.toUpperCase();
+    }
+    /**
+     * Place a limit order.
+     */
+    async placeOrder(params) {
+        this.validateOrderParams(params);
+        const contractAddress = await this.resolveContract(typeof params.pair === 'string' ? params.pair : params.pair.contractAddress);
+        const assetInfo = await this.getOfferAsset(params);
+        if (!assetInfo) {
+            throw new RujiraError(RujiraErrorCode.INVALID_ASSET, 'Could not determine offer asset for order');
+        }
+        // Convert SDK side to contract's Side enum format
+        const contractSide = toContractSide(params.side);
+        const orderTarget = [contractSide, params.price, params.amount];
+        const msg = {
+            order: [[orderTarget], null],
+        };
+        const funds = [
+            {
+                denom: assetInfo.denom,
+                amount: this.calculateOfferAmount(params),
+            },
+        ];
+        const result = await this.client.executeContract(contractAddress, msg, funds);
+        const orderId = `${result.transactionHash}-0`;
+        return {
+            orderId,
+            txHash: result.transactionHash,
+            order: {
+                orderId,
+                owner: await this.client.getAddress(),
+                pair: typeof params.pair === 'string'
+                    ? { base: '', quote: '', contractAddress, tick: '0', takerFee: '0', makerFee: '0' }
+                    : params.pair,
+                side: params.side,
+                price: params.price,
+                amount: params.amount,
+                filled: '0',
+                remaining: params.amount,
+                status: 'open',
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            },
+        };
+    }
+    /**
+     * Cancel an open order.
+     */
+    async cancelOrder(contractAddress, side, price) {
+        // Convert SDK side to contract's Side enum format
+        const contractSide = toContractSide(side);
+        const orderTarget = [contractSide, price, null];
+        const msg = {
+            order: [[orderTarget], null],
+        };
+        const result = await this.client.executeContract(contractAddress, msg, []);
+        return { txHash: result.transactionHash };
+    }
+    /**
+     * Get user's open orders.
+     */
+    async getOrders(contractAddress, owner, side, limit = 30, offset = 0) {
+        const address = owner || (await this.client.getAddress());
+        // Convert SDK side to contract side for query
+        const contractSide = side ? toContractSide(side) : undefined;
+        const query = {
+            orders: {
+                owner: address,
+                side: contractSide,
+                offset,
+                limit,
+            },
+        };
+        const response = await this.client.queryContract(contractAddress, query);
+        return response.orders.map((o) => {
+            // Convert contract side back to SDK side
+            const sdkSide = fromContractSide(o.side);
+            return {
+                orderId: `${address}-${o.side}-${o.price}`,
+                owner: o.owner,
+                pair: {
+                    base: '',
+                    quote: '',
+                    contractAddress,
+                    tick: '0',
+                    takerFee: '0',
+                    makerFee: '0',
+                },
+                side: sdkSide,
+                price: o.price,
+                amount: o.offer,
+                filled: o.filled,
+                remaining: o.remaining,
+                status: BigInt(o.remaining) === 0n ? 'filled' : BigInt(o.filled) > 0n ? 'partial' : 'open',
+                createdAt: parseInt(o.updated_at),
+                updatedAt: parseInt(o.updated_at),
+            };
+        });
+    }
+    /**
+     * Get a specific order.
+     */
+    async getOrder(contractAddress, owner, side, price) {
+        // Convert SDK side to contract side for query
+        const contractSide = toContractSide(side);
+        const query = {
+            order: [owner, contractSide, price],
+        };
+        try {
+            const response = await this.client.queryContract(contractAddress, query);
+            // Convert contract side back to SDK side
+            const sdkSide = fromContractSide(response.side);
+            return {
+                orderId: `${owner}-${response.side}-${price}`,
+                owner: response.owner,
+                pair: {
+                    base: '',
+                    quote: '',
+                    contractAddress,
+                    tick: '0',
+                    takerFee: '0',
+                    makerFee: '0',
+                },
+                side: sdkSide,
+                price: response.price,
+                amount: response.offer,
+                filled: response.filled,
+                remaining: response.remaining,
+                status: BigInt(response.remaining) === 0n ? 'filled' : BigInt(response.filled) > 0n ? 'partial' : 'open',
+                createdAt: parseInt(response.updated_at),
+                updatedAt: parseInt(response.updated_at),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async resolveContract(pairOrContract) {
+        if (pairOrContract.startsWith('thor1')) {
+            return pairOrContract;
+        }
+        const knownContracts = this.client.config.contracts.finContracts;
+        if (knownContracts[pairOrContract]) {
+            return knownContracts[pairOrContract];
+        }
+        throw new RujiraError(RujiraErrorCode.INVALID_PAIR, `Unknown trading pair: ${pairOrContract}`);
+    }
+    /**
+     * Uses string-based decimal arithmetic to avoid floating-point precision loss.
+     */
+    transformBookEntries(entries, sortOrder) {
+        const transformed = entries.map(e => {
+            const price = Big(e.price);
+            const amount = Big(e.total);
+            return {
+                price: e.price,
+                amount: e.total,
+                total: price.mul(amount).toFixed(8),
+            };
+        });
+        return transformed.sort((a, b) => {
+            const pA = Big(a.price);
+            const pB = Big(b.price);
+            return sortOrder === 'asc' ? pA.cmp(pB) : pB.cmp(pA);
+        });
+    }
+    validateOrderParams(params) {
+        if (!params.price || parseFloat(params.price) <= 0) {
+            throw new RujiraError(RujiraErrorCode.INVALID_PRICE, 'Order price must be positive');
+        }
+        if (!params.amount || BigInt(params.amount) <= 0n) {
+            throw new RujiraError(RujiraErrorCode.INVALID_AMOUNT, 'Order amount must be positive');
+        }
+        if (!['buy', 'sell'].includes(params.side)) {
+            throw new RujiraError(RujiraErrorCode.INVALID_AMOUNT, 'Order side must be "buy" or "sell"');
+        }
+    }
+    async getOfferAsset(params) {
+        const getAssetInfo = (assetId) => {
+            const asset = findAssetByFormat(assetId);
+            if (!asset?.formats?.fin)
+                return undefined;
+            return { denom: asset.formats.fin, decimals: asset.decimals?.fin ?? 8 };
+        };
+        if (typeof params.pair !== 'string' && params.pair.base && params.pair.quote) {
+            const assetId = params.side === 'buy' ? params.pair.quote : params.pair.base;
+            return getAssetInfo(assetId);
+        }
+        const contractAddress = await this.resolveContract(typeof params.pair === 'string' ? params.pair : params.pair.contractAddress);
+        const config = await this.getContractConfig(contractAddress);
+        if (params.side === 'buy') {
+            return config.quote ? getAssetInfo(config.quote) : getAssetInfo('THOR.RUNE');
+        }
+        return config.base ? getAssetInfo(config.base) : undefined;
+    }
+    calculateOfferAmount(params) {
+        if (params.side === 'buy') {
+            const amount = Big(params.amount);
+            const price = Big(params.price);
+            return amount.mul(price).toFixed(0, 0);
+        }
+        return params.amount;
+    }
+}