@font-face {
    font-family: 'Euclid Circular B';
    font-style: normal;
    font-weight: 400;
    font-display: swap;
    src: url('https://storage.googleapis.com/onebalance-public-assets/docs/fonts/EuclidCircularB/EuclidCircularB-Regular-Web.woff') format('woff');
}

@font-face {
    font-family: 'Euclid Circular B';
    font-style: normal;
    font-weight: 500;
    font-display: swap;
    src: url('https://storage.googleapis.com/onebalance-public-assets/docs/fonts/EuclidCircularB/EuclidCircularB-Semibold-Web.woff') format('woff');
}

@font-face {
    font-family: 'Euclid Circular B';
    font-style: normal;
    font-weight: 700;
    font-display: swap;
    src: url('https://storage.googleapis.com/onebalance-public-assets/docs/fonts/EuclidCircularB/EuclidCircularB-Bold-Web.woff') format('woff');
}

* {
    font-family: 'Euclid Circular B', sans-serif;
}

pre, pre > code, code span {
    font-family: monospace;
}

.main-background {
    background-image: radial-gradient(circle at 1px 1px, #d1d5db 1px, transparent 0);
    background-size: 40px 40px;
}

html.dark .main-background {
    background-image: radial-gradient(circle at 1px 1px, #4b5563 1px, transparent 0);
    background-size: 40px 40px;
}

#topbar-cta-button a span {
    border-radius: 0.75rem;
}

pre {
 max-height: 500px;
 overflow-y: auto;
}

.nav-logo {
  height: 1rem !important;
}


import * as mdx from 'eslint-plugin-mdx';
import js from '@eslint/js';
import prettier from 'eslint-plugin-prettier/recommended';
import tseslint from '@typescript-eslint/eslint-plugin';
import tsparser from '@typescript-eslint/parser';
import mdxFrontmatter from './rules/mdx-frontmatter.js';

export default [
  js.configs.recommended,
  prettier,
  {
    files: ['**/*.{ts,tsx}'],
    plugins: {
      '@typescript-eslint': tseslint,
    },
    languageOptions: {
      parser: tsparser,
      parserOptions: {
        ecmaVersion: 'latest',
        sourceType: 'module',
      },
    },
    rules: {
      ...tseslint.configs.recommended.rules,
      '@typescript-eslint/no-explicit-any': 'warn',
    },
  },
  {
    ...mdx.flat,
    processor: mdx.createRemarkProcessor({
      lintCodeBlocks: true,
      languageMapper: {},
    }),
    rules: {
      'prettier/prettier': ['error', { singleQuote: true }],
    },
  },
  {
    ...mdx.flatCodeBlocks,
    rules: {
      ...mdx.flatCodeBlocks.rules,
      'no-var': 'error',
      'prefer-const': 'error',
    },
  },
  {
    files: ['**/*.mdx'],
    plugins: {
      'mdx-frontmatter': mdxFrontmatter,
    },
    rules: {
      'mdx-frontmatter/frontmatter-format': 'error',
      'no-unused-vars': 'warn',
    },
  },
  {
    files: ['scripts/**/*.js'],
    languageOptions: {
      globals: {
        console: 'readonly',
        process: 'readonly',
      },
    },
  },
];


// Create a custom rule for frontmatter validation
const frontmatterRule = {
  name: 'frontmatter-format',
  meta: {
    type: 'problem',
    docs: {
      description: 'Enforce proper frontmatter formatting in MDX files',
      category: 'Possible Errors',
    },
    fixable: 'code',
    schema: [],
  },
  create(context) {
    return {
      Program(node) {
        const sourceCode = context.getSourceCode();
        const text = sourceCode.getText();
        const filePath = context.getFilename();
        const isApiReference = filePath.includes('api-reference/');
        const isSnippet = filePath.includes('snippets/');

        // Skip validation for snippets
        if (isSnippet) {
          return;
        }

        // Check if the file has frontmatter
        if (!text.startsWith('---')) {
          context.report({
            node,
            message: 'MDX files must start with frontmatter (---)',
            fix(fixer) {
              return fixer.insertTextBefore(
                node,
                "---\ntitle: 'Untitled'\ndescription: 'No description provided'\n---\n\n"
              );
            },
          });
          return;
        }

        // Find the end of frontmatter
        const endIndex = text.indexOf('---', 3);
        if (endIndex === -1) {
          context.report({
            node,
            message: 'Frontmatter must end with ---',
            fix(fixer) {
              return fixer.insertTextAfter(node, '\n---\n');
            },
          });
          return;
        }

        // Extract frontmatter content
        const frontmatterContent = text.substring(3, endIndex).trim();

        // Check for required fields only if not in api-reference directory
        if (!isApiReference) {
          if (!frontmatterContent.includes('title:')) {
            context.report({
              node,
              message: 'Frontmatter must include a title field',
              fix(fixer) {
                return fixer.insertTextBefore(node, "---\ntitle: 'Untitled'\n---\n\n");
              },
            });
          }

          if (!frontmatterContent.includes('description:')) {
            context.report({
              node,
              message: 'Frontmatter must include a description field',
              fix(fixer) {
                return fixer.insertTextBefore(
                  node,
                  "---\ndescription: 'No description provided'\n---\n\n"
                );
              },
            });
          }
        }

        // Check for proper formatting (key: value pairs)
        const lines = frontmatterContent.split('\n');
        for (let i = 0; i < lines.length; i++) {
          const line = lines[i].trim();
          if (line && !line.includes(':')) {
            context.report({
              node,
              message: `Invalid frontmatter format at line ${i + 1}: "${line}"`,
              fix(fixer) {
                return fixer.replaceText(node, text.replace(line, `${line}: ""`));
              },
            });
          }
        }
      },
    };
  },
};

// Export the rule as a plugin
export default {
  rules: {
    'frontmatter-format': frontmatterRule,
  },
};


#!/usr/bin/env node

import fs from 'fs';
import { glob } from 'glob';

// Find all MDX files
const mdxFiles = glob.sync('**/*.mdx', { ignore: ['node_modules/**', 'dist/**'] });

let hasErrors = false;

// Check each MDX file
for (const file of mdxFiles) {
  const content = fs.readFileSync(file, 'utf8');
  const isApiReference = file.includes('api-reference/');
  const isSnippet = file.includes('snippets/');

  // Skip validation for snippets
  if (isSnippet) {
    continue;
  }

  // Check if the file has frontmatter
  if (!content.startsWith('---')) {
    console.error(`❌ ${file}: Missing frontmatter (should start with ---)`);
    hasErrors = true;
    continue;
  }

  // Find the end of frontmatter
  const endIndex = content.indexOf('---', 3);
  if (endIndex === -1) {
    console.error(`❌ ${file}: Frontmatter must end with ---`);
    hasErrors = true;
    continue;
  }

  // Extract frontmatter content
  const frontmatterContent = content.substring(3, endIndex).trim();

  // Check for required fields only if not in api-reference directory
  if (!isApiReference) {
    if (!frontmatterContent.includes('title:')) {
      console.error(`❌ ${file}: Missing title field in frontmatter`);
      hasErrors = true;
    }

    if (!frontmatterContent.includes('description:')) {
      console.error(`❌ ${file}: Missing description field in frontmatter`);
      hasErrors = true;
    }
  }

  // Check for proper formatting (key: value pairs)
  const lines = frontmatterContent.split('\n');
  for (let i = 0; i < lines.length; i++) {
    const line = lines[i].trim();
    if (line && !line.includes(':')) {
      console.error(`❌ ${file}: Invalid frontmatter format at line ${i + 1}: "${line}"`);
      hasErrors = true;
    }
  }
}

if (hasErrors) {
  console.error('\n❌ Frontmatter validation failed. Please fix the issues above.');
  process.exit(1);
} else {
  console.log('✅ All MDX files have valid frontmatter.');
}


Unified Quotes

Contract Call Quotes

Quote Types

Quote Lifecycle

Key Features

Understanding and working with transaction quotes in OneBalance

Overview

Quotes Overview

x-api-key

One Click, One Integration, One Balance, All Chains.

OneBalance Docs

The OneBalance Toolkit is the simplest and most reliable way to bring your users onchain. We offer an all-in-one API platform that lets you build one-click crypto products.

Welcome to OneBalance Toolkit

Learn how OneBalance Toolkit integrates with your application

How OneBalance Works

Your step-by-step guide to building with OneBalance - from first API call to production deployment

Onboarding Checklist

A list of all networks supported by OneBalance

Supported Networks

Build chain-abstracted experiences in minutes, not months

Introduction

Integrate OneBalance with Privy for a seamless wallet experience

Set Up Your Environment

Set up a smart contract account for chain-abstracted transactions

Your First API Call

Execute seamless chain-abstracted swaps with OneBalance and Privy

Chain-Abstracted Swap

Understanding how transactions flow through the OneBalance API

Transaction Lifecycle

How Resource Locks enable fast cross-chain transactions by eliminating finality wait times and preventing double-spending

Resource Locks

Understanding OneBalance account models and their capabilities.

Account Models

How user fees are calculated and paid to applications using OneBalance

Fees & Monetization

Understanding OneBalance's unified token representation across multiple chains

Aggregated Assets

Use LLMs in your OneBalance integration workflow.

Building with LLMs

Setting up a Model Context Protocol server for advanced agent interactions

MCP Server Setup

Definitions of OneBalance-specific terms and relevant Web3 concepts

Glossary

Performance metrics, stress test results, and benchmarks for OneBalance infrastructure

Benchmarks & Stress Tests

Learn how to use OneBalance by following our official guides and tutorials

Guides

Learn the key concepts for building a production-ready chain-abstracted token swap interface using OneBalance API and Privy embedded wallets.

Chain-Abstracted Swap with Privy

Building a Chain-Abstracted Swap with OneBalance & Privy

Examples of quote requests for chain-abstracted operations

Examples

Quote Examples

Execute arbitrary smart contract calls across multiple chains with aggregated asset management

Contract Calls Overview

Learn to prepare, sign and submit arbitrary calldata across chains using the OneBalance API

How to Execute Smart Contract Calls

How OneBalance automatically handles token approvals for secure, gas-efficient transactions

Allowances & Approvals

Complex multi-step operations, error recovery, and production optimization techniques

Advanced Patterns

Advanced Contract Call Patterns

Common issues, debugging techniques, and solutions for contract call operations

Troubleshooting

Troubleshooting Contract Calls

Production-ready examples for common DeFi, NFT, and gaming use cases

Contract Call Examples

Overview of the OneBalance API, versioning, and general conventions

How to authenticate requests to the OneBalance API

Authentication

Complete list of error codes with explanations and troubleshooting tips

Errors

Pagination

Information about API rate limits and how to handle them

Rate Limits

Information about CORS support in the OneBalance API

Cross Origin Resource Sharing

Changelog

Connect with the OneBalance community and get help

Community & Support

Common questions and answers about OneBalance platform and API

Overview

Wallet Infrastructure

Quotes

Contract Calls

​Quote Types

​Unified Quotes

​Contract Call Quotes

​Quote Lifecycle