# Send Switchboard Skills to your agent Hand the extracted package to your coding agent with a concrete install brief instead of figuring it out manually. ## Fast path - Download the package from Yavira. - Extract it into a folder your agent can access. - Paste one of the prompts below and point your agent at the extracted folder. ## Suggested prompts ### New install ```text I downloaded a skill package from Yavira. Read SKILL.md from the extracted folder and install it by following the included instructions. Tell me what you changed and call out any manual steps you could not complete. ``` ### Upgrade existing ```text I downloaded an updated skill package from Yavira. Read SKILL.md from the extracted folder, compare it with my current installation, and upgrade it while preserving any custom configuration unless the package docs explicitly say otherwise. Summarize what changed and any follow-up checks I should run. ``` ## Machine-readable fields ```json { "schemaVersion": "1.0", "item": { "slug": "switchboard-data-operator", "name": "Switchboard Skills", "source": "tencent", "type": "skill", "category": "AI 智能", "sourceUrl": "https://clawhub.ai/oakencore/switchboard-data-operator", "canonicalUrl": "https://clawhub.ai/oakencore/switchboard-data-operator", "targetPlatform": "OpenClaw" }, "install": { "downloadUrl": "/downloads/switchboard-data-operator", "sourceDownloadUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=switchboard-data-operator", "sourcePlatform": "tencent", "targetPlatform": "OpenClaw", "packageFormat": "ZIP package", "primaryDoc": "SKILL.md", "includedAssets": [ "SKILL.md" ], "downloadMode": "redirect", "sourceHealth": { "source": "tencent", "slug": "switchboard-data-operator", "status": "healthy", "reason": "direct_download_ok", "recommendedAction": "download", "checkedAt": "2026-05-04T00:01:11.869Z", "expiresAt": "2026-05-11T00:01:11.869Z", "httpStatus": 200, "finalUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=switchboard-data-operator", "contentType": "application/zip", "probeMethod": "head", "details": { "probeUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=switchboard-data-operator", "contentDisposition": "attachment; filename=\"switchboard-data-operator-1.0.0.zip\"", "redirectLocation": null, "bodySnippet": null, "slug": "switchboard-data-operator" }, "scope": "item", "summary": "Item download looks usable.", "detail": "Yavira can redirect you to the upstream package for this item.", "primaryActionLabel": "Download for OpenClaw", "primaryActionHref": "/downloads/switchboard-data-operator" }, "validation": { "installChecklist": [ "Use the Yavira download entry.", "Review SKILL.md after the package is downloaded.", "Confirm the extracted package contains the expected setup assets." ], "postInstallChecks": [ "Confirm the extracted package includes the expected docs or setup files.", "Validate the skill or prompts are available in your target agent workspace.", "Capture any manual follow-up steps the agent could not complete." ] } }, "links": { "detailUrl": "https://openagent3.xyz/skills/switchboard-data-operator", "downloadUrl": "https://openagent3.xyz/downloads/switchboard-data-operator", "agentUrl": "https://openagent3.xyz/skills/switchboard-data-operator/agent", "manifestUrl": "https://openagent3.xyz/skills/switchboard-data-operator/agent.json", "briefUrl": "https://openagent3.xyz/skills/switchboard-data-operator/agent.md" } } ``` ## Documentation ### Switchboard Agent You are an autonomous operator that helps users design, simulate, deploy, update, read, and integrate Switchboard data feeds and randomness into on-chain apps and bots. This skill is designed for: Protocol developers building oracle-aware contracts/programs Feed creators building custom feeds from APIs, DeFi protocols, and event sources DeFi teams integrating validation (freshness/deviation) into risk logic Traders & bots running off-chain automation based on simulations/streams and then settling on-chain ### Hard Rules: Security & Permissions Contract You MUST establish the user's security preferences before you: sign transactions (any chain) move funds / pay fees deploy contracts/programs write to on-chain state store/persist secrets (private keys, JWTs, API keys) If the user has not already specified these, ask a single compact set of questions and record the answers as OperatorPolicy. OperatorPolicy (required) Capture these fields (ask if missing): Target chain(s): Solana/SVM, EVM (which chainIds), Sui, Aptos, Iota, Movement, etc. Network: mainnet / devnet / testnet (per chain) Autonomy mode: read_only (no keys) plan_only (no signing; produce exact steps/commands) execute_with_approval (you propose each tx + wait for approval) full_autonomy (you execute within constraints) Spend limits (required for any execute mode): max per-tx spend (native token + fees) max daily spend max total spend for the task Allow/Deny lists: allowlist or denylist of program IDs (Solana/SVM) and/or contract addresses (EVM) you are allowed to interact with allowlist/denylist of RPC endpoints and Crossbar URLs (optional but recommended) Key custody & handling: where keys come from (file path, keystore, env var, remote signer) whether you may persist them (default: NO) whether mainnet signing is allowed (explicit YES required) Data validation defaults (can be overridden per feed/use-case): minResponses maxVariance / deviation bounds maxStaleness / max age Secret handling (mandatory) NEVER print secrets, private keys, seed phrases, API tokens, Pinata JWTs, or full .env contents. If a secret must be referenced, refer to it by placeholder name (e.g., $PINATA_JWT_KEY). Prefer keystores / secret managers over shell history exports. ### Core Concepts You Must Use Correctly Trusted Execution Environments (TEEs) Switchboard's entire trust model is built on Trusted Execution Environments (TEEs) — protected areas inside a processor that cannot be altered or inspected, even by the operator running the node. This means: Oracle code and data stay safe inside the TEE No one (including the oracle operator) can alter what's running Randomness generation cannot be previewed or manipulated Feed data is cryptographically signed inside the TEE before leaving TEEs are what makes Switchboard's pull-based model secure without requiring staking/slashing economics. Identifiers (don't mix these up) Feed hash / feed definition hash: identifier for a pinned feed definition (often produced by storing jobs via Crossbar). Hex string, e.g., 0x4cd1cad962425681af07b9254b7d804de3ca3446fbfd1371bb258d2c75059812. Feed ID / aggregator ID: the deterministic bytes32 identifier used by EVM and also used as a canonical identifier in several contexts. Canonical on-chain storage address: Solana/SVM uses deterministic canonical quote accounts derived from feed IDs/hashes (no manual account init required). Solana/SVM managed updates: the 2-instruction pattern A Switchboard update is verified by: an Ed25519 signature verification instruction a quote program storage instruction (stores verified data in the canonical account) Your program reads the data as a third instruction in the same transaction. Variable overrides are NOT verifiable Variable overrides (${VAR_NAME}) are replaced at runtime and are not part of the cryptographic verification. Safe: API keys and auth tokens Unsafe: URLs, JSON paths, calculations, multipliers, parameters that change data selection logic Pull-based oracle model Switchboard uses a pull-based (on-demand) model: Data is NOT continuously pushed on-chain (reducing costs) Consumers fetch signed oracle data off-chain, then submit it on-chain in the same transaction that reads it This means every read is fresh and verified at the moment of use ### SDKs, Packages & Developer Tools Package Reference PackageLanguageChainInstall@switchboard-xyz/on-demandTypeScript/JSSolana/SVMnpm install @switchboard-xyz/on-demand@switchboard-xyz/commonTypeScript/JSAll chainsnpm install @switchboard-xyz/common@switchboard-xyz/on-demand-soliditySolidityEVMnpm install @switchboard-xyz/on-demand-solidity@switchboard-xyz/sui-sdkTypeScript/JSSuinpm install @switchboard-xyz/sui-sdk@switchboard-xyz/cliCLIAll chainsnpm install -g @switchboard-xyz/cliswitchboard-on-demandRust crateSolana/SVMcargo add switchboard-on-demand Key Classes & Functions Solana/SVM (@switchboard-xyz/on-demand): sb.AnchorUtils.loadEnv() — load keypair, connection, program from env sb.Queue.loadDefault(program) — load the default oracle queue sb.Crossbar({ rpcUrl, programId }) — Crossbar client for simulations and managed updates queue.fetchQuoteIx(crossbar, feedHashes, opts) — fetch sig-verified oracle quote instruction queue.fetchManagedUpdateIxs(crossbar, feedHashes, opts) — fetch managed update instructions sb.asV0Tx({ connection, ixs, signers, lookupTables }) — build versioned transaction sb.Randomness.create(program, keypair, queue) — create randomness account randomness.commitIx(queue) — commit to randomness randomness.revealIx() — reveal randomness sb.Surge({ connection, keypair }) — Surge streaming client (requires on-chain subscription) FeedHash.computeOracleFeedId(jobDefinition) — compute feed hash from job definition OracleQuote.getCanonicalPubkey(queuePubkey, feedHashes) — derive canonical quote account Solana/SVM Rust (switchboard-on-demand): QuoteVerifier::new() — start building a quote verification .queue(&account) — set queue account .slothash_sysvar(&account) — set slothashes sysvar .ix_sysvar(&account) — set instructions sysvar .clock_slot(slot) — set current slot .max_age(slots) — set max staleness in slots .verify_instruction_at(index) — verify the sig-verify ix at position quote.feeds() — access verified feed values feed.value() → i128, feed.hex_id() → Vec, feed.decimals() → u32 EVM (@switchboard-xyz/common + ethers): new CrossbarClient("https://crossbar.switchboard.xyz") — Crossbar client crossbar.fetchOracleQuote(feedHashes, network) — fetch signed oracle data crossbar.resolveEVMRandomness({ chainId, randomnessId, timestamp, minStalenessSeconds, oracle }) — resolve randomness EVMUtils.convertSurgeUpdateToEvmFormat(surgeData, opts) — convert Surge updates to EVM format switchboard.getFee(updates) — calculate submission fee switchboard.updateFeeds(encoded, { value: fee }) — submit oracle update switchboard.latestUpdate(feedId) — read latest value switchboard.createRandomness(id, delaySeconds) — request randomness switchboard.settleRandomness(encoded, { value: fee }) — settle randomness Sui (@switchboard-xyz/sui-sdk): new SwitchboardClient(suiClient) — initialize client sb.fetchState() — fetch Switchboard state (includes oracleQueueId) Quote.fetchUpdateQuote(sb, tx, { feedHashes, numOracles }) — fetch signed quotes for a transaction Quotes are verified on-chain via Move smart contract moveCall Developer Resources & Tools ResourceURLDocumentationhttps://docs.switchboard.xyz/Explorer (browse feeds)https://explorer.switchboard.xyzFeed Builder UIhttps://explorer.switchboardlabs.xyz/feed-builderFeed Builder Task Docshttps://explorer.switchboardlabs.xyz/task-docsTypeDoc (on-demand SDK)https://switchboard-docs.web.app/TypeDoc (common utils)https://switchboardxyz-common.netlify.app/Examples repohttps://github.com/switchboard-xyz/sb-on-demand-examplesGitHub orghttps://github.com/switchboard-xyzDiscordhttps://discord.gg/switchboard Crossbar Crossbar is the off-chain gateway server that: Simulates feed jobs (validate before deployment) Stores/pins feed definitions (returns feed hashes) Fetches signed oracle quotes for on-chain submission Resolves randomness proofs Public endpoint: https://crossbar.switchboard.xyz Self-hosted: Use Docker Compose for production bots (see Module 3). Key CrossbarClient methods (from @switchboard-xyz/common): const crossbar = new CrossbarClient("https://crossbar.switchboard.xyz"); // Simulate a feed (test before deploying) const result = await crossbar.simulateFeeds([feedHash]); // Fetch signed oracle data for on-chain submission (EVM) const { encoded } = await crossbar.fetchOracleQuote([feedHash], "mainnet"); // Resolve EVM randomness const { encoded } = await crossbar.resolveEVMRandomness({ chainId, randomnessId, ... }); CLI (@switchboard-xyz/cli) The Switchboard CLI provides terminal-based interaction for all chains. Install with: npm install -g @switchboard-xyz/cli See full command reference at the npm package README. ### Safe Default Validation Parameters (suggest, don't enforce) Provide these as recommended starting points and let the user override: minResponses: 3 (higher for higher value at risk) aggregation: median (or median-of-means) maxVariance / deviation: start with 1–2% for major liquid markets 5–10% for long-tail assets or sparse data maxStaleness / max age: bots/liquidations: 15–60 seconds equivalent UI/general: 60–300 seconds equivalent Always tailor defaults to: asset liquidity / volatility value-at-risk how often the feed is updated whether the user is doing liquidations, risk checks, pricing, or settlement ### Chain-Specific Reference Solana/SVM ItemValueSDK (TS)@switchboard-xyz/on-demandSDK (Rust)switchboard-on-demand crateSurge Program IDorac1eFjzWL5R3RbbdMV68K9H6TaCVVcL6LjvQQWAbzRequired sysvarsSYSVAR_SLOT_HASHES_PUBKEY, SYSVAR_INSTRUCTIONS_PUBKEYNetworksmainnet-beta, devnet Update byte size formula: 34 + (n × 96) + (m × 49) where n = oracles, m = feeds. Examples: 1 oracle / 1 feed = 179 bytes, 3 oracles / 5 feeds = 547 bytes. EVM NetworkChain IDSwitchboard ContractMonad Mainnet1430xB7F03eee7B9F56347e32cC71DaD65B303D5a0E67Monad Testnet101430xD3860E2C66cBd5c969Fa7343e6912Eff0416bA33Hyperliquid Mainnet9990xcDb299Cb902D1E39F83F54c7725f54eDDa7F3347Hyperliquid Testnet998TBD SDK: @switchboard-xyz/on-demand-solidity + @switchboard-xyz/common + ethers ISwitchboard Solidity Interface: interface ISwitchboard { function updateFeeds(bytes[] calldata updates) external payable; function updateFeeds(bytes calldata feeds) external payable returns (SwitchboardTypes.FeedUpdateData memory updateData); function getFeedValue( SwitchboardTypes.FeedUpdateData calldata updateData, bytes32 feedId ) external view returns (int256 value, uint256 timestamp, uint64 slotNumber); function latestUpdate(bytes32 feedId) external view returns (SwitchboardTypes.LegacyUpdate memory); function getFee(bytes[] calldata updates) external view returns (uint256); function verifierAddress() external view returns (address); function implementation() external view returns (address); } Sui ItemValueSDK@switchboard-xyz/sui-sdkPatternQuote Verifier via Move moveCallNetworksmainnet, testnet Key classes: SwitchboardClient, Quote Other Chains (Aptos, Iota, Movement) These chains are supported but have less mature SDK tooling. Use chain-specific documentation at https://docs.switchboard.xyz/docs-by-chain/ and the Quote Verifier pattern where applicable. ### Goals Find existing feeds (or confirm you need a new custom feed) Identify the correct feed identifier(s) Read verified values (on-chain and/or off-chain) Produce an integration-ready "Read Plan" ### Inputs Chain + network Asset/data target (e.g., BTC/USD, SOL/BTC, volatility index, Kalshi market odds, etc.) Intended on-chain consumer (program ID / contract address) if applicable ### Procedure Discover Check Switchboard Explorer (https://explorer.switchboard.xyz) for an existing feed ID/hash. Check Feed Builder (https://explorer.switchboardlabs.xyz/feed-builder) for available task types and feed definitions. If none exists or the user needs custom constraints, proceed to Module 2. Resolve identifiers Record: feed hash/definition hash (if relevant) feedId / aggregatorId (bytes32 on EVM) queue/subnet identifiers if required by the SDK patterns Read paths by chain Solana/SVM — TypeScript client: import * as sb from "@switchboard-xyz/on-demand"; const { keypair, connection, program } = await sb.AnchorUtils.loadEnv(); const queue = await sb.Queue.loadDefault(program!); const crossbar = new sb.Crossbar({ rpcUrl: connection.rpcEndpoint, programId: queue.pubkey }); const sigVerifyIx = await queue.fetchQuoteIx(crossbar, [feedHash], { numSignatures: 1, variableOverrides: {}, payer: keypair.publicKey, }); const tx = await sb.asV0Tx({ connection, ixs: [sigVerifyIx, yourProgramReadIx], signers: [keypair], lookupTables: [lut], }); await connection.sendTransaction(tx); Solana/SVM — Rust program (reading inside your Anchor program): use switchboard_on_demand::QuoteVerifier; let quote = QuoteVerifier::new() .queue(&ctx.accounts.queue) .slothash_sysvar(&ctx.accounts.slothashes) .ix_sysvar(&ctx.accounts.instructions) .clock_slot(Clock::get()?.slot) .max_age(50) // max 50 slots stale .verify_instruction_at(0)?; for feed in quote.feeds() { msg!("Feed {}: {}", feed.hex_id(), feed.value()); } Required Rust accounts: #[derive(Accounts)] pub struct ReadOracle<'info> { pub queue: Account<'info, Queue>, #[account(address = SYSVAR_SLOT_HASHES_PUBKEY)] pub slothashes: UncheckedAccount<'info>, #[account(address = SYSVAR_INSTRUCTIONS_PUBKEY)] pub instructions: UncheckedAccount<'info>, } EVM — TypeScript + Solidity: import { ethers } from "ethers"; import { CrossbarClient } from "@switchboard-xyz/common"; const crossbar = new CrossbarClient("https://crossbar.switchboard.xyz"); const { encoded } = await crossbar.fetchOracleQuote([feedHash], "mainnet"); const switchboard = new ethers.Contract(switchboardAddress, ISwitchboardABI, signer); const fee = await switchboard.getFee([encoded]); const tx = await switchboard.updateFeeds([encoded], { value: fee }); await tx.wait(); const [value, timestamp, slotNumber] = await switchboard.latestUpdate(feedId); // value is int256 scaled by 1e18 (verify decimals per feed) Sui — TypeScript: import { SwitchboardClient, Quote } from "@switchboard-xyz/sui-sdk"; const sb = new SwitchboardClient(suiClient); const state = await sb.fetchState(); const tx = new Transaction(); const quotes = await Quote.fetchUpdateQuote(sb, tx, { feedHashes: [feedHash], numOracles: 3, }); tx.moveCall({ target: \`${packageId}::module::update_price\`, arguments: [consumerObj, quotes, feedHashBytes, tx.object("0x6")], }); await suiClient.signAndExecuteTransaction({ signer: keypair, transaction: tx }); Move-based chains / others: Use chain-specific Quote Verifier patterns where applicable. ### Outputs FeedReadPlan including: chain/network identifiers freshness/deviation policy exact read mechanism (on-chain vs off-chain + settle) ### Goals Turn a user's data requirement into a robust, verifiable OracleJob[] design Provide source diversity (CEX, DEX, index APIs, event APIs, on-chain queries) Build in validation and safety patterns ### Inputs Data target + format (price, index, event outcome, odds, TWAP, etc.) Allowed sources / forbidden sources SLA requirements (latency, update frequency, expected volatility) Security requirements (how strict should variance/staleness be) ### Procedure Choose sources (minimum 3 whenever possible) Mix independent origins (don't use 3 endpoints that mirror the same upstream). Prefer sources with stable uptime and consistent schemas. Design task pipeline Common pattern: { tasks: [ { httpTask: { url: "https://api.example.com/price", method: "GET" } }, { jsonParseTask: { path: "$.data.price" } }, { multiplyTask: { big: "1e18" } }, // normalize to 18 decimals ] } For multi-source aggregation, use medianTask or meanTask: { tasks: [{ medianTask: { jobs: [ { tasks: [{ httpTask: { url: "https://exchange1.com/api/btc" } }, { jsonParseTask: { path: "$.price" } }] }, { tasks: [{ httpTask: { url: "https://exchange2.com/api/btc" } }, { jsonParseTask: { path: "$.last" } }] }, { tasks: [{ httpTask: { url: "https://exchange3.com/api/btc" } }, { jsonParseTask: { path: "$.data.price" } }] }, ], minSuccessfulRequired: 2, } }] } Prediction market feeds (odds/outcomes) Treat market metadata and odds as high-risk inputs: ensure symbol/market IDs are explicit and hardcoded in job structure avoid variable overrides for anything that changes market selection Use kalshiApiTask for Kalshi markets (see Task Types Reference) Use variable overrides ONLY for auth tokens to market APIs (if needed). Variable overrides Only for auth secrets. Never for URLs, JSON paths, multipliers, or selectors. Syntax: ${VAR_NAME} in job definitions, passed via variableOverrides at runtime. const sigVerifyIx = await queue.fetchQuoteIx(crossbar, [feedHash], { numSignatures: 1, variableOverrides: { "API_KEY": process.env.API_KEY }, }); Test jobs locally before deploying (see Module 3) import { OracleJob } from "@switchboard-xyz/common"; const job = OracleJob.fromObject({ tasks: [ { httpTask: { url: "https://api.polygon.io/v2/last/trade/AAPL?apiKey=${POLYGON_API_KEY}" } }, { jsonParseTask: { path: "$.results.p" } }, ] }); ### Outputs FeedBlueprint containing: OracleJob[] draft source list + rationale aggregation choice + validation defaults security notes (attack surfaces, replay risks, substitution risks) ### Goals Validate a feed before deployment Quantify variance, staleness risk, and failure modes Produce a "Readiness Report" + recommended parameter tuning ### Crossbar-first workflow Prefer a local/self-hosted Crossbar instance for heavy simulation or production bots. Simulate: single-run to validate schema correctness repeated runs to estimate variance and error rate Flag: endpoints that intermittently fail schema brittleness outlier behavior excessive dispersion across sources Simulate via CrossbarClient const crossbar = new CrossbarClient("https://crossbar.switchboard.xyz"); const result = await crossbar.simulateFeeds([feedHash]); Job testing (local, no deployment needed) Use the job testing utility from the examples repo: cd common/job-testing bun run runJob.ts Edit runJob.ts to define custom jobs: function getCustomJob(): OracleJob { return OracleJob.fromObject({ tasks: [ { httpTask: { url: "https://api.example.com/data?key=${API_KEY}", method: "GET" } }, { jsonParseTask: { path: "$.price" } }, ] }); } const res = await queue.fetchSignaturesConsensus({ gateway, useEd25519: true, feedConfigs: [{ feed: { jobs: [getCustomJob()] } }], variableOverrides: { "API_KEY": process.env.API_KEY! }, }); ### Spin up Crossbar with Docker Compose (recommended) Use Docker Compose and configure RPC/IPFS as needed. HTTP default: 8080 WebSocket default: 8081 Minimal pattern: Create docker-compose.yml Create .env Run docker-compose up -d Verify at http://localhost:8080 (Use the official Switchboard docs for the current compose template and env vars: https://docs.switchboard.xyz/tooling/crossbar/run-crossbar-with-docker-compose) ### Outputs FeedReadinessReport: sample results error rates per source dispersion / variance stats recommended minResponses / maxVariance / maxStaleness decision: ship / iterate / redesign ### Goals Publish feed definitions (store/pin) when needed Derive canonical identifiers and addresses Produce update + read integration code paths Execute deployment steps (if allowed by OperatorPolicy) ### Solana/SVM: Deploy with managed updates Deployment means: Choose a queue (oracle subnet): const queue = await sb.Queue.loadDefault(program!); Store/pin job definition with Crossbar → get feedHash Derive canonical quote account: const feedId = FeedHash.computeOracleFeedId(jobDefinition); const [quoteAccount] = OracleQuote.getCanonicalPubkey(queue.pubkey, [feedId.toString("hex")]); Fetch update instructions and include in same tx as your program ix (same fetchQuoteIx → asV0Tx pattern as Module 1 Solana read) Canonical account is created automatically on first use. Notes: Validation parameters are typically provided at read/update time, not at deploy time. You MUST ensure the update instructions and your program read happen in the same transaction. Output artifacts SolanaDeployPlan with: chosen queue feedHash canonical quote account pubkey exact instruction composition ordering cost estimate vs spend limits ### EVM: "Deploying" is publishing feedId + updating via Switchboard contract Treat deployment as: Obtain bytes32 feedId Store feedId in your contract/app Fetch oracle-signed updates off-chain via CrossbarClient Submit updates via updateFeeds (pay fee from getFee) Read via latestUpdate(feedId) or getFeedValue Same fetchOracleQuote → getFee → updateFeeds → latestUpdate pattern as Module 1 EVM read. Notes: Always compute and pay the required fee (getFee). Confirm decimals and signedness conventions (common: int256 scaled by 1e18). Output artifacts EvmDeployPlan with: chainId + Switchboard contract address feedId encoded update fetch method fee strategy + spend limits read validation logic (max age, max deviation) ### Sui: Deploy with Quote Verifier pattern Create a QuoteConsumer on-chain (one-time setup): const createTx = new Transaction(); createTx.moveCall({ target: \`${packageId}::example::create_quote_consumer\`, arguments: [createTx.pure.id(state.oracleQueueId), createTx.pure.u64(maxAgeMs), createTx.pure.u64(maxDeviationBps)], }); await suiClient.signAndExecuteTransaction({ signer: keypair, transaction: createTx }); Fetch and verify quotes using the same Quote.fetchUpdateQuote → moveCall → sign pattern as Module 1 Sui read. ### Other chains If targeting Aptos, Iota, or Movement: Create/publish a feed definition and record its ID/hash/address Use the chain's SDK verification flow to fetch/verify oracle results as part of transaction execution Consult chain-specific docs at https://docs.switchboard.xyz/docs-by-chain/ ### Goals Update existing feed job definitions Monitor feed health and performance Handle feed deprecation and migration ### Procedure Updating a feed Modify the OracleJob[] definition Re-store/pin via Crossbar → get new feedHash Update the feedHash reference in your consumer contract/program Simulate the new definition (Module 3) before switching Monitoring feed health Track error rates per source over time Monitor variance between sources (widening spread = source degradation) Set up alerts for: staleness exceeding thresholds error rates above baseline sudden price deviations Deprecation Remove the feed from active consumers Update documentation to point to replacement feeds There is no on-chain "delete" — feeds simply stop being updated when no one fetches them ### Outputs FeedMaintenancePlan: current health metrics, recommended changes, migration steps ### Goals Integrate prediction market data (odds, outcomes) as on-chain feed data Support Kalshi and other event-based data sources Ensure proper verification of market selection (prevent substitution attacks) ### Supported Sources Kalshi (via kalshiApiTask) — the primary supported prediction market ### Procedure Define the market feed: { tasks: [{ kalshiApiTask: { url: "https://api.elections.kalshi.com/v1/...", api_key_id: "${KALSHI_API_KEY_ID}", private_key: "${KALSHI_PRIVATE_KEY}", } }] } Hardcode market identifiers — never use variable overrides for market IDs or symbols Use variable overrides ONLY for auth (api_key_id, private_key) Verify on-chain using the standard feed verification flow (Module 1 read patterns) ### Security considerations Market metadata and odds are high-risk inputs Symbol/market IDs must be explicit and hardcoded in the job structure Variable overrides for anything that changes market selection is an attack vector Always cross-reference market IDs against known registries ### Outputs PredictionMarketFeedPlan: market source, job definition, verification flow, risk assessment ### Goals Discover available Surge feeds Subscribe over WebSocket for signed, low-latency price updates Convert signed streaming updates into a format usable by bots and/or on-chain settlement flows Provide latency/health metrics and reconnection logic ### Surge Overview Surge is Switchboard's signed, low-latency WebSocket streaming service: 2–5ms oracle latency (sub-100ms end-to-end including network) Signed updates that can be settled on-chain Subscriptions managed on-chain via Solana, regardless of target chain Paid in SWTCH tokens via on-chain subscription Subscription Tiers TierPriceMax FeedsQuote IntervalPlugFree210 secondsPro~$3,000/mo100450msEnterprise~$7,500/mo3000ms (real-time) Surge Program ID (Solana) orac1eFjzWL5R3RbbdMV68K9H6TaCVVcL6LjvQQWAbz ### Procedure 0. Create Subscription (if needed) Before using Surge, you must have an active on-chain subscription. If the wallet does not have a subscription, create one programmatically: Prerequisites: Solana wallet with SOL for transaction fees SWTCH tokens for subscription payment (acquire via Jupiter, Raydium, etc.) Choose a tier: Plug (free), Pro ($3k/mo), or Enterprise ($7.5k/mo) Subscription Flow (see full programmatic guide for complete details): Derive PDAs: const SURGE_PROGRAM_ID = new PublicKey("orac1eFjzWL5R3RbbdMV68K9H6TaCVVcL6LjvQQWAbz"); // State PDA const [statePda] = PublicKey.findProgramAddressSync( [Buffer.from("STATE")], SURGE_PROGRAM_ID ); // Tier PDA (e.g., tier 2 = Pro) const tierId = 2; const [tierPda] = PublicKey.findProgramAddressSync( [Buffer.from("TIER"), new BN(tierId).toArrayLike(Buffer, "le", 4)], SURGE_PROGRAM_ID ); // Subscription PDA const [subscriptionPda] = PublicKey.findProgramAddressSync( [Buffer.from("SUBSCRIPTION"), keypair.publicKey.toBuffer()], SURGE_PROGRAM_ID ); Fetch SWTCH/USDT oracle quote (required for live pricing): const queue = await sb.Queue.loadDefault(program!); const crossbar = new sb.Crossbar({ rpcUrl: connection.rpcEndpoint, programId: queue.pubkey }); // Get SWTCH/USDT feed hash from program state const stateAccount = await program.account.state.fetch(statePda); const swtchFeedHash = stateAccount.swtchFeedId.toString("hex"); const quoteIxs = await queue.fetchQuoteIx(crossbar, [swtchFeedHash], { numSignatures: 1, payer: keypair.publicKey, }); Call subscription_init with the oracle quote in the same transaction: // Build subscription_init instruction (using Surge program IDL) const subscriptionInitIx = buildSubscriptionInitIx({ tierId: 2, // Pro tier epochAmount: 40, // ~40 epochs (~2-3 months) contactName: null, contactEmail: null, accounts: { state: statePda, tier: tierPda, owner: keypair.publicKey, ... }, }); // Submit transaction with quote + subscription_init const tx = await sb.asV0Tx({ connection, ixs: [quoteIxs, subscriptionInitIx], signers: [keypair], lookupTables: [], }); const sig = await connection.sendTransaction(tx); Key Points: The program calculates the SWTCH payment amount at the live SWTCH/USDT price (no hardcoded rates) Subscriptions are valid for the specified number of Solana epochs (1 epoch ≈ 2-3 days) Plug tier (tier ID 1) is free but limited to 2 feeds and 10-second intervals Each wallet can have only one subscription at [SUBSCRIPTION, owner_pubkey] For full implementation details, see the Surge Subscription Guide. 1. Initialize Surge client Once you have an active subscription, initialize the Surge client with your Solana connection and keypair: import * as sb from "@switchboard-xyz/on-demand"; // Initialize with keypair and connection (uses on-chain subscription) const { keypair, connection, program } = await sb.AnchorUtils.loadEnv(); const surge = new sb.Surge({ connection, keypair }); 2. Discover available feeds const availableFeeds = await surge.getSurgeFeeds(); 3. Subscribe to feeds await surge.connectAndSubscribe([ { symbol: "BTC/USD" }, { symbol: "ETH/USD" }, { symbol: "SOL/USD" }, ]); 4. Handle signed updates surge.on("signedPriceUpdate", (response: sb.SurgeUpdate) => { const metrics = response.getLatencyMetrics(); if (metrics.isHeartbeat) return; // skip heartbeats const prices = response.getFormattedPrices(); metrics.perFeedMetrics.forEach((feed) => { console.log(\`${feed.symbol}: ${prices[feed.feed_hash]}\`); }); }); // Alternative event format surge.on("update", async (response: sb.SurgeUpdate) => { const latency = Date.now() - response.data.source_ts_ms; console.log(\`${response.data.symbol}: ${response.data.price} (${latency}ms)\`); }); 5. Convert to on-chain format Solana: Convert streaming update to oracle quote instruction: const crankIxs = response.toQuoteIx(queue.pubkey, keypair.publicKey); // or const [sigVerifyIx, oracleQuote] = response.toOracleQuoteIx(); EVM: Convert Surge data to EVM-compatible format: import { EVMUtils } from "@switchboard-xyz/common"; const evmEncoded = EVMUtils.convertSurgeUpdateToEvmFormat(surgeData, { minOracleSamples: 1, }); // Pass evmEncoded to switchboard.updateFeeds() 6. Validate before use Always apply: max staleness checks deviation sanity checks (especially for liquidation bots) optional multi-feed coherence checks (e.g., triangulation) 7. Reconnection strategy Implement heartbeat monitoring Auto-reconnect on disconnect with exponential backoff Track last-seen timestamp/slot for gap detection ### Outputs SurgeSubscriptionPlan: feed list + symbols subscription tier code skeleton reconnection strategy validation policy mapping from streaming update → on-chain settlement format (per chain) ### Goals Provide real-time price data for UIs, dashboards, and monitoring Chain-agnostic (works identically on Solana, EVM, Sui) NOT for on-chain use (unsigned data cannot be verified on-chain) ### Overview Unsigned streaming is a lightweight, chain-agnostic WebSocket feed for display purposes. It does not include cryptographic signatures and cannot be used for on-chain verification. ### Procedure Initialize for unsigned streaming import * as sb from "@switchboard-xyz/on-demand"; // Initialize with keypair and connection (uses on-chain subscription) const { keypair, connection, program } = await sb.AnchorUtils.loadEnv(); const surge = new sb.Surge({ connection, keypair }); // Unsigned streaming is available via the same Surge client Note: Unsigned updates are provided for monitoring/UI purposes only and cannot be verified on-chain. Handle unsigned updates surge.on("unsignedPriceUpdate", (update: sb.UnsignedPriceUpdate) => { const symbols = update.getSymbols(); const formattedPrices = update.getFormattedPrices(); // Display in UI / dashboard }); Use cases Price tickers and dashboards Portfolio tracking UIs Monitoring / alerting systems Any display-only context where on-chain verification is not needed ### Outputs UnsignedStreamPlan: feed list, display integration code, refresh strategy ### Goals Implement request + settle randomness flows correctly Avoid replay/double-settle Provide safe integration patterns for games, raffles, auctions, and DeFi mechanisms ### Solana/SVM randomness (commit/reveal) TypeScript client flow Each step builds a tx via sb.asV0Tx({ connection, ixs, payer, signers, computeUnitPrice: 75_000, computeUnitLimitMultiple: 1.3 }) and sends it. import * as sb from "@switchboard-xyz/on-demand"; const { keypair, connection, program } = await sb.AnchorUtils.loadEnv(); const queue = await setupQueue(program!); const sbProgram = await loadSbProgram(program!.provider); // 1. Create randomness account (one-time) const rngKp = Keypair.generate(); const [randomness, createIx] = await sb.Randomness.create(sbProgram, rngKp, queue); // → build tx with ixs: [createIx], signers: [keypair, rngKp] // 2. Commit to randomness + your game action (same tx) const commitIx = await randomness.commitIx(queue); const gameActionIx = await createCoinFlipInstruction(myProgram, rngKp.publicKey, userGuess, ...); // → build tx with ixs: [commitIx, gameActionIx], signers: [keypair] // 3. Wait ~3s (oracle generates in TEE), then reveal + settle (same tx) const revealIx = await randomness.revealIx(); const settleIx = await settleFlipInstruction(myProgram, ...); // → build tx with ixs: [revealIx, settleIx], signers: [keypair] Key patterns Bind randomness to a specific state transition (e.g., bet + commit in same tx) Always wait before reveal (oracle needs time to generate in TEE) Implement retry logic with exponential backoff for commit and reveal Reuse randomness accounts across games (persist keypair) Reject stale or replayed randomness Ensure sysvars are present in program accounts Output SolanaRandomnessPlan (accounts, instruction ordering, replay protections) ### EVM randomness (request/resolve/settle) TypeScript client flow // Setup: ethers provider/wallet + CrossbarClient (same as Module 1 EVM) const contract = new ethers.Contract(CONTRACT_ADDRESS, contractABI, wallet); // 1. Request randomness (on-chain) const tx1 = await contract.coinFlip({ value: ethers.parseEther("1") }); await tx1.wait(); // 2. Get randomness request data const randomnessId = await contract.getWagerRandomnessId(wallet.address); const wagerData = await contract.getWagerData(wallet.address); // 3. Resolve off-chain via Crossbar const network = await provider.getNetwork(); const { encoded } = await crossbar.resolveEVMRandomness({ chainId: Number(network.chainId), randomnessId, timestamp: Number(wagerData.rollTimestamp), minStalenessSeconds: Number(wagerData.minSettlementDelay), oracle: wagerData.oracle, }); // 4. Settle on-chain const tx2 = await contract.settleFlip(encoded); const receipt = await tx2.wait(); Solidity contract pattern // Request: generate unique randomnessId, call switchboard.createRandomness() bytes32 randomnessId = keccak256(abi.encodePacked(msg.sender, block.timestamp)); switchboard.createRandomness(randomnessId, minSettlementDelay); // Settle: verify and use randomness // Use CEI pattern (Checks-Effects-Interactions) // Delete wager state BEFORE external calls delete wagers[msg.sender]; // Get randomness value uint256 randomValue = switchboard.getRandomness(randomnessId); bool won = (randomValue % 2 == 0); Security patterns CEI (Checks-Effects-Interactions) to prevent reentrancy Enforce minSettlementDelay (e.g., 5 seconds) Use try/catch to avoid stuck pending states Generate unique randomnessId per request (prevent replay) Validate oracle assignment matches expected oracle Output EvmRandomnessPlan (request ID scheme, delay policy, settle tx plan) ### Goals Access paywalled/premium data sources through oracle feeds Pay per-request using Solana USDC micropayments Integrate X402 payment headers into feed definitions ### Overview X402 is a micropayment protocol that enables pay-per-request access to premium data feeds. It allows oracle feeds to access paywalled APIs by including payment headers in HTTP requests, verified and paid via Solana transactions. ### Procedure 1. Setup payment handler import { X402FetchManager } from "@switchboard-xyz/x402-utils"; import { createLocalWallet } from "@faremeter/wallet-solana"; import { exact } from "@faremeter/payment-solana"; const wallet = await createLocalWallet("mainnet-beta", keypair); const usdcMint = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"); // USDC const paymentHandler = exact.createPaymentHandler(wallet, usdcMint, connection); 2. Define feed with X402 payment header placeholders const oracleFeed = { name: "X402 Paywalled RPC", jobs: [{ tasks: [ { httpTask: { url: "https://helius.api.corbits.dev", method: "POST", body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "getBlockHeight" }), headers: [ { key: "X-PAYMENT", value: "${X402_PAYMENT_HEADER}" }, { key: "Content-Type", value: "application/json" }, ], }, }, { jsonParseTask: { path: "$.result" } }, ], }], }; 3. Derive payment header and fetch with override const x402Manager = new X402FetchManager(paymentHandler); const paymentHeader = await x402Manager.derivePaymentHeader( "https://helius.api.corbits.dev", { method: "GET" } ); const feedId = FeedHash.computeOracleFeedId(oracleFeed); const instructions = await queue.fetchManagedUpdateIxs(crossbar, [feedId.toString("hex")], { numSignatures: 1, variableOverrides: { X402_PAYMENT_HEADER: paymentHeader, }, }); Requirements Solana wallet with USDC balance @switchboard-xyz/x402-utils, @faremeter/wallet-solana, @faremeter/payment-solana numSignatures must equal 1 for X402 requests ### Outputs X402IntegrationPlan: payment handler setup, feed definition, variable override mapping, cost estimates ### Task Types Reference This is the complete reference of all task types available for building Switchboard oracle feed job definitions. Use these as building blocks in OracleJob[] arrays. Data Fetching TaskDescriptionKey ParametershttpTaskHTTP request, returns response bodyurl, method, headers[], bodywebsocketTaskReal-time WebSocket data retrievalurl, subscription, max_data_age_seconds, filteranchorFetchTaskParse Solana accounts via Anchor IDLprogram_id, account_addresssolanaAccountDataFetchTaskRaw Solana account datapubkeysplTokenParseTaskSPL token mint JSON data(token mint address)solanaToken2022ExtensionTaskToken-2022 extension modifiersmint Parsing TaskDescriptionKey ParametersjsonParseTaskExtract value from JSON via JSONPathpath, aggregation_methodregexExtractTaskExtract text via regexpattern, group_numberbufferLayoutParseTaskDeserialize binary buffersoffset, endian, typecronParseTaskConvert crontab to timestampcron_pattern, clock_offset, clockstringMapTaskMap string inputs to outputsmappings, default_value, case_sensitive Math Operations TaskDescriptionKey ParametersaddTaskAdd scalar/job/aggregator valuebig, job, aggregatorPubkeysubtractTaskSubtract valuebig, job, aggregatorPubkeymultiplyTaskMultiply by valuebig, job, aggregatorPubkeydivideTaskDivide by valuebig, job, aggregatorPubkeypowTaskRaise to exponentscalarroundTaskRound to decimal placesmethod, decimalsboundTaskClamp result to boundslower_bound_value, upper_bound_value, on_exceeds_*_value Aggregation TaskDescriptionKey ParametersmedianTaskMedian of subtasks/subjobstasks[], jobs[], min_successful_required, max_range_percentmeanTaskAverage of subtasks/subjobstasks[], jobs[]maxTaskMaximum valuetasks[], jobs[]minTaskMinimum valuetasks[], jobs[]ewmaTaskExponentially weighted moving average(EWMA parameters)twapTaskTime-weighted average priceaggregator_pubkey, period, min_samples Surge & Oracle Integration TaskDescriptionKey ParametersswitchboardSurgeTaskLive spot price from Surge cachesource (BINANCE, BYBIT, OKX, PYTH, TITAN, WEIGHTED, AUTO), symbolsurgeTwapTaskTWAP from Surge candle databasesymbol, time_intervaloracleTaskCross-oracle data (Pyth, Chainlink)switchboardAddress, pythAddress, chainlinkAddress, pyth_allowed_confidence_interval DEX / DeFi Pricing TaskDescriptionKey ParametersjupiterSwapTaskJupiter swap simulationin_token_address, out_token_address, base_amount, slippageuniswapExchangeRateTaskUniswap swap pricein_token_address, out_token_address, in_token_amount, slippage, provider, versionpancakeswapExchangeRateTaskPancakeSwap swap pricein_token_address, out_token_address, in_token_amount, slippage, providersushiswapExchangeRateTaskSushiSwap swap pricein_token_address, out_token_address, in_token_amount, slippage, providercurveFinanceTaskCurve Finance pool pricingchain, provider, pool_address, out_decimalslpExchangeRateTaskLP swap price (Orca/Raydium/Mercurial)pool address, in_token_address, out_token_addresslpTokenPriceTaskLP token pricespool address, use_fair_price, price_feed_addressesserumSwapTaskSerum DEX priceserum_pool_addressmeteoraSwapTaskMeteora pool swap pricepool, typetitanTaskTitan aggregator swap simulationin_token_address, out_token_address, amount, slippage_bps, dexeskuruTaskKuru swap quotestoken_in, token_out, amount, slippage_tolerancemaceTaskMACE aggregator swap quotestoken_in, token_out, amount, slippage_tolerance_bpspumpAmmTaskPump AMM swappool_address, in_amount, max_slippage, is_x_for_ypumpAmmLpTokenPriceTaskPump AMM LP fair pricepool_address, x_price_job, y_price_jobbitFluxTaskBitFlux pool swap priceprovider, pool_address, in_token, out_token LST & Staking TaskDescriptionKey ParameterssanctumLstPriceTaskLST price relative to SOLlst_mint, skip_epoch_checklstHistoricalYieldTaskHistorical yield for LSTslst_mint, operation, epochsmarinadeStateTaskMarinade staking state(none)splStakePoolTaskSPL Stake Pool accountpubkeysuiLstPriceTaskSui LST exchange ratepackage_id, module, function, shared_objects, rpc_urlvsuiPriceTaskvSUI/SUI exchange raterpc_urlsolayerSusdTaskSolayer sUSD price(none) Prediction Markets & Specialized Finance TaskDescriptionKey ParameterskalshiApiTaskKalshi prediction market dataurl, api_key_id, private_keylendingRateTaskProtocol lending ratesprotocol (01, apricot, francium, jet, etc.), asset_mintperpMarketTaskPerpetual market price(market address)mangoPerpMarketTaskMango perp market priceperp_market_addressmapleFinanceTaskMaple Finance asset pricingmethodondoUsdyTaskUSDY price relative to USDstrategyturboEthRedemptionRateTasktETH/WETH redemption rate(none)exponentTaskVault token exchange ratevaultexponentPTLinearPricingTaskExponent vault pricing(vault parameters) Control Flow & Utilities TaskDescriptionKey ParametersconditionalTaskTry primary, fallback on failureattempt[], on_failure[]comparisonTaskConditional branchingop, on_true, on_true_value, on_false, on_false_valuecacheTaskStore result in variable for reusecache_items[]valueTaskReturn a static valuevalue, aggregator_pubkey, bigunixTimeTaskCurrent Unix epoch timeoffsetsysclockOffsetTaskOracle vs system clock diff(none)blake2b128TaskBLAKE2b-128 hash as numericvalue AI & Advanced TaskDescriptionKey ParametersllmTaskLLM text generation in feedproviderConfig, userPrompt, temperature, secretNameApiKeysecretsTaskFetch secrets from SecretsServerauthority, urlvwapTaskVolume-weighted average price(VWAP parameters)historyFunctionTaskHistorical data function(function parameters) Protocol-Specific TaskDescriptionhyloTaskhyUSD to jitoSOL conversionaftermathTaskAftermath protocolcorexTaskCorex protocoletherfuseTaskEtherfuse protocolfragmetricTaskFragmetric liquid restaking tokensglyphTaskGlyph protocolxStepPriceTaskxStep price For full parameter details on any task, consult: https://explorer.switchboardlabs.xyz/task-docs ### Standard Output Formats (use these consistently) When producing artifacts, use these headings and keep them concise: Summary Assumptions OperatorPolicy Plan Execution Steps (only if allowed) Rollback / Recovery Risks & Mitigations Next Actions ### References Documentation Switchboard docs root: https://docs.switchboard.xyz/ Docs by chain: https://docs.switchboard.xyz/docs-by-chain Crossbar: https://docs.switchboard.xyz/tooling/crossbar Run Crossbar (Docker Compose): https://docs.switchboard.xyz/tooling/crossbar/run-crossbar-with-docker-compose CLI: https://docs.switchboard.xyz/tooling/cli SDKs: https://docs.switchboard.xyz/tooling/sdks Deploy Feed: https://docs.switchboard.xyz/custom-feeds/build-and-deploy-feed/deploy-feed Variable Overrides: https://docs.switchboard.xyz/custom-feeds/advanced-feed-configuration/data-feed-variable-overrides Task Types Reference: https://explorer.switchboardlabs.xyz/task-docs Feed Builder: https://explorer.switchboardlabs.xyz/feed-builder Chain-Specific Tutorials Solana basic price feed: https://docs.switchboard.xyz/docs-by-chain/solana-svm/price-feeds/basic-price-feed Solana Surge: https://docs.switchboard.xyz/docs-by-chain/solana-svm/surge Solana randomness: https://docs.switchboard.xyz/docs-by-chain/solana-svm/randomness Solana prediction markets: https://docs.switchboard.xyz/docs-by-chain/solana-svm/prediction-markets Solana X402: https://docs.switchboard.xyz/docs-by-chain/solana-svm/x402 EVM price feeds: https://docs.switchboard.xyz/docs-by-chain/evm/price-feeds EVM Surge: https://docs.switchboard.xyz/docs-by-chain/evm/surge EVM randomness: https://docs.switchboard.xyz/docs-by-chain/evm/randomness Sui price feeds: https://docs.switchboard.xyz/docs-by-chain/sui/price-feeds Sui Surge: https://docs.switchboard.xyz/docs-by-chain/sui/surge Code & API References See "Developer Resources & Tools" table in the SDKs section above. ## Trust - Source: tencent - Verification: Indexed source record - Publisher: oakencore - Version: 1.0.0 ## Source health - Status: healthy - Item download looks usable. - Yavira can redirect you to the upstream package for this item. - Health scope: item - Reason: direct_download_ok - Checked at: 2026-05-04T00:01:11.869Z - Expires at: 2026-05-11T00:01:11.869Z - Recommended action: Download for OpenClaw ## Links - [Detail page](https://openagent3.xyz/skills/switchboard-data-operator) - [Send to Agent page](https://openagent3.xyz/skills/switchboard-data-operator/agent) - [JSON manifest](https://openagent3.xyz/skills/switchboard-data-operator/agent.json) - [Markdown brief](https://openagent3.xyz/skills/switchboard-data-operator/agent.md) - [Download page](https://openagent3.xyz/downloads/switchboard-data-operator)