SDK Reference

const rain = new Rain({
  environment: 'production',  // 'development' | 'stage' | 'production' (default: development)
  rpcUrl: 'https://arb1.arbitrum.io/rpc', // optional
  apiUrl: 'https://prod2-api.rain.one',   // optional, derived from environment
});

interface RawTransaction {
  to: `0x${string}`;
  data: `0x${string}`;
  value?: bigint;
}

import { RainAA } from 'rain-sdk-v2';

const rainAA = new RainAA({
  walletClient,             // viem WalletClient (required)
  alchemyApiKey: '...',     // required
  paymasterPolicyId: '...', // required
  chain: arbitrum,          // required
  rpcUrl: '...',            // optional
});

const smartAccountAddress = await rainAA.connect(); // init smart account
const hash = await rainAA.sendTransaction(rawTx);   // gas-sponsored send
rainAA.address;            // getter — smart account address (throws if not connected)
rainAA.client;             // getter — smart wallet client
rainAA.disconnect();       // reset connection state

const txs = await rain.buildCreateMarketTx({
  marketQuestion: 'Will ETH reach $5000 by end of year?',
  marketOptions: ['Yes', 'No'],
  marketTags: ['crypto'],
  marketDescription: 'Prediction on ETH price target',
  isPublic: true,
  isPublicPoolResolverAi: true,
  creator: '0x...',
  startTime: BigInt(Math.floor(Date.now() / 1000) + 120),
  endTime: BigInt(Math.floor(Date.now() / 1000) + 86400),
  no_of_options: 2n,
  disputeTimer: 259200,
  inputAmountWei: parseUnits('10', 6),
  barValues: [50, 50],
  initialYesPrices: [parseEther('0.5'), parseEther('0.5')], // optional
  baseToken: config.tokens.usdt.address,
  tradingModel: TradingModel.AMM, // AMM = 0, OrderBook = 1
  marketImage: 'https://cdn.example.com/market-image.png',
});

const txs = await rain.buildEnterOptionTx({
  marketContractAddress: '0x...',
  selectedOption: 1n,                 // 1-based
  optionSide: OptionSide.Yes,         // Yes = 1, No = 2
  buyAmountInWei: parseUnits('5', 6), // 5 USDT
  walletAddress: '0x...',
  slippageTolerance: 5n,              // optional, default 5%
  deadline: 600n,                     // optional, default 600s
});

const tx = await rain.buildSellOptionTx({
  marketContractAddress: '0x...',
  selectedOption: 1n,
  optionSide: OptionSide.Yes,
  sharesAmount: parseUnits('10', 6),  // shares to sell
  slippageTolerance: 5n,              // optional
  deadline: 600n,                     // optional
});

const txs = await rain.buildSplitTx({
  marketContractAddress: '0x...',
  option: 1n,
  amount: parseUnits('5', 6),
  walletAddress: '0x...',
});

const tx = rain.buildMergeTx({
  marketContractAddress: '0x...',
  option: 1n,
  amount: 5000000n, // raw shares (from getUserOptionShares)
});

const txs = await rain.buildAddLiquidityTx({
  marketContractAddress: '0x...',
  option: 1n,
  totalAmountInWei: parseUnits('10', 6),
  walletAddress: '0x...',
  slippageTolerance: 5n, // optional
  deadline: 600n,        // optional
});

const lpShares = await rain.getUserOptionLPShares({
  marketContractAddress: '0x...', option: 1n, userAddress: '0x...',
});
const tx = await rain.buildRemoveLiquidityTx({
  marketContractAddress: '0x...',
  option: 1n,
  lpShares,
  slippageTolerance: 5n, // optional
});

const txs = await rain.buildPlaceBuyOrderTx({
  marketContractAddress: '0x...',
  option: 1n,
  optionSide: OptionSide.Yes,
  price: parseEther('0.5'),       // 50% in 1e18 scale
  amount: parseUnits('10', 6),    // 10 USDT
  walletAddress: '0x...',
});

const tx = rain.buildPlaceSellOrderTx({
  marketContractAddress: '0x...',
  option: 1n,
  optionSide: OptionSide.Yes,
  price: parseEther('0.7'),  // 70%
  shares: 5000000n,          // from getUserOptionShares
});

const tx = rain.buildCancelBuyOrdersTx({
  marketContractAddress: '0x...',
  option: 1n,
  optionSides: [1, 1],                              // Yes, Yes
  prices: [parseEther('0.5'), parseEther('0.6')],
  orderIDs: [1n, 2n],                               // from PlaceBuyOrder event
});

// Close with AI resolver (after endTime)
const closeTxs = await rain.buildClosePoolAITx({ marketContractAddress: '0x...', option: 1n });

// Or close manually, proposing the winner
const closeManual = await rain.buildClosePoolManualTx({
  marketContractAddress: '0x...', option: 1n, proposedWinner: 1, // 1 = Yes
});

// After the dispute window: calculate the winner, then claim
const calcTx = await rain.buildCalculateWinnerTx({ marketContractAddress: '0x...', option: 1n });

const tx = rain.buildClaimTx({ marketContractAddress: '0x...', option: 1n });

// Call once to open a dispute; call again after the dispute window to appeal
const txs = await rain.buildOpenDisputeTx({ marketContractAddress: '0x...', option: 1n });

const tx = rain.buildApprovalTx({
  tokenAddress: config.tokens.usdt.address,
  spender: '0x...',                 // market contract
  amount: parseUnits('100', 6),
});

import { signLoginMessage } from 'rain-sdk-v2';

const signature = await signLoginMessage(walletClient, walletAddress);

const result = await rain.login({
  signature,
  walletAddress,                      // EOA address
  smartWalletAddress,                 // smart account address
  referredBy: 'CODE',                 // optional referral code
});
// result.accessToken — JWT for authenticated REST routes
// result.userId      — backend user ID

// Later: check token validity
const status = await rain.checkTokenExpiration(result.accessToken);

import { RainSocket } from 'rain-sdk-v2';

const socket = new RainSocket('https://dev-api.rain.one');
socket.connect();

const unsub = socket.onSyncPrice(poolId, (data) => {
  // data.prices = [{ side: 1, price: 0.62, percentage: 62, subPoolIndex: 1 }, ...]
});

socket.onChannel('custom-event/123', (data) => { /* generic subscription */ });

unsub();
socket.disconnect();

enum TradingModel {
  AMM = 0,
  OrderBook = 1,
}

enum OptionSide {
  Yes = 1,
  No = 2,
}

const config = rain.getEnvironmentConfig();
// config.apiUrl
// config.market_factory_address
// config.dispute_initial_timer
// config.tokens.usdt — { address, symbol, decimals, oracle_fixed_fee_per_option }
// config.tokens.rain — { address, symbol, decimals, oracle_fixed_fee_per_option }

const tokenInfo = rain.getTokenConfig('0x...'); // lookup by address, or null

1. Create Market        (buildCreateMarketTx)
2. Wait for startTime
3. Enter Option         (buildEnterOptionTx) / Split (buildSplitTx)
4. Place Orders         (buildPlaceBuyOrderTx / buildPlaceSellOrderTx)
5. Wait for endTime
6. Close Pool           (buildClosePoolAITx / buildClosePoolManualTx)
7. Calculate Winner     (buildCalculateWinnerTx)
8. Check claimed        (getOptionClaimed) — optional
9. Claim                (buildClaimTx)

If disputed:   6b. Open Dispute (buildOpenDisputeTx)  6c. Appeal (call again)
If extending:  5b. signOraclesExtendTime API → buildExtendTimeTx