@megatao/sdk 1.1.0

package/dist/contracts/viem/AlphaViem.js

@@ -0,0 +1,1287 @@
+"use strict";
+/**
+ * Alpha contract wrapper using Viem
+ * Main implementation of ALPHA perpetual futures protocol
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlphaViem = void 0;
+const viem_1 = require("viem");
+const Alpha_json_1 = __importDefault(require("../../abi/Alpha.json"));
+class AlphaViem {
+    constructor(contractAddress, publicClient, walletClient, collateralTokenAddress) {
+        this.contractAddress = contractAddress;
+        this.publicClient = publicClient;
+        this.walletClient = walletClient;
+        this.collateralTokenAddress = collateralTokenAddress;
+    }
+    get isNativeCollateral() {
+        return (!this.collateralTokenAddress ||
+            this.collateralTokenAddress === '0x0000000000000000000000000000000000000000');
+    }
+    // ============ Utility Functions ============
+    /**
+     * Convert bytes32 (padded by ABI encoding) to bytes16
+     * Takes first 16 bytes from the 32 byte value
+     */
+    bytes32ToBytes16(bytes32) {
+        // Remove 0x prefix if present
+        const hex = bytes32.startsWith('0x') ? bytes32.slice(2) : bytes32;
+        // Take first 32 characters (16 bytes)
+        const bytes16Hex = hex.slice(0, 32);
+        return `0x${bytes16Hex}`;
+    }
+    /**
+     * Simulate a contract transaction before writing to catch errors early
+     * This prevents sending failed transactions to the wallet
+     */
+    async simulateAndWriteContract(writeParams) {
+        if (!this.walletClient) {
+            throw new Error('Wallet client required for write operations');
+        }
+        if (!this.walletClient.account) {
+            throw new Error('Wallet client must have an account for transactions');
+        }
+        // Simulate the transaction first to catch errors early
+        try {
+            await this.publicClient.simulateContract({
+                address: writeParams.address,
+                abi: writeParams.abi,
+                functionName: writeParams.functionName,
+                args: writeParams.args,
+                account: this.walletClient.account.address,
+                value: writeParams.value,
+            });
+        }
+        catch (simulationError) {
+            console.error('[simulateContract] Raw viem error:', simulationError);
+            let errorMessage = 'Transaction simulation failed';
+            let errorName;
+            let errorArgs;
+            // Walk the viem error chain to find decoded custom error data
+            for (let cur = simulationError; cur; cur = cur.cause) {
+                if (cur.data?.errorName) {
+                    errorName = cur.data.errorName;
+                    errorArgs = cur.data.args ? [...cur.data.args] : undefined;
+                    errorMessage = errorName;
+                    if (errorArgs && errorArgs.length > 0) {
+                        errorMessage += `: ${errorArgs
+                            .map((arg) => (typeof arg === 'bigint' ? arg.toString() : String(arg)))
+                            .join(', ')}`;
+                    }
+                    break;
+                }
+            }
+            // If no decoded error found, fall back to message extraction
+            if (!errorName) {
+                if (simulationError.cause?.shortMessage) {
+                    errorMessage = simulationError.cause.shortMessage;
+                }
+                else if (simulationError.shortMessage) {
+                    errorMessage = simulationError.shortMessage;
+                }
+                else if (simulationError.cause?.message) {
+                    errorMessage = simulationError.cause.message;
+                }
+                else if (simulationError.message) {
+                    errorMessage = simulationError.message;
+                }
+            }
+            const error = new Error(errorMessage);
+            error.code = 'SIMULATION_FAILED';
+            error.cause = simulationError;
+            error.simulationError = true;
+            error.contractErrorName = errorName;
+            error.contractErrorArgs = errorArgs;
+            throw error;
+        }
+        // If simulation succeeds, proceed with the actual write
+        // Note: writeContract needs the full account object, not just the address
+        return await this.walletClient.writeContract({
+            ...writeParams,
+            account: this.walletClient.account,
+        });
+    }
+    // ============ Admin Functions ============
+    async initializeMarket(market, maxLeverage, maintenanceMargin, liquidationFee, options) {
+        if (!this.walletClient)
+            throw new Error('Wallet client required for write operations');
+        const { waitForConfirmation, ...txOptions } = options || {};
+        if (!this.walletClient.account) {
+            throw new Error('Wallet client must have an account for transactions');
+        }
+        const hash = await this.walletClient.writeContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'initializeMarket',
+            args: [market, maxLeverage, maintenanceMargin, liquidationFee],
+            account: this.walletClient.account,
+            ...txOptions,
+        });
+        if (waitForConfirmation) {
+            await this.publicClient.waitForTransactionReceipt({ hash });
+            return hash;
+        }
+        return hash;
+    }
+    async addMarket(market, symbol, options) {
+        if (!this.walletClient)
+            throw new Error('Wallet client required for write operations');
+        const { waitForConfirmation, ...txOptions } = options || {};
+        if (!this.walletClient.account) {
+            throw new Error('Wallet client must have an account for transactions');
+        }
+        const hash = await this.walletClient.writeContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'addMarket',
+            args: [market, symbol],
+            account: this.walletClient.account,
+            ...txOptions,
+        });
+        if (waitForConfirmation) {
+            await this.publicClient.waitForTransactionReceipt({ hash });
+            return hash;
+        }
+        return hash;
+    }
+    async seedVault(amount, options) {
+        if (!this.walletClient)
+            throw new Error('Wallet client required for write operations');
+        const { waitForConfirmation, ...txOptions } = options || {};
+        if (!this.walletClient.account) {
+            throw new Error('Wallet client must have an account for transactions');
+        }
+        const hash = await this.walletClient.writeContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'seedVault',
+            args: [amount],
+            account: this.walletClient.account,
+            ...txOptions,
+        });
+        if (waitForConfirmation) {
+            await this.publicClient.waitForTransactionReceipt({ hash });
+            return hash;
+        }
+        return hash;
+    }
+    // ============ Margin Management ============
+    async deposit(amount, options) {
+        const { waitForConfirmation, ...txOptions } = options || {};
+        if (!this.walletClient?.account) {
+            throw new Error('Wallet client must have an account for transactions');
+        }
+        const hash = await this.simulateAndWriteContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'deposit',
+            args: [amount],
+            account: this.walletClient.account.address,
+            ...(this.isNativeCollateral ? { value: amount } : {}),
+            ...txOptions,
+        });
+        if (waitForConfirmation) {
+            await this.publicClient.waitForTransactionReceipt({ hash });
+            return hash;
+        }
+        return hash;
+    }
+    async withdraw(amount, options) {
+        const { waitForConfirmation, ...txOptions } = options || {};
+        if (!this.walletClient?.account) {
+            throw new Error('Wallet client must have an account for transactions');
+        }
+        const hash = await this.simulateAndWriteContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'withdraw',
+            args: [amount],
+            account: this.walletClient.account.address,
+            ...txOptions,
+        });
+        if (waitForConfirmation) {
+            await this.publicClient.waitForTransactionReceipt({ hash });
+            return hash;
+        }
+        return hash;
+    }
+    // ============ Position Management ============
+    /**
+     * Opens a market position with specified margin, leverage, and slippage tolerance
+     * @param market - Market address
+     * @param isLong - True for long position, false for short
+     * @param margin - Collateral amount to risk (in wei)
+     * @param leverage - Leverage multiplier in 1e18 format (e.g., 3e18 for 3x)
+     * @param maxSlippage - Maximum allowed slippage in basis points
+     * @param options - Transaction options
+     * @returns Transaction hash
+     */
+    async openMarketPosition(market, isLong, margin, leverage, maxSlippage, options) {
+        const { waitForConfirmation, ...txOptions } = options || {};
+        if (!this.walletClient?.account) {
+            throw new Error('Wallet client must have an account for transactions');
+        }
+        // Contract expects a single struct parameter: MarketPositionParams
+        const params = {
+            market,
+            isLong,
+            margin,
+            leverage,
+            maxSlippage,
+        };
+        const hash = await this.simulateAndWriteContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'openMarketPosition',
+            args: [params],
+            account: this.walletClient.account.address,
+            ...txOptions,
+        });
+        if (waitForConfirmation) {
+            await this.publicClient.waitForTransactionReceipt({ hash });
+            return hash;
+        }
+        return hash;
+    }
+    async openMarketPositionWithStruct(params, options) {
+        if (!this.walletClient)
+            throw new Error('Wallet client required for write operations');
+        const { waitForConfirmation, ...txOptions } = options || {};
+        if (!this.walletClient.account) {
+            throw new Error('Wallet client must have an account for transactions');
+        }
+        const hash = await this.walletClient.writeContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'openMarketPositionWithStruct',
+            args: [params],
+            account: this.walletClient.account,
+            ...txOptions,
+        });
+        if (waitForConfirmation) {
+            await this.publicClient.waitForTransactionReceipt({ hash });
+            return hash;
+        }
+        return hash;
+    }
+    async closePosition(positionId, sizeToClose, options) {
+        const { waitForConfirmation, ...txOptions } = options || {};
+        if (!this.walletClient?.account) {
+            throw new Error('Wallet client must have an account for transactions');
+        }
+        const hash = await this.simulateAndWriteContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'closePosition',
+            args: [positionId, sizeToClose],
+            account: this.walletClient.account.address,
+            ...txOptions,
+        });
+        if (waitForConfirmation) {
+            await this.publicClient.waitForTransactionReceipt({ hash });
+            return hash;
+        }
+        return hash;
+    }
+    /**
+     * Batch multiple contract calls into a single transaction using multicall.
+     * Handles ABI encoding internally.
+     *
+     * @param calls - Array of { functionName, args } to batch
+     * @param options - Optional transaction options
+     * @returns Transaction hash
+     *
+     * @example
+     * // Close multiple positions in one tx
+     * await alpha.multicall([
+     *   { functionName: 'closePosition', args: [posId1, 0n] },
+     *   { functionName: 'closePosition', args: [posId2, 0n] },
+     * ]);
+     */
+    async multicall(calls, options) {
+        const { waitForConfirmation, ...txOptions } = options || {};
+        if (!this.walletClient?.account) {
+            throw new Error('Wallet client must have an account for transactions');
+        }
+        if (calls.length === 0) {
+            throw new Error('No calls provided');
+        }
+        const calldata = calls.map((call) => (0, viem_1.encodeFunctionData)({
+            abi: Alpha_json_1.default,
+            functionName: call.functionName,
+            args: call.args ?? [],
+        }));
+        const hash = await this.simulateAndWriteContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'multicall',
+            args: [calldata],
+            account: this.walletClient.account.address,
+            ...txOptions,
+        });
+        if (waitForConfirmation) {
+            await this.publicClient.waitForTransactionReceipt({ hash });
+        }
+        return hash;
+    }
+    /**
+     * Close multiple positions in a single transaction using multicall
+     * @param positionIds - Array of position IDs to close (bytes16 format)
+     * @param options - Optional transaction options
+     * @returns Transaction hash
+     */
+    async closeAllPositions(positionIds, options) {
+        if (positionIds.length === 0) {
+            throw new Error('No position IDs provided');
+        }
+        return this.multicall(positionIds.map((positionId) => ({
+            functionName: 'closePosition',
+            args: [positionId, 0n],
+        })), options);
+    }
+    // ============ Order Management ============
+    /**
+     * Places a limit order with specified margin and leverage
+     * @param market - Market address
+     * @param isBuy - True for buy order, false for sell
+     * @param margin - Collateral amount to risk
+     * @param leverage - Leverage multiplier in 1e18 format (e.g., 3e18 for 3x)
+     * @param price - Limit price in wei
+     * @param reduceOnlyType - 0=Normal, 1=TakeProfit (natural side), 2=StopLoss (opposite side)
+     * @param options - Transaction options
+     * @returns Transaction hash
+     */
+    async placeLimitOrder(market, isBuy, margin, leverage, price, reduceOnlyType = 0, options) {
+        const { waitForConfirmation, ...txOptions } = options || {};
+        if (!this.walletClient?.account) {
+            throw new Error('Wallet client must have an account for transactions');
+        }
+        const params = {
+            market,
+            isBuy,
+            margin,
+            leverage,
+            price,
+            reduceOnlyType,
+        };
+        const hash = await this.simulateAndWriteContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'placeLimitOrder',
+            args: [params],
+            account: this.walletClient.account.address,
+            ...txOptions,
+        });
+        if (waitForConfirmation) {
+            await this.publicClient.waitForTransactionReceipt({ hash });
+            return hash;
+        }
+        return hash;
+    }
+    /**
+     * Places a limit order using a params struct
+     * @param params - LimitOrderParams struct containing all order parameters
+     * @param options - Transaction options
+     * @returns Transaction hash
+     */
+    async placeLimitOrderWithStruct(params, options) {
+        return this.placeLimitOrder(params.market, params.isBuy, params.margin, params.leverage, params.price, params.reduceOnlyType, options);
+    }
+    async cancelOrder(market, orderId, options) {
+        if (!this.walletClient)
+            throw new Error('Wallet client required for write operations');
+        const { waitForConfirmation, ...txOptions } = options || {};
+        if (!this.walletClient.account) {
+            throw new Error('Wallet client must have an account for transactions');
+        }
+        const hash = await this.walletClient.writeContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'cancelOrder',
+            args: [market, orderId],
+            account: this.walletClient.account,
+            ...txOptions,
+        });
+        if (waitForConfirmation) {
+            await this.publicClient.waitForTransactionReceipt({ hash });
+            return hash;
+        }
+        return hash;
+    }
+    async cancelAllOrders(market, options) {
+        if (!this.walletClient)
+            throw new Error('Wallet client required for write operations');
+        const { waitForConfirmation, ...txOptions } = options || {};
+        if (!this.walletClient.account) {
+            throw new Error('Wallet client must have an account for transactions');
+        }
+        const hash = await this.walletClient.writeContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'cancelAllOrders',
+            args: [market],
+            account: this.walletClient.account,
+            ...txOptions,
+        });
+        if (waitForConfirmation) {
+            await this.publicClient.waitForTransactionReceipt({ hash });
+            return hash;
+        }
+        return hash;
+    }
+    // ============ Liquidation Functions ============
+    async liquidatePosition(positionId, options) {
+        if (!this.walletClient)
+            throw new Error('Wallet client required for write operations');
+        const { waitForConfirmation, ...txOptions } = options || {};
+        if (!this.walletClient.account) {
+            throw new Error('Wallet client must have an account for transactions');
+        }
+        const hash = await this.walletClient.writeContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'liquidatePosition',
+            args: [positionId],
+            account: this.walletClient.account,
+            ...txOptions,
+        });
+        if (waitForConfirmation) {
+            await this.publicClient.waitForTransactionReceipt({ hash });
+            return hash;
+        }
+        return hash;
+    }
+    async claimKeeperRewards(options) {
+        if (!this.walletClient)
+            throw new Error('Wallet client required for write operations');
+        const { waitForConfirmation, ...txOptions } = options || {};
+        if (!this.walletClient.account) {
+            throw new Error('Wallet client must have an account for transactions');
+        }
+        const hash = await this.walletClient.writeContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'claimKeeperRewards',
+            args: [],
+            account: this.walletClient.account,
+            ...txOptions,
+        });
+        if (waitForConfirmation) {
+            await this.publicClient.waitForTransactionReceipt({ hash });
+            return hash;
+        }
+        return hash;
+    }
+    // ============ View Functions - Positions ============
+    async getPositionId(trader, market) {
+        const result = await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getPositionId',
+            args: [trader, market],
+        });
+        // Convert bytes32 (padded) to bytes16
+        return this.bytes32ToBytes16(result);
+    }
+    async hasPosition(trader, market) {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'hasPosition',
+            args: [trader, market],
+        }));
+    }
+    async getPosition(positionId) {
+        const result = (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getPosition',
+            args: [positionId],
+        }));
+        // Ensure values are BigInt for calculations
+        const notionalValue = BigInt(result[3]);
+        const margin = BigInt(result[4]);
+        return {
+            // Based on ABI: [0] owner, [1] market, [2] isLong, [3] notionalValue, [4] margin, [5] entryPrice, [6] fundingIndex, [7] lastUpdateTime
+            notionalValue: result[3],
+            margin: result[4],
+            entryPrice: result[5],
+            isLong: result[2],
+            lastUpdated: result[7], // Maps from contract's lastUpdateTime
+            fundingIndex: result[6],
+            leverage: margin > 0n ? (notionalValue * 1000000000000000000n) / margin : 0n, // Calculate leverage in 1e18 format (notionalValue/margin * 1e18)
+            liquidationPrice: 0n, // Not returned by ABI - would need separate calculation
+        };
+    }
+    async getPositionDetails(positionId) {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getPositionDetails',
+            args: [positionId],
+        }));
+    }
+    async getUserPositions(trader) {
+        const result = (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getUserPositions',
+            args: [trader],
+        }));
+        // Convert each bytes32 (padded) to bytes16
+        return result.map((id) => this.bytes32ToBytes16(id));
+    }
+    async getUserPositionsSummary(trader) {
+        const result = (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getUserPositionsSummary',
+            args: [trader],
+        }));
+        return {
+            totalPositions: result[0],
+            totalMargin: result[1],
+            totalUnrealizedPnl: result[2],
+            totalSize: result[3],
+        };
+    }
+    async calculateUnrealizedPnl(positionId) {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'calculateUnrealizedPnl',
+            args: [positionId],
+        }));
+    }
+    async getMarginRatio(positionId) {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getMarginRatio',
+            args: [positionId],
+        }));
+    }
+    async isLiquidatable(positionId) {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'isLiquidatable',
+            args: [positionId],
+        }));
+    }
+    async getLiquidationStatus(positionId) {
+        const result = (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getLiquidationStatus',
+            args: [positionId],
+        }));
+        return {
+            isLiquidatable: result[0],
+            marginRatio: result[1],
+            requiredMargin: result[2],
+            liquidationPrice: result[3],
+        };
+    }
+    /**
+     * Get account-level liquidation status (cross-margin)
+     * When account equity < total maintenance, ALL positions are liquidatable (Hyperliquid-style)
+     */
+    async getAccountLiquidationStatus(trader) {
+        const result = (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getAccountLiquidationStatus',
+            args: [trader],
+        }));
+        return {
+            liquidatable: result[0],
+            worstPositionId: result[1],
+            accountEquity: result[2],
+            totalMaintenanceRequired: result[3],
+        };
+    }
+    /**
+     * Get cross-margin liquidation price for a position
+     * Uses Hyperliquid formula: accounts for all positions' PnL in the account
+     */
+    async getAccountLiquidationPrice(positionId) {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getAccountLiquidationPrice',
+            args: [positionId],
+        }));
+    }
+    // ============ View Functions - Margin ============
+    /**
+     * Get raw deposited margin balance (excludes unrealized PnL).
+     * For account equity (balance + PnL), use getAccountSummary().
+     */
+    async getMarginBalance(trader) {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getMarginBalance',
+            args: [trader],
+        }));
+    }
+    /**
+     * Get comprehensive account summary in a single RPC call.
+     * Returns deposited balance, account equity, unrealized PnL, locked margin, and available margin.
+     */
+    async getAccountSummary(trader) {
+        const result = (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getAccountSummary',
+            args: [trader],
+        }));
+        return {
+            depositedBalance: result.depositedBalance ?? result[0],
+            accountEquity: result.accountEquity ?? result[1],
+            unrealizedPnl: result.unrealizedPnl ?? result[2],
+            lockedMargin: result.lockedMargin ?? result[3],
+            availableMargin: result.availableMargin ?? result[4],
+        };
+    }
+    async getLockedMargin(trader) {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getLockedMargin',
+            args: [trader],
+        }));
+    }
+    async getAvailableMargin(trader) {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getAvailableMargin',
+            args: [trader],
+        }));
+    }
+    async getMaxUserDeposit() {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getMaxUserDeposit',
+            args: [],
+        }));
+    }
+    async getMaxGlobalDeposits() {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getMaxGlobalDeposits',
+            args: [],
+        }));
+    }
+    async getTotalDeposits() {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getTotalDeposits',
+            args: [],
+        }));
+    }
+    // ============ View Functions - Markets ============
+    async getMarketInfo(market) {
+        const result = (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getMarketInfo',
+            args: [market],
+        }));
+        if (!result || !Array.isArray(result) || result.length < 8) {
+            throw new Error(`Invalid market info response for market ${market}. ` +
+                `Expected array with 8 elements, got: ${JSON.stringify(result)}`);
+        }
+        return {
+            longOpenInterest: result[0],
+            shortOpenInterest: result[1],
+            fundingRate: result[2],
+            lastFundingUpdate: result[3],
+            isActive: result[4],
+            maxLeverage: result[5],
+            maintenanceMargin: result[6],
+            liquidationFee: result[7],
+        };
+    }
+    async getMarketOpenInterest(market) {
+        const result = (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getMarketOpenInterest',
+            args: [market],
+        }));
+        return {
+            longOI: result[0],
+            shortOI: result[1],
+        };
+    }
+    async getFundingRate(market) {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getFundingRate',
+            args: [market],
+        }));
+    }
+    async getFundingState(market) {
+        const result = (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getFundingState',
+            args: [market],
+        }));
+        // Based on ABI, getFundingState returns:
+        // [0] currentRate (int256), [1] cumulativeIndex (int256), [2] lastUpdate (uint256)
+        const lastUpdateTime = result[2] !== undefined ? BigInt(result[2]) : 0n;
+        return {
+            fundingRate: result[0] || 0n,
+            fundingIndex: result[1] || 0n,
+            lastUpdateTime: result[2] || 0n,
+            nextFundingTime: lastUpdateTime + 8n * 3600n, // Add 8 hours to lastUpdate
+        };
+    }
+    // ============ Funding Rate Updates (Keeper Function) ============
+    async updateFundingRates(markets, options) {
+        if (!this.walletClient)
+            throw new Error('Wallet client required for write operations');
+        const { waitForConfirmation: _waitForConfirmation, ...txOptions } = options || {};
+        if (!this.walletClient.account) {
+            throw new Error('Wallet client must have an account for transactions');
+        }
+        const hash = await this.walletClient.writeContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'updateFundingRates',
+            args: [markets],
+            account: this.walletClient.account,
+            ...txOptions,
+        });
+        return {
+            hash,
+            wait: async () => {
+                const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+                return receipt;
+            },
+        };
+    }
+    // ============ View Functions - Orders ============
+    async getBestBid(market) {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getBestBid',
+            args: [market],
+        }));
+    }
+    async getBestAsk(market) {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getBestAsk',
+            args: [market],
+        }));
+    }
+    /**
+     * Get all open order IDs for a trader in a specific market
+     * @param trader - Trader address
+     * @param market - Market address
+     * @returns Array of order IDs (bytes16)
+     */
+    async getUserOrders(trader, market) {
+        const result = (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getUserOrders',
+            args: [trader, market],
+        }));
+        // Convert each bytes32 (padded) to bytes16
+        return result.map((id) => this.bytes32ToBytes16(id));
+    }
+    /**
+     * Get details of a specific order
+     * @param market - The market address
+     * @param orderId - The order ID (bytes16)
+     * @returns Order details including trader, direction, size, price, reduceOnly
+     */
+    async getOrderDetails(market, orderId) {
+        const result = (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getOrderDetails',
+            args: [market, orderId],
+        }));
+        // Contract returns a struct with: trader, isLong, notionalValue, price, reduceOnly, next, prev
+        return {
+            trader: result.trader,
+            isLong: result.isLong,
+            notionalValue: result.notionalValue,
+            price: result.price,
+            reduceOnly: result.reduceOnly,
+            next: result.next,
+            prev: result.prev,
+        };
+    }
+    // ============ View Functions - Vault ============
+    async getVaultStats() {
+        const result = (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getVaultStats',
+            args: [],
+        }));
+        return {
+            totalReserves: result[0],
+            availableReserves: result[1],
+            totalExposure: result[2],
+            unrealizedPnl: result[3],
+        };
+    }
+    async getVaultBalance() {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getVaultBalance',
+            args: [],
+        }));
+    }
+    async getVaultState() {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getVaultState',
+            args: [],
+        }));
+    }
+    async getVaultExposure(market) {
+        const result = (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getVaultExposure',
+            args: [market],
+        }));
+        return {
+            longExposure: result[0],
+            shortExposure: result[1],
+            netExposure: result[2],
+            utilizationRate: result[3],
+        };
+    }
+    // ============ View Functions - Protocol Limits ============
+    async getMaxPositionSize(market) {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getMaxPositionSize',
+            args: [market],
+        }));
+    }
+    // ============ View Functions - Execution Analysis ============
+    async calculateVaultSlippage(market, size, isBuy) {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'calculateVaultSlippage',
+            args: [market, size, isBuy],
+        }));
+    }
+    async getOptimalExecutionPlan(market, size, isLong, maxSlippage) {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getOptimalExecutionPlan',
+            args: [market, size, isLong, maxSlippage],
+        }));
+    }
+    async getExecutionStrategyAnalysis(market, size, isLong, maxSlippage) {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getExecutionStrategyAnalysisStruct',
+            args: [market, size, isLong, maxSlippage],
+        }));
+    }
+    // ============ View Functions - Market Depth ============
+    async getMarketDepth(market, isBuy, levels) {
+        const result = (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getMarketDepth',
+            args: [market, isBuy, levels],
+        }));
+        return {
+            depth: result[0],
+            totalLiquidity: result[1],
+        };
+    }
+    async getOrderbookDepth(market, levels) {
+        const result = (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getOrderbookDepth',
+            args: [market, levels],
+        }));
+        return {
+            bidPrices: result[0],
+            bidNotionals: result[1],
+            askPrices: result[2],
+            askNotionals: result[3],
+        };
+    }
+    async getVWAP(market, size, isBuy) {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getVWAP',
+            args: [market, size, isBuy],
+        }));
+    }
+    async getBidAskSpread(market) {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getBidAskSpread',
+            args: [market],
+        }));
+    }
+    async estimateMarketImpact(market, size, isBuy) {
+        const result = (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'estimateMarketImpact',
+            args: [market, size, isBuy],
+        }));
+        return {
+            averagePrice: result[0],
+            worstPrice: result[1],
+            priceImpact: result[2],
+            filledFromOrderbook: result[3],
+        };
+    }
+    async getMarketLiquidityAnalysis(market) {
+        return (await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName: 'getMarketLiquidityAnalysisStruct',
+            args: [market],
+        }));
+    }
+    // ============ Event Parsing ============
+    parsePositionOpenedEvent(receipt) {
+        const logs = (0, viem_1.parseEventLogs)({
+            abi: Alpha_json_1.default,
+            logs: receipt.logs,
+            eventName: 'PositionOpened',
+        });
+        if (logs.length > 0) {
+            const event = logs[0];
+            // Convert bytes32 (padded) back to bytes16
+            const positionId = this.bytes32ToBytes16(event.args.positionId);
+            return {
+                positionId: positionId,
+                trader: event.args.trader,
+                market: event.args.market,
+                isLong: event.args.isLong,
+                notionalValue: event.args.notionalValue,
+                margin: event.args.margin,
+            };
+        }
+        return undefined;
+    }
+    parsePositionClosedEvent(receipt) {
+        const logs = (0, viem_1.parseEventLogs)({
+            abi: Alpha_json_1.default,
+            logs: receipt.logs,
+            eventName: 'PositionClosed',
+        });
+        if (logs.length > 0) {
+            const event = logs[0];
+            // Convert bytes32 (padded) back to bytes16
+            const positionId = this.bytes32ToBytes16(event.args.positionId);
+            return {
+                positionId: positionId,
+                trader: event.args.trader,
+                pnl: event.args.pnl,
+            };
+        }
+        return undefined;
+    }
+    parseOrderPlacedEvent(receipt) {
+        const logs = (0, viem_1.parseEventLogs)({
+            abi: Alpha_json_1.default,
+            logs: receipt.logs,
+            eventName: 'OrderPlaced',
+        });
+        if (logs.length > 0) {
+            const event = logs[0];
+            return {
+                orderId: event.args.orderId,
+                trader: event.args.trader,
+                market: event.args.market,
+                isBuy: event.args.isBuy,
+                notionalValue: event.args.notionalValue,
+                price: event.args.price,
+            };
+        }
+        return undefined;
+    }
+    parseHybridOrderExecutedEvent(receipt) {
+        const logs = (0, viem_1.parseEventLogs)({
+            abi: Alpha_json_1.default,
+            logs: receipt.logs,
+            eventName: 'HybridOrderExecuted',
+        });
+        if (logs.length > 0) {
+            const event = logs[0];
+            return {
+                trader: event.args.trader,
+                market: event.args.market,
+                orderbookFilled: event.args.orderbookFilled,
+                vaultFilled: event.args.vaultFilled,
+                avgPrice: event.args.avgPrice,
+            };
+        }
+        return undefined;
+    }
+    // ============ Helper Functions ============
+    async waitForTransaction(hash) {
+        return this.publicClient.waitForTransactionReceipt({ hash });
+    }
+    getContractAddress() {
+        return this.contractAddress;
+    }
+    // Generic readContract method for custom function calls
+    async readContract({ functionName, args }) {
+        return await this.publicClient.readContract({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName,
+            args,
+        });
+    }
+    async getConstants() {
+        const [precision, basisPoints, maxLeverage, defaultLeverage, minPositionSize, liquidationThreshold, partialLiquidationThreshold, liquidationFee, fundingInterval, maxFundingRate, maxExposurePerAsset, maxTotalUtilization, criticalUtilizationBps, maxLossRateBps, maxLiquidationsPerBlock,] = await Promise.all([
+            this.publicClient.readContract({
+                address: this.contractAddress,
+                abi: Alpha_json_1.default,
+                functionName: 'PRECISION',
+                args: [],
+            }),
+            this.publicClient.readContract({
+                address: this.contractAddress,
+                abi: Alpha_json_1.default,
+                functionName: 'BASIS_POINTS',
+                args: [],
+            }),
+            this.publicClient.readContract({
+                address: this.contractAddress,
+                abi: Alpha_json_1.default,
+                functionName: 'MAX_LEVERAGE',
+                args: [],
+            }),
+            this.publicClient.readContract({
+                address: this.contractAddress,
+                abi: Alpha_json_1.default,
+                functionName: 'DEFAULT_LEVERAGE',
+                args: [],
+            }),
+            this.publicClient.readContract({
+                address: this.contractAddress,
+                abi: Alpha_json_1.default,
+                functionName: 'MIN_POSITION_SIZE',
+                args: [],
+            }),
+            this.publicClient.readContract({
+                address: this.contractAddress,
+                abi: Alpha_json_1.default,
+                functionName: 'LIQUIDATION_THRESHOLD',
+                args: [],
+            }),
+            this.publicClient.readContract({
+                address: this.contractAddress,
+                abi: Alpha_json_1.default,
+                functionName: 'PARTIAL_LIQUIDATION_THRESHOLD',
+                args: [],
+            }),
+            this.publicClient.readContract({
+                address: this.contractAddress,
+                abi: Alpha_json_1.default,
+                functionName: 'LIQUIDATION_FEE',
+                args: [],
+            }),
+            this.publicClient.readContract({
+                address: this.contractAddress,
+                abi: Alpha_json_1.default,
+                functionName: 'FUNDING_INTERVAL',
+                args: [],
+            }),
+            this.publicClient.readContract({
+                address: this.contractAddress,
+                abi: Alpha_json_1.default,
+                functionName: 'MAX_FUNDING_RATE',
+                args: [],
+            }),
+            this.publicClient.readContract({
+                address: this.contractAddress,
+                abi: Alpha_json_1.default,
+                functionName: 'MAX_EXPOSURE_PER_ASSET',
+                args: [],
+            }),
+            this.publicClient.readContract({
+                address: this.contractAddress,
+                abi: Alpha_json_1.default,
+                functionName: 'MAX_TOTAL_UTILIZATION',
+                args: [],
+            }),
+            this.publicClient.readContract({
+                address: this.contractAddress,
+                abi: Alpha_json_1.default,
+                functionName: 'CRITICAL_UTILIZATION_BPS',
+                args: [],
+            }),
+            this.publicClient.readContract({
+                address: this.contractAddress,
+                abi: Alpha_json_1.default,
+                functionName: 'MAX_LOSS_RATE_BPS',
+                args: [],
+            }),
+            this.publicClient.readContract({
+                address: this.contractAddress,
+                abi: Alpha_json_1.default,
+                functionName: 'MAX_LIQUIDATIONS_PER_BLOCK',
+                args: [],
+            }),
+        ]);
+        return {
+            precision,
+            basisPoints,
+            maxLeverage,
+            defaultLeverage,
+            minPositionSize,
+            liquidationThreshold,
+            partialLiquidationThreshold,
+            liquidationFee,
+            fundingInterval,
+            maxFundingRate,
+            maxExposurePerAsset,
+            maxTotalUtilization,
+            criticalUtilizationBps,
+            maxLossRateBps,
+            maxLiquidationsPerBlock,
+        };
+    }
+    // Event watching methods
+    /**
+     * Watch for MarginDeposited events
+     */
+    watchMarginDepositedEvent(callback) {
+        return this.publicClient.watchContractEvent({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            eventName: 'MarginDeposited',
+            onLogs: (logs) => {
+                for (const log of logs) {
+                    const { trader, amount } = log.args;
+                    callback(trader, amount);
+                }
+            },
+        });
+    }
+    /**
+     * Watch for MarginWithdrawn events
+     */
+    watchMarginWithdrawnEvent(callback) {
+        return this.publicClient.watchContractEvent({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            eventName: 'MarginWithdrawn',
+            onLogs: (logs) => {
+                for (const log of logs) {
+                    const { trader, amount } = log.args;
+                    callback(trader, amount);
+                }
+            },
+        });
+    }
+    /**
+     * Watch for PositionOpened events
+     */
+    watchPositionOpenedEvent(callback) {
+        return this.publicClient.watchContractEvent({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            eventName: 'PositionOpened',
+            onLogs: (logs) => {
+                for (const log of logs) {
+                    const { positionId, trader, market, isLong, notionalValue, entryPrice, margin } = log.args;
+                    callback(positionId, trader, market, isLong, notionalValue, entryPrice, margin);
+                }
+            },
+        });
+    }
+    /**
+     * Get past MarginDeposited events
+     */
+    async getMarginDepositedEvents(fromBlock, toBlock, trader) {
+        return await this.publicClient.getContractEvents({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            eventName: 'MarginDeposited',
+            fromBlock: fromBlock || 'earliest',
+            toBlock: toBlock || 'latest',
+            args: trader ? { trader } : undefined,
+        });
+    }
+    /**
+     * Get past MarginWithdrawn events
+     */
+    async getMarginWithdrawnEvents(fromBlock, toBlock, trader) {
+        return await this.publicClient.getContractEvents({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            eventName: 'MarginWithdrawn',
+            fromBlock: fromBlock || 'earliest',
+            toBlock: toBlock || 'latest',
+            args: trader ? { trader } : undefined,
+        });
+    }
+    /**
+     * Get past PositionOpened events
+     */
+    async getPositionOpenedEvents(fromBlock, toBlock, trader) {
+        return await this.publicClient.getContractEvents({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            eventName: 'PositionOpened',
+            fromBlock: fromBlock || 'earliest',
+            toBlock: toBlock || 'latest',
+            args: trader ? { trader } : undefined,
+        });
+    }
+    /**
+     * Estimate gas for a transaction
+     */
+    async estimateGas(functionName, args, options) {
+        if (!this.walletClient) {
+            throw new Error('Wallet client is required for gas estimation');
+        }
+        const { gasPrice: _gasPrice, waitForConfirmation: _waitForConfirmation, ...estimateOptions } = options || {};
+        return await this.publicClient.estimateContractGas({
+            address: this.contractAddress,
+            abi: Alpha_json_1.default,
+            functionName,
+            args,
+            account: this.walletClient.account,
+            ...estimateOptions,
+        });
+    }
+}
+exports.AlphaViem = AlphaViem;
+//# sourceMappingURL=AlphaViem.js.map