@megatao/sdk 1.1.0

package/src/contracts/viem/PriceOracleViem.ts

@@ -0,0 +1,272 @@
+/**
+ * PriceOracle contract wrapper using Viem
+ * Provides type-safe contract interactions with automatic type inference
+ *
+ * Note: The Alpha contract includes oracle integration. This wrapper is for
+ * interacting with the standalone oracle contract if needed.
+ */
+
+import { Address, PublicClient, WalletClient, getContract, Hash } from 'viem';
+import { PriceOracleABI } from '../../abi';
+import { PriceData, TransactionOptions } from '../../types';
+
+export class PriceOracleViem {
+  private readContract;
+  private writeContract;
+  private publicClient: PublicClient;
+  private walletClient?: WalletClient;
+
+  constructor(address: Address, publicClient: PublicClient, walletClient?: WalletClient) {
+    this.publicClient = publicClient;
+    this.walletClient = walletClient;
+
+    // Create read contract
+    this.readContract = getContract({
+      address,
+      abi: PriceOracleABI,
+      client: publicClient,
+    });
+
+    // Create write contract if wallet client is available
+    if (walletClient) {
+      this.writeContract = getContract({
+        address,
+        abi: PriceOracleABI,
+        client: walletClient,
+      });
+    }
+  }
+
+  /**
+   * Read Methods
+   */
+
+  async getPrice(asset: Address): Promise<bigint> {
+    // Convert asset address to subnet ID (last 2 bytes)
+    // e.g., 0x0000000000000000000000000000000000000022 -> 34 (0x22)
+    const subnetId = parseInt(asset.slice(-4), 16);
+
+    try {
+      // Use calculatePriceFromReserves with subnet ID
+      return (await this.readContract.read.calculatePriceFromReserves([subnetId])) as bigint;
+    } catch (error) {
+      // Fallback to mock price if oracle doesn't have price set
+      console.warn(`Oracle price not available for subnet ${subnetId}, using mock price`);
+      return BigInt('100000000000000000000'); // 100 TAO
+    }
+  }
+
+  // Note: These methods require additional ABI entries
+  // async getLatestPrice(asset: Address): Promise<{ price: bigint; timestamp: bigint }> {
+  //   const result = await this.readContract.read.getLatestPrice([asset]) as [bigint, bigint];
+  //   return { price: result[0], timestamp: result[1] };
+  // }
+
+  /**
+   * Get latest price data (simplified implementation)
+   */
+  async getLatestPriceData(asset: Address): Promise<{ price: bigint; timestamp: bigint }> {
+    const price = await this.getPrice(asset);
+    return { price, timestamp: BigInt(Date.now()) };
+  }
+
+  /**
+   * Write Methods - Not available for this oracle (read-only)
+   */
+
+  async updatePrice(_asset: Address, _price: bigint, _options?: TransactionOptions): Promise<Hash> {
+    throw new Error(
+      'updatePrice not available - this oracle is read-only (calculatePriceFromReserves only)',
+    );
+  }
+
+  /**
+   * Event Methods
+   */
+
+  async getPriceUpdatedEvents(
+    asset?: Address,
+    fromBlock?: bigint,
+    toBlock?: bigint,
+  ): Promise<
+    Array<{
+      asset: Address;
+      price: bigint;
+      timestamp: bigint;
+      blockNumber: bigint;
+      transactionHash: Hash;
+    }>
+  > {
+    const logs = await this.publicClient.getLogs({
+      address: this.readContract.address,
+      event: {
+        type: 'event',
+        name: 'PriceUpdated',
+        inputs: [
+          {
+            name: 'asset',
+            type: 'address',
+            indexed: true,
+          },
+          {
+            name: 'price',
+            type: 'uint256',
+            indexed: false,
+          },
+          {
+            name: 'timestamp',
+            type: 'uint256',
+            indexed: false,
+          },
+        ],
+      },
+      args: asset ? { asset } : undefined,
+      fromBlock,
+      toBlock,
+    });
+
+    return logs.map((log) => ({
+      asset: (log as any).args.asset!,
+      price: (log as any).args.price!,
+      timestamp: (log as any).args.timestamp!,
+      blockNumber: log.blockNumber,
+      transactionHash: log.transactionHash,
+    }));
+  }
+
+  async getOracleSourceUpdatedEvents(
+    asset?: Address,
+    fromBlock?: bigint,
+    toBlock?: bigint,
+  ): Promise<
+    Array<{
+      asset: Address;
+      newSource: Address;
+      blockNumber: bigint;
+      transactionHash: Hash;
+    }>
+  > {
+    const logs = await this.publicClient.getLogs({
+      address: this.readContract.address,
+      event: {
+        type: 'event',
+        name: 'OracleSourceUpdated',
+        inputs: [
+          {
+            name: 'asset',
+            type: 'address',
+            indexed: true,
+          },
+          {
+            name: 'newSource',
+            type: 'address',
+            indexed: false,
+          },
+        ],
+      },
+      args: asset ? { asset } : undefined,
+      fromBlock,
+      toBlock,
+    });
+
+    return logs.map((log) => ({
+      asset: (log as any).args.asset!,
+      newSource: (log as any).args.newSource!,
+      blockNumber: log.blockNumber,
+      transactionHash: log.transactionHash,
+    }));
+  }
+
+  /**
+   * Utility Methods
+   */
+
+  async getPriceData(asset: Address): Promise<PriceData> {
+    const price = await this.getPrice(asset);
+    const timestamp = BigInt(Date.now());
+
+    return {
+      asset,
+      price,
+      timestamp,
+      confidence: 100n, // Default confidence
+    };
+  }
+
+  async getMultiplePrices(assets: Address[]): Promise<PriceData[]> {
+    const promises = assets.map(async (asset) => {
+      try {
+        return await this.getPriceData(asset);
+      } catch (error) {
+        console.warn(`Failed to get price for asset ${asset}:`, error);
+        return {
+          asset,
+          price: 0n,
+          timestamp: 0n,
+          confidence: 0n,
+        };
+      }
+    });
+
+    return Promise.all(promises);
+  }
+
+  async waitForPriceUpdate(
+    asset: Address,
+    _timeout: number = 30000,
+  ): Promise<{ price: bigint; timestamp: bigint }> {
+    // Simplified implementation - just return current price
+    return await this.getLatestPriceData(asset);
+  }
+
+  /**
+   * Subscription Methods (if supported by the client)
+   */
+
+  subscribeToPriceUpdates(
+    callback: (data: { asset: Address; price: bigint; timestamp: bigint }) => void,
+    asset?: Address,
+  ): (() => void) | undefined {
+    if (!this.publicClient.watchContractEvent) {
+      console.warn('Contract event watching not supported by this client');
+      return undefined;
+    }
+
+    const unwatch = this.publicClient.watchContractEvent({
+      address: this.readContract.address,
+      abi: PriceOracleABI,
+      eventName: 'PriceUpdated',
+      args: asset ? { asset } : undefined,
+      onLogs: (logs: any[]) => {
+        logs.forEach((log: any) => {
+          const logArgs = (log as any).args;
+          if (logArgs.asset && logArgs.price && logArgs.timestamp) {
+            callback({
+              asset: logArgs.asset,
+              price: logArgs.price,
+              timestamp: logArgs.timestamp,
+            });
+          }
+        });
+      },
+    });
+
+    return unwatch;
+  }
+
+  /**
+   * Helper Methods
+   */
+
+  getAddress(): Address {
+    return this.readContract.address;
+  }
+
+  async getBlockNumber(): Promise<bigint> {
+    return await this.publicClient.getBlockNumber();
+  }
+
+  async estimateUpdatePriceGas(_asset: Address, _price: bigint): Promise<bigint> {
+    throw new Error('estimateUpdatePriceGas not available - this oracle is read-only');
+  }
+}

package/src/contracts/viem/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Viem contract exports
+ * Type-safe contract wrappers using Viem for automatic type inference
+ */
+
+export { AlphaViem } from './AlphaViem';
+export { PriceOracleViem } from './PriceOracleViem';
+
+// Re-export types from viem for convenience
+export type { Address, Hash, TransactionReceipt, Block } from 'viem';
+export { parseEther, formatEther, parseUnits, formatUnits } from 'viem';

package/src/errors/index.ts

@@ -0,0 +1,87 @@
+/**
+ * Custom error classes for Alpha Futures SDK
+ */
+
+export class AlphaFuturesError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'AlphaFuturesError';
+  }
+}
+
+export class ContractError extends AlphaFuturesError {
+  constructor(
+    message: string,
+    public readonly contractName: string,
+    public readonly method: string,
+    public readonly originalError?: any,
+  ) {
+    super(message);
+    this.name = 'ContractError';
+  }
+}
+
+export class ValidationError extends AlphaFuturesError {
+  constructor(
+    message: string,
+    public readonly field?: string,
+  ) {
+    super(message);
+    this.name = 'ValidationError';
+  }
+}
+
+export class InsufficientMarginError extends AlphaFuturesError {
+  constructor(
+    public readonly required: bigint,
+    public readonly available: bigint,
+  ) {
+    super(`Insufficient margin. Required: ${required}, Available: ${available}`);
+    this.name = 'InsufficientMarginError';
+  }
+}
+
+export class PositionNotFoundError extends AlphaFuturesError {
+  constructor(public readonly positionId: bigint) {
+    super(`Position not found: ${positionId}`);
+    this.name = 'PositionNotFoundError';
+  }
+}
+
+export class InvalidLeverageError extends AlphaFuturesError {
+  constructor(
+    public readonly requested: bigint,
+    public readonly maximum: bigint,
+  ) {
+    super(`Invalid leverage. Requested: ${requested}, Maximum: ${maximum}`);
+    this.name = 'InvalidLeverageError';
+  }
+}
+
+export class PriceStaleError extends AlphaFuturesError {
+  constructor(
+    public readonly asset: string,
+    public readonly lastUpdate: bigint,
+    public readonly threshold: bigint,
+  ) {
+    super(`Price data is stale for ${asset}. Last update: ${lastUpdate}, Threshold: ${threshold}`);
+    this.name = 'PriceStaleError';
+  }
+}
+
+export class NetworkError extends AlphaFuturesError {
+  constructor(
+    message: string,
+    public readonly network?: string,
+  ) {
+    super(message);
+    this.name = 'NetworkError';
+  }
+}
+
+export class SignerRequiredError extends AlphaFuturesError {
+  constructor() {
+    super('Signer is required for this operation');
+    this.name = 'SignerRequiredError';
+  }
+}

package/src/index.ts

@@ -0,0 +1,59 @@
+/**
+ * Alpha Futures SDK
+ * Main entry point for the Alpha Futures TypeScript SDK
+ */
+
+// Export main client
+export { AlphaFuturesClient } from './AlphaFuturesClient';
+
+// Export Viem contracts
+export { AlphaViem, PriceOracleViem } from './contracts/viem';
+
+// Export ABIs
+export * from './abi/abis';
+
+// Export types
+export * from './types';
+
+// Export errors
+export * from './errors';
+
+// Export utilities
+export * from './utils/format';
+export * from './utils/validation';
+export * from './utils/events';
+export * from './utils/positionCalculations';
+
+// Export constants
+export * from './constants';
+
+// Export configuration
+export {
+  type DeploymentInfo,
+  type ContractsConfig,
+  contractsConfig,
+  type ContractAddresses,
+} from './config/contracts.config';
+export * from './config/environments';
+
+// Re-export viem utilities
+export {
+  type Address,
+  type Hash,
+  type TransactionReceipt,
+  type PublicClient,
+  type WalletClient,
+  parseEther,
+  formatEther,
+  parseUnits,
+  formatUnits,
+  getContract,
+  createPublicClient,
+  createWalletClient,
+  http,
+  custom,
+  type Chain,
+  type Transport,
+} from 'viem';
+
+export { mainnet, sepolia } from 'viem/chains';

package/src/types/VIEM_TYPES_README.md

@@ -0,0 +1,70 @@
+# Viem Type Generation
+
+## Overview
+
+Unlike traditional approaches that require code generation (like Typechain), Viem provides automatic type inference directly from your ABI definitions. This means:
+
+1. **No Build Step**: Types are inferred at compile time, not generated
+2. **Always Up-to-Date**: Types automatically update when you change your ABIs
+3. **Better Developer Experience**: Full IntelliSense without running generators
+4. **Type Safety**: Complete type safety for all contract interactions
+
+## How It Works
+
+Viem uses TypeScript's advanced type system to infer types from your ABI:
+
+```typescript
+import { getContract } from 'viem';
+import { PositionManagerABI } from './abi/abis';
+
+// Viem automatically infers all types from the ABI
+const contract = getContract({
+    address: '0x...',
+    abi: PositionManagerABI,
+    client: publicClient
+});
+
+// Full type safety and autocomplete
+const position = await contract.read.getPosition([positionId]);
+//                                   ^-- autocomplete shows all functions
+//                                              ^-- type-safe parameters
+```
+
+## Benefits Over Traditional Approaches
+
+### Traditional (Typechain)
+- Requires running code generation
+- Generated files can get out of sync
+- Large generated files in your codebase
+- Need to regenerate after ABI changes
+
+### Modern (Viem + ABIType)
+- Zero code generation
+- Types always match your ABIs
+- No generated files to maintain
+- Instant type updates
+
+## Usage
+
+Simply import your ABIs and use them with Viem:
+
+```typescript
+import { createPublicClient, getContract } from 'viem';
+import { MarginAccountABI } from './abi/abis';
+
+const contract = getContract({
+    address: '0x...',
+    abi: MarginAccountABI,
+    client: publicClient
+});
+
+// Everything is fully typed!
+const balance = await contract.read.getBalance(['0x...']);
+const tx = await contract.write.deposit([amount], { value: amount });
+```
+
+## See Also
+
+- `src/types/viem-types.ts` - Examples of type inference
+- `src/contracts/viem/` - Viem contract wrappers
+- `src/abi/abis.ts` - Type-safe ABI definitions