example-js-sdk

Mememax Orbix TypeScript SDK

Get Started

Initializing SDK

// 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

import BigNumber from "bignumber.js";
import { OrderModule } from "example-js-sdk";

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)

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

await sdk.order.edit({
  id: 'order_id_123',
  price: new BigNumber(51000),
  quantity: new BigNumber(0.2),
})

Cancel Multiple Orders

await sdk.order.cancelOrders([
  { id: 'order_id_123' },
  { id: 'order_id_456' },
])

IBC Transfer (V2)

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

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

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

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

await sdk.admin.setTradingFlag({
  isEnabled: true,
  blockchain: "orbix",
})

EVM: Send Transaction (Contract Call)

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:

{
  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:

{
  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

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

OrderModule.OrderSide.Buy   // Buy order
OrderModule.OrderSide.Sell  // Sell order

Time In Force

OrderModule.TimeInForce.Gtc  // Good Till Cancel
OrderModule.TimeInForce.Fok  // Fill Or Kill
OrderModule.TimeInForce.Ioc  // Immediate Or Cancel

Trigger Type

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:

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);
}