@mememax/sdk-core 0.0.1

package/README.md

@@ -0,0 +1,314 @@
+### Core SDK for Mememax ###
+
+# Get Started
+
+## Initializing SDK
+
+```typescript
+// Initialize SDK instance
+const sdk = await OrbixSDK.instance({
+  network: OrbixSDK.Network.MainNet, 
+  config: {
+    tmRpcUrl: "https://tm-api.mememax.orbix.com", 
+  },
+});
+
+// Connect SDK with mnemonic
+const connectedSdk1 = await sdk.connectWithMnemonic(mnemonic);
+
+// Connect SDK with private key
+const connectedSdk2 = await sdk.connectWithPrivateKey(privateKey);
+
+// Connect SDK with custom signer
+const connectedSdk3 = await sdk.connectWithSigner(signer, publicKeyBase64);
+```
+
+## Usage Overview
+
+The SDK provides a structured way to interact with the Orbix blockchain.
+
+### Architecture
+
+```
+Your Application (e.g. Node.js/React)
+  ↓ initialize & connect
+SDK (SDK.instance)
+  ↓ call module methods
+sdk.order / sdk.leverage / sdk.ibc / sdk.bridge ...
+  ↓ broadcast transaction
+Orbix Chain
+```
+
+### Common SDK Methods
+
+| Module | Method | Description |
+|--------|--------|-------------|
+| `order` | `sdk.order.create(params)` | Create a single order |
+| `order` | `sdk.order.createOrders(params[])` | Create multiple orders and/or set leverage in batch |
+| `order` | `sdk.order.edit(params)` | Edit an existing order |
+| `order` | `sdk.order.editOrders(params[])` | Edit multiple orders in batch |
+| `order` | `sdk.order.cancel(params)` | Cancel a single order |
+| `order` | `sdk.order.cancelOrders(params[])` | Cancel multiple orders in batch |
+| `order` | `sdk.order.cancelAll(params)` | Cancel all orders for a market |
+| `leverage` | `sdk.leverage.set(params)` | Set leverage multiplier for a market |
+| `leverage` | `sdk.leverage.setLeverages(params[])` | Set leverage for multiple markets in batch |
+| `ibc` | `sdk.ibc.sendIbcTransferV2(params)` | Cross-chain IBC transfer |
+| `bridge` | `sdk.bridge.withdraw(params)` | Cross-chain bridge withdrawal |
+| `bridge` | `sdk.bridge.withdrawAndExecute(params)` | Withdraw and execute (e.g., unwrap wETH to ETH) |
+| `admin` | `sdk.admin.createToken(params)` | Create a new token (Admin only) |
+| `admin` | `sdk.admin.createTokens(params[])` | Create multiple tokens in batch (Admin only) |
+| `admin` | `sdk.admin.updateToken(params)` | Update token properties (Admin only) |
+| `admin` | `sdk.admin.bindToken(params)` | Bind a source denom to a wrapped denom (Admin only) |
+| `admin` | `sdk.admin.unbindToken(params)` | Unbind a wrapped token (Admin only) |
+| `admin` | `sdk.admin.createMarket(params)` | Create a new market (Admin only) |
+| `admin` | `sdk.admin.createMarkets(params[])` | Create multiple markets in batch (Admin only) |
+| `admin` | `sdk.admin.setTradingFlag(params)` | Enable/disable trading for a blockchain (Admin only) |
+| `admin` | `sdk.admin.createOracle(params)` | Create a new oracle (Admin only) |
+| `admin` | `sdk.admin.createValidator(params)` | Create a new validator (Admin only) |
+| `admin` | `sdk.admin.editValidator(params)` | Edit validator properties (Admin only) |
+| `evm` | `sdk.evm.sendEvmTx(txRequest)` | Send EVM transaction (Contract calls) |
+| `bank` | `sdk.bank.send(params)` | Transfer tokens to another address |
+| `staking` | `sdk.staking.delegate(params)` | Delegate tokens to a validator |
+| `staking` | `sdk.staking.undelegate(params)` | Undelegate tokens from a validator |
+| `position` | `sdk.position.adjustMargin(params)` | Adjust margin for a position |
+
+### Examples
+
+#### Create a Limit Order
+```typescript
+import BigNumber from "bignumber.js";
+import { OrderModule } from "@mememax/sdk-core";
+
+await sdk.order.create({
+  marketId: 'btc_z29',
+  side: OrderModule.OrderSide.Buy,
+  orderType: OrderModule.OrderType.Limit,
+  price: new BigNumber(50000),
+  quantity: new BigNumber(0.1),
+  timeInForce: OrderModule.TimeInForce.Gtc,
+})
+```
+
+#### Create Order + Set Leverage (Batch)
+```typescript
+await sdk.order.createOrders([
+  {
+    marketId: 'btc_z29',
+    leverage: new BigNumber(10),
+  },
+  {
+    marketId: 'btc_z29',
+    side: OrderModule.OrderSide.Buy,
+    orderType: OrderModule.OrderType.Limit,
+    price: new BigNumber(50000),
+    quantity: new BigNumber(0.1),
+  }
+])
+```
+
+#### Edit an Order
+```typescript
+await sdk.order.edit({
+  id: 'order_id_123',
+  price: new BigNumber(51000),
+  quantity: new BigNumber(0.2),
+})
+```
+
+#### Cancel Multiple Orders
+```typescript
+await sdk.order.cancelOrders([
+  { id: 'order_id_123' },
+  { id: 'order_id_456' },
+])
+```
+
+#### IBC Transfer (V2)
+```typescript
+import Long from "long";
+
+await sdk.ibc.sendIbcTransferV2({
+  sourcePort: 'transfer',
+  sourceChannel: 'channel-0',
+  receiver: 'meme1...',
+  denom: 'meme',
+  amount: new BigNumber('1000000'),
+  timeoutTimestamp: new BigNumber(Date.now() + 600000),
+})
+```
+
+#### Bridge Withdrawal
+```typescript
+await sdk.bridge.withdraw({
+  connectionId: 'connection-1',
+  receiver: 'xxx',
+  tokenDenom: 'eth.1.19.0x6b175474e89094c44da98b954eedeac495271d0f',
+  tokenAmount: new BigNumber('1000000000000000000'), // 1 token
+  relayDenom: 'meme',
+  relayAmount: new BigNumber('5000000'), // relay fee
+  expirySeconds: 600, // 10 minutes
+})
+```
+
+#### Admin: Create a New Token
+```typescript
+await sdk.admin.createToken({
+  creator: 'meme1...', // admin address
+  name: "New Token",
+  symbol: "NEW",
+  decimals: 18,
+  chainId: 1,
+  bridgeId: 1,
+  bridgeAddress: "0x...",
+  tokenAddress: "0x...",
+})
+```
+
+#### Admin: Create a New Market
+```typescript
+await sdk.admin.createMarket({
+  marketType: "futures",
+  base: "btc",
+  quote: "usd",
+  currentBasePriceUsd: new BigNumber(50000),
+  currentQuotePriceUsd: new BigNumber(1),
+  indexOracleId: "btc_oracle",
+})
+```
+
+#### Admin: Set Trading Flag
+```typescript
+await sdk.admin.setTradingFlag({
+  isEnabled: true,
+  blockchain: "orbix",
+})
+```
+
+#### EVM: Send Transaction (Contract Call)
+```typescript
+import { ethers } from "ethers";
+
+await sdk.evm.sendEvmTx({
+  to: "0x...", // contract address
+  value: ethers.utils.parseEther("0.1"),
+  data: "0x...", // encoded contract call data
+  gasLimit: ethers.BigNumber.from(100000),
+})
+```
+
+### Return Values
+
+All transaction methods return a `Promise` that resolves to an object containing transaction details:
+
+```typescript
+{
+  txHash: string;        // Transaction hash
+  txResponse?: {         // Full transaction response (if available)
+    height: string;
+    txhash: string;
+    code: number;
+    // ... other fields
+  };
+}
+```
+
+For order creation, the response may include:
+```typescript
+{
+  txHash: string;
+  orderId?: string;      // Single order ID (for create())
+  orderIds?: string[];   // Multiple order IDs (for createOrders())
+}
+```
+
+## Module Support Summary
+
+The SDK provides comprehensive blockchain interaction capabilities through the following modules:
+
+### Trading & Orders
+- **Order**: Create, edit, cancel orders (single/batch operations)
+- **Leverage**: Set and manage leverage for markets
+- **Position**: Adjust margin, manage positions
+- **Market**: Query market data and information
+
+### Asset Management
+- **Bank**: On-chain token transfers
+- **Coin**: Token operations and queries
+- **Bridge**: Cross-chain bridge operations (withdraw, execute)
+- **IBC**: Cross-chain IBC transfers
+
+### Staking & Governance
+- **Staking**: Delegate, undelegate, redelegate tokens
+- **Alliance**: Alliance module interactions
+- **Gov**: Governance proposals and voting
+- **Grant**: Authorization grants (authz module)
+
+### Advanced Features
+- **EVM**: Send transactions to the EVM module
+- **EvmMerge**: EVM merge module operations
+- **SubAccount**: Management of sub-accounts
+- **PerpPool**: Perpetual pool operations
+- **Broker**: Broker module functionality
+- **Fee**: Fee management and queries
+- **Oracle**: Oracle data queries
+
+### Admin Operations (Restricted)
+- **Admin**: Token creation, market creation, validator management, trading flags, and other administrative functions
+
+### Query Clients
+- **query**: Access to all chain query functions
+- **insights**: Analytics and insights data
+- **hydrogen**: Hydrogen API client
+- **token**: Token metadata and configuration
+
+## Important Types and Enums
+
+### Order Types
+```typescript
+OrderModule.OrderType.Limit           // Limit order
+OrderModule.OrderType.Market          // Market order
+OrderModule.OrderType.StopLimit       // Stop-limit order
+OrderModule.OrderType.StopMarket      // Stop-market order
+OrderModule.OrderType.TakeProfitLimit // Take-profit limit
+OrderModule.OrderType.TakeProfitMarket // Take-profit market
+```
+
+### Order Side
+```typescript
+OrderModule.OrderSide.Buy   // Buy order
+OrderModule.OrderSide.Sell  // Sell order
+```
+
+### Time In Force
+```typescript
+OrderModule.TimeInForce.Gtc  // Good Till Cancel
+OrderModule.TimeInForce.Fok  // Fill Or Kill
+OrderModule.TimeInForce.Ioc  // Immediate Or Cancel
+```
+
+### Trigger Type
+```typescript
+OrderModule.TriggerType.LastPrice   // Trigger on last price
+OrderModule.TriggerType.MarkPrice   // Trigger on mark price
+OrderModule.TriggerType.IndexPrice  // Trigger on index price
+```
+
+## Error Handling
+
+All SDK methods return Promises that may reject with errors. Always use try-catch blocks:
+
+```typescript
+try {
+  const result = await sdk.order.create({
+    marketId: 'btc_z29',
+    side: OrderModule.OrderSide.Buy,
+    orderType: OrderModule.OrderType.Limit,
+    price: new BigNumber(50000),
+    quantity: new BigNumber(0.1),
+  });
+  console.log('Order created:', result.txHash);
+} catch (error) {
+  console.error('Failed to create order:', error.message);
+}
+```
+

package/dist/OrbixSDK.d.ts

@@ -0,0 +1,145 @@
+import { Network, NetworkConfig, Network as _Network } from "./constant";
+import { Tendermint37Client } from "@cosmjs/tendermint-rpc";
+import * as clients from "./clients";
+import { OrbixQueryClient, HydrogenClient, InsightsQueryClient, TokenClient } from "./clients";
+import GasFee from "./clients/GasFee";
+import GrpcQueryClient from "./clients/GrpcQueryClient";
+import { AdminModule, AllianceModule, BankModule, BridgeModule, BrokerModule, CoinModule, EvmMergeModule, EvmModule, FeeModule, GovModule, IBCModule, LeverageModule, MarketModule, OracleModule, OrderModule, PerpspoolModule, PositionModule, SubAccountModule } from "./modules";
+import { GrantModule } from "./modules/grant";
+import { StakingModule } from "./modules/staking";
+import { CosmosLedger, Keplr, LeapExtended } from "./provider";
+import { MetaMask } from "./provider/metamask/MetaMask";
+import RainbowKitAccount from "./provider/rainbowKit/RainbowKitAccount";
+import { OrbixSigner, OrbixWallet, OrbixWalletGenericOpts, EvmWalletOpts, RainbowKitWalletOpts } from "./wallet";
+export { OrbixTx } from "./util";
+export { OrbixSigner, OrbixSignerTypes, OrbixWallet, OrbixWalletGenericOpts, OrbixWalletInitOpts } from "./wallet";
+export * as Orbix from "./codec/orbix-models";
+export interface OrbixSDKOpts {
+    network: Network;
+    tmClient: Tendermint37Client;
+    wallet?: OrbixWallet;
+    chainId?: string;
+    evmChainId?: string;
+    token?: TokenClient;
+    query?: OrbixQueryClient;
+    hydrogen?: HydrogenClient;
+    insights?: InsightsQueryClient;
+    config?: Partial<NetworkConfig>;
+    grpcQueryClient?: GrpcQueryClient;
+    useTmAbciQuery?: boolean;
+    defaultTimeoutBlocks?: number;
+    gasFee?: GasFee;
+}
+export interface OrbixSDKInitOpts {
+    network: Network;
+    tmClient?: Tendermint37Client;
+    config?: Partial<NetworkConfig>;
+    wallet?: OrbixWallet;
+    skipInit?: boolean;
+    defaultTimeoutBlocks?: number;
+    /**
+     * temporary flag to disable GRPC Query client service when required
+     * TODO: Deprecate when grpc query client is implemented across all networks
+     */
+    useTmAbciQuery?: boolean;
+}
+export interface OverrideConfig {
+    chainId: string;
+    evmChainId: string;
+}
+/**
+ * Orbix SDK
+ *
+ *
+ */
+declare class OrbixSDK {
+    static DEFAULT_NETWORK: Network;
+    static DenomPrefix: {
+        LPToken: string;
+        CDPToken: string;
+        PerpPoolToken: string;
+        UserVaultToken: string;
+    };
+    initialized: boolean;
+    readonly query: OrbixQueryClient;
+    readonly useTmAbciQuery: boolean;
+    insights: InsightsQueryClient;
+    hydrogen: HydrogenClient;
+    wallet?: OrbixWallet;
+    gasFee?: GasFee;
+    network: Network;
+    configOverride: Partial<NetworkConfig>;
+    networkConfig: NetworkConfig;
+    tmClient: Tendermint37Client;
+    token: TokenClient;
+    admin: AdminModule;
+    alliance: AllianceModule;
+    order: OrderModule;
+    perpspool: PerpspoolModule;
+    grant: GrantModule;
+    subaccount: SubAccountModule;
+    leverage: LeverageModule;
+    market: MarketModule;
+    broker: BrokerModule;
+    position: PositionModule;
+    coin: CoinModule;
+    oracle: OracleModule;
+    gov: GovModule;
+    staking: StakingModule;
+    bank: BankModule;
+    fee: FeeModule;
+    ibc: IBCModule;
+    evm: EvmModule;
+    evmmerge: EvmMergeModule;
+    bridge: BridgeModule;
+    chainId: string;
+    evmChainId: string;
+    constructor(opts: OrbixSDKOpts);
+    static instance(opts?: OrbixSDKInitOpts): Promise<OrbixSDK>;
+    static instanceWithWallet(wallet: OrbixWallet, sdkOpts?: OrbixSDKInitOpts): Promise<ConnectedOrbixSDK>;
+    static instanceWithPrivateKey(privateKey: string | Buffer, sdkOpts?: OrbixSDKInitOpts, walletOpts?: OrbixWalletGenericOpts): Promise<ConnectedOrbixSDK>;
+    static instanceWithMnemonic(mnemonic: string, sdkOpts?: OrbixSDKInitOpts, walletOpts?: OrbixWalletGenericOpts): Promise<ConnectedOrbixSDK>;
+    static instanceWithSigner(signer: OrbixSigner, publicKeyBase64: string, sdkOpts?: OrbixSDKInitOpts, walletOpts?: OrbixWalletGenericOpts): Promise<ConnectedOrbixSDK>;
+    static instanceWithLedger(ledger: CosmosLedger, sdkOpts?: OrbixSDKInitOpts, walletOpts?: OrbixWalletGenericOpts): Promise<ConnectedOrbixSDK>;
+    static instanceWithKeplr(keplr: Keplr, sdkOpts?: OrbixSDKInitOpts, walletOpts?: OrbixWalletGenericOpts): Promise<ConnectedOrbixSDK>;
+    static instanceWithLeap(leap: LeapExtended, sdkOpts?: OrbixSDKInitOpts, walletOpts?: OrbixWalletGenericOpts): Promise<ConnectedOrbixSDK>;
+    static instanceWithMetamask(metamask: MetaMask, sdkOpts?: OrbixSDKInitOpts, walletOpts?: OrbixWalletGenericOpts): Promise<ConnectedOrbixSDK>;
+    static instanceWithRainbowKit(rainbowKit: RainbowKitAccount, sdkOpts: OrbixSDKInitOpts | undefined, rainbowKitWalletOpts: RainbowKitWalletOpts, walletOpts?: OrbixWalletGenericOpts): Promise<ConnectedOrbixSDK>;
+    static instanceViewOnly(bech32Address: string, sdkOpts?: OrbixSDKInitOpts, walletOpts?: OrbixWalletGenericOpts): Promise<ConnectedOrbixSDK>;
+    initialize(): Promise<OrbixSDK>;
+    getGasFee(): Promise<GasFee>;
+    clone(): OrbixSDK;
+    generateOpts(): OrbixSDKOpts;
+    connect(wallet: OrbixWallet, opts?: OrbixWalletGenericOpts): Promise<ConnectedOrbixSDK>;
+    disconnect(): OrbixSDK;
+    connectWithPrivateKey(privateKey: string | Buffer, opts?: OrbixWalletGenericOpts): Promise<ConnectedOrbixSDK>;
+    connectWithMnemonic(mnemonic: string, opts?: OrbixWalletGenericOpts): Promise<ConnectedOrbixSDK>;
+    connectWithSigner(signer: OrbixSigner, publicKeyBase64: string, opts?: OrbixWalletGenericOpts): Promise<ConnectedOrbixSDK>;
+    connectWithLedger(ledger: CosmosLedger, opts?: OrbixWalletGenericOpts): Promise<ConnectedOrbixSDK>;
+    connectWithKeplr(keplr: Keplr, opts?: OrbixWalletGenericOpts): Promise<ConnectedOrbixSDK>;
+    connectWithLeap(leap: LeapExtended, opts?: OrbixWalletGenericOpts): Promise<ConnectedOrbixSDK>;
+    connectWithMetamask(metamask: MetaMask, opts?: OrbixWalletGenericOpts, evmWalletOpts?: EvmWalletOpts): Promise<ConnectedOrbixSDK>;
+    connectWithRainbowKit(rainbowKit: RainbowKitAccount, rainbowKitWalletOpts: RainbowKitWalletOpts, opts?: OrbixWalletGenericOpts): Promise<ConnectedOrbixSDK>;
+    connectViewOnly(bech32Address: string, opts?: OrbixWalletGenericOpts): Promise<ConnectedOrbixSDK>;
+    connectWithQr(granteeMnemonic: string, granterAddress: string, expiry: Date, opts?: OrbixWalletGenericOpts): Promise<ConnectedOrbixSDK>;
+    getConfig(): NetworkConfig;
+    getTokenClient(): TokenClient;
+    getConnectedWallet(): OrbixWallet;
+    log(...args: any[]): void;
+    private checkWallet;
+    static parseNetwork: (network: string, defaultNetwork?: Network | null) => Network | null;
+}
+export declare class ConnectedOrbixSDK extends OrbixSDK {
+    wallet: OrbixWallet;
+    constructor(wallet: OrbixWallet, opts: OrbixSDKOpts);
+    clone(): ConnectedOrbixSDK;
+}
+declare namespace OrbixSDK {
+    export import Network = _Network;
+    export import OrbixQueryClient = clients.OrbixQueryClient;
+    export import ETHClient = clients.ETHClient;
+    export import HydrogenClient = clients.HydrogenClient;
+    export import InsightsQueryClient = clients.InsightsQueryClient;
+    export import TokenClient = clients.TokenClient;
+}
+export default OrbixSDK;