Trading

npm install polynode-sdk viem better-sqlite3 @polymarket/clob-client @polymarket/builder-relayer-client @polymarket/builder-signing-sdk

import { PolyNodeTrader } from 'polynode-sdk';

const trader = new PolyNodeTrader({ polynodeKey: 'pn_live_...' });

// 1. Generate a wallet (or use an existing private key)
const { privateKey, address } = await PolyNodeTrader.generateWallet();
// SAVE THIS KEY. It is not stored anywhere. If you lose it, you lose access.

// 2. One call sets up everything: deploys a Safe, sets approvals, creates credentials.
//    Completely gasless. No MATIC needed. Takes ~10 seconds for a new wallet.
const status = await trader.ensureReady(privateKey);

// 3. Send USDC.e (Polygon) to the funder address. This is your trading wallet.
console.log('Send USDC.e here:', status.funderAddress);

// 4. Place an order
const result = await trader.order({
  tokenId: '...',  // Get token IDs from /v1/events/search or /v1/crypto/active
  side: 'BUY',
  price: 0.55,
  size: 100,
});

// 5. Cancel it
if (result.orderId) {
  await trader.cancelOrder(result.orderId);
}

import { PolyNodeTrader, createPrivySigner, createPrivyClient } from 'polynode-sdk';

// Set up Privy (one client for your whole app)
// createPrivyClient handles the wallet API config for you.
const privy = createPrivyClient({
  appId: process.env.PRIVY_APP_ID!,
  appSecret: process.env.PRIVY_APP_SECRET!,
  authorizationKey: process.env.PRIVY_AUTHORIZATION_KEY!,
});

// Create a signer for a specific user's wallet
const signer = createPrivySigner(privy, user.privyWalletId, user.walletAddress);

const trader = new PolyNodeTrader({ polynodeKey: 'pn_live_...' });

// Set up the wallet — gasless, ~10 seconds for new users
const status = await trader.ensureReady(signer);

// Send USDC.e to status.funderAddress, then trade
const result = await trader.order({ tokenId: '...', side: 'BUY', price: 0.55, size: 100 });

const trader = new PolyNodeTrader({ polynodeKey: 'pn_live_...' });
const status = await trader.ensureReady('0xYOUR_EXPORTED_KEY');

// Your USDC.e is already in the right place. Start trading.
const balance = await trader.checkBalance();
console.log(`USDC.e: $${balance.usdc}`);

trader.linkCredentials({
  wallet: '0xYOUR_EOA',
  apiKey: 'your-clob-api-key',
  apiSecret: 'your-clob-api-secret',
  apiPassphrase: 'your-clob-passphrase',
  signatureType: 2,
  funderAddress: '0xYOUR_SAFE',
});
await trader.linkWallet('0xYOUR_PRIVATE_KEY');

import { PolyNode } from 'polynode-sdk';
const pn = new PolyNode({ apiKey: 'pn_live_...' });

// Search for markets
const results = await pn.searchEvents('Bitcoin', { limit: 5 });
for (const event of results.events) {
  for (const market of event.markets) {
    console.log(market.question, '→', market.tokenId);
  }
}

const trader = new PolyNodeTrader({
  polynodeKey: 'pn_live_...',         // Your polynode API key
  dbPath: './my-trading.db',          // Local SQLite path (default: ./polynode-trading.db)
  cosignerUrl: 'https://trade.polynode.dev', // Relay URL (default)
  fallbackDirect: true,               // Fall back to direct CLOB if relay is down (default: true)
  rpcUrl: 'https://polygon-bor-rpc.publicnode.com', // RPC for on-chain reads (default)
  builderCredentials: {               // Optional: your own Polymarket builder credentials
    key: process.env.POLY_BUILDER_API_KEY!,
    secret: process.env.POLY_BUILDER_SECRET!,
    passphrase: process.env.POLY_BUILDER_PASSPHRASE!,
  },
  feeConfig: {                        // Optional: charge fees on orders
    feeBps: 50,                       // 0.5% fee (0 = no fee, default)
    affiliate: '0xPartner...',        // Partner wallet for revenue share
    affiliateShareBps: 3000,          // 30% to partner, 70% to treasury
  },
});

const trader = new PolyNodeTrader({
  polynodeKey: 'pn_live_...',
  builderCredentials: {
    key: process.env.POLY_BUILDER_API_KEY!,
    secret: process.env.POLY_BUILDER_SECRET!,
    passphrase: process.env.POLY_BUILDER_PASSPHRASE!,
  },
});

const trader = new PolyNodeTrader({
  polynodeKey: 'pn_live_...',
  feeConfig: { feeBps: 50 },  // 0.5% platform fee on every order (yours; not Polymarket's)
});

const result = await trader.order({
  tokenId: '...',
  side: 'BUY',
  price: 0.55,
  size: 100,
});

console.log(result.feeEscrowTxHash); // on-chain pullFee TX
console.log(result.feeAmount);       // "0.0275" USDC

// Cancel → fee is automatically refunded
await trader.cancelOrder(result.orderId);

const { privateKey, address } = await PolyNodeTrader.generateWallet();
// IMPORTANT: Save privateKey securely. It is not stored anywhere by the SDK.

const result = await trader.order({
  tokenId: '...',  // Market token ID (from /v1/events/search)
  side: 'BUY',     // 'BUY' or 'SELL'
  price: 0.55,     // Limit price (0 to 1)
  size: 100,       // Number of shares
  type: 'GTC',     // 'GTC' | 'GTD' | 'FOK' | 'FAK' (default: GTC)
});

if (result.success) {
  console.log('Order placed:', result.orderId);
  // When feeConfig is set:
  console.log('Fee TX:', result.feeEscrowTxHash);  // on-chain escrow TX
  console.log('Fee:', result.feeAmount);            // USDC charged
} else {
  console.log('Failed:', result.error);
}

const result = await trader.split({
  conditionId: '0x895e01db...', // market condition ID
  amount: 100,                   // $100 USDC
});
// result: { success: true, txHash: '0x...' }

const result = await trader.merge({
  conditionId: '0x895e01db...',
  amount: 50,
});

const result = await trader.convert({
  marketId: '0xc7d902c4...', // negRiskMarketID
  outcomeIndices: [0, 1],     // which outcomes to convert
  amount: 100,                // $100 per outcome
});