@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.');
}


#!/usr/bin/env node

import fs from 'fs';
import path from 'path';
import readline from 'readline';

// Constants
const DEFAULT_IMAGE_URL =
  'https://storage.googleapis.com/onebalance-public-assets/changelog/new-docs.png';
const CHANGELOG_DIR = 'changelog';
const MAIN_CHANGELOG_FILE = 'changelog.mdx';

// Create readline interface
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

// Utility functions
const question = query => new Promise(resolve => rl.question(query, resolve));

const formatDate = date => {
  const months = [
    'January',
    'February',
    'March',
    'April',
    'May',
    'June',
    'July',
    'August',
    'September',
    'October',
    'November',
    'December',
  ];

  const day = date.getDate();
  const month = months[date.getMonth()];
  const year = date.getFullYear();

  const getOrdinal = day => {
    if (day > 3 && day < 21) return 'th';
    switch (day % 10) {
      case 1:
        return 'st';
      case 2:
        return 'nd';
      case 3:
        return 'rd';
      default:
        return 'th';
    }
  };

  return `${month} ${day}${getOrdinal(day)}, ${year}`;
};

const createSlug = title => {
  return title
    .toLowerCase()
    .replace(/[^a-z0-9\s-]/g, '')
    .replace(/\s+/g, '-')
    .replace(/-+/g, '-')
    .trim('-');
};

const parseDate = dateSlug => {
  const date = new Date(dateSlug + 'T00:00:00');
  if (isNaN(date.getTime())) {
    throw new Error('Invalid date format. Please use YYYY-MM-DD');
  }
  return date;
};

// Input collection functions
const getUserInput = async () => {
  const currentDate = new Date();
  const todaySlug = currentDate.toISOString().split('T')[0];

  console.log('🚀 Creating new changelog item...\n');

  // Get title
  const title = await question('Enter changelog title: ');
  if (!title.trim()) {
    throw new Error('Title is required');
  }

  // Get date
  const dateInput = await question(`Date (YYYY-MM-DD, default: ${todaySlug}): `);
  const dateSlug = dateInput.trim() || todaySlug;

  // Parse and validate date
  let changelogDate;
  try {
    changelogDate = parseDate(dateSlug);
  } catch (error) {
    throw new Error(
      `❌ Invalid date format. Please use YYYY-MM-DD (e.g., ${todaySlug}). ${error.message}`
    );
  }

  const defaultLabel = formatDate(changelogDate);

  // Get label
  const labelInput = await question(`Label (default: "${defaultLabel}"): `);
  const label = labelInput.trim() || defaultLabel;

  return {
    title: title.trim(),
    dateSlug,
    label,
    changelogDate,
  };
};

const confirmCreation = async config => {
  const { title, label, filename, link } = config;

  console.log(`\n📝 Creating changelog item:`);
  console.log(`   Title: ${title}`);
  console.log(`   Label: ${label}`);
  console.log(`   File: ${filename}`);
  console.log(`   Link: ${link}`);

  const confirm = await question('\nProceed? (Y/n): ');
  return confirm.trim() === '' || confirm.toLowerCase() === 'y' || confirm.toLowerCase() === 'yes';
};

// File creation functions
const createChangelogFile = config => {
  const { title, filename, imageUrl } = config;

  const content = `---
title: '${title}'
description: 'TODO: Add description'
'og:image': '${imageUrl}'
---

<img
  className="blur-0 aspect-video rounded-lg border border-neutral-200 object-cover dark:border-neutral-800"
  src="${imageUrl}"
  alt="${title}"
/>

TODO: Add changelog content here

## What's New

- TODO: Add bullet points

## Getting Started

TODO: Add getting started information if relevant

<Info>
  TODO: Add any additional information or call-to-action
</Info>
`;

  const filePath = path.join(CHANGELOG_DIR, filename);
  fs.writeFileSync(filePath, content);
  return filePath;
};

const updateMainChangelog = config => {
  const { title, label, link, imageUrl } = config;

  const mainContent = fs.readFileSync(MAIN_CHANGELOG_FILE, 'utf8');

  // Find insertion point after imports
  const importEndIndex = mainContent.indexOf(
    "import { ChangelogItem } from '/snippets/ChangelogItem.mdx';"
  );
  const insertIndex = mainContent.indexOf('\n', importEndIndex) + 1;

  const newItem = `
<ChangelogItem
  label="${label}"
  link="${link}"
  imageUrl="${imageUrl}"
>
  ## ${title}

  TODO: Add brief description here
</ChangelogItem>

`;

  const updatedContent =
    mainContent.slice(0, insertIndex) + newItem + mainContent.slice(insertIndex);
  fs.writeFileSync(MAIN_CHANGELOG_FILE, updatedContent);
};

const showNextSteps = filePath => {
  console.log(`\n🎉 Changelog item created successfully!`);
  console.log(`\nNext steps:`);
  console.log(`1. Edit ${filePath} to add your content`);
  console.log(`2. Update the brief description in ${MAIN_CHANGELOG_FILE}`);
  console.log(`3. Optionally update the image URL`);
};

// Main function
const main = async () => {
  try {
    // Collect user input
    const input = await getUserInput();

    // Create configuration object
    const config = {
      ...input,
      titleSlug: createSlug(input.title),
      filename: `${input.dateSlug}-${createSlug(input.title)}.mdx`,
      link: `/changelog/${input.dateSlug}-${createSlug(input.title)}`,
      imageUrl: DEFAULT_IMAGE_URL,
    };

    // Confirm with user
    const shouldProceed = await confirmCreation(config);
    if (!shouldProceed) {
      console.log('❌ Cancelled');
      return;
    }

    // Create files
    const filePath = createChangelogFile(config);
    console.log(`✅ Created ${filePath}`);

    updateMainChangelog(config);
    console.log(`✅ Updated ${MAIN_CHANGELOG_FILE}`);

    // Show next steps
    showNextSteps(filePath);
  } catch (error) {
    console.error('❌ Error:', error.message);
    process.exit(1);
  } finally {
    rl.close();
  }
};

main();


Unified Quotes

Contract Call Quotes

Quote Types

Quote Lifecycle

Key Features

Understanding and working with transaction quotes in OneBalance

Quotes Overview

x-api-key

Announcing our $20m venture round co-led by cyber•Fund and Blockchain Capital. [Read more](https://www.onebalance.io/post/announcing-our-20m-venture-round).

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

OneBalance Docs

A documentation for OneBalance - guides, API reference, tutorials, and resources to build chain-abstracted applications with ease

Home

OneBalance Documentation

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

Connect with the OneBalance community and get help

Community & Support

Build chain-abstracted experiences in hours, 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

Ready-to-use prompts for OneBalance MCP server integration

MCP Example Prompts

Explore All Products

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

Learn how to integrate Turnkey with OneBalance API

Turnkey Integration

Examples of quote requests for chain-abstracted operations

Quote Examples

Overview of the OneBalance API, versioning, and general conventions

Authenticate your API requests with OneBalance using API keys

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

Predicts the address for a new OneBalance smart account based on the provided EVM-compatible signer addresses (session and admin). This allows you to determine the smart account's on-chain address before its actual deployment. This predicted address serves as a primary identifier for the user within the OneBalance ecosystem.

Predict smart account address

Request a quote for transferring or swapping assets.

Get quote

Prepares the necessary data structure for executing one or more contract calls on a target chain. This endpoint helps construct the appropriate user operation, handles token allowance requirements, and generates a signed quote ready for execution.

Prepare call quote

Gets a quote for arbitrary contract call operations on a specific chain. This endpoint handles the execution of pre-signed user operations with typed data signatures, supporting interactions with smart contracts.

Get call quote

Execute a previously generated quote to transfer funds.

Execute quote

Retrieves the execution status of a quote by its quote ID as well as transaction hashes for user operations

Get quote status

Retrieves the transaction history for an address, including the transaction type and token details.

Get transaction history

Retrieves a list of all aggregated assets currently supported and enabled on the OneBalance platform. Each aggregated asset includes details such as its unique ID, symbol, name, decimals, and the underlying individual assets (chain-specific tokens) that constitute it, identified by their CAIP-19 asset types.


List aggregated assets

Fetches the aggregated balance of all supported assets for a given smart account address, with an option to filter by specific `assetId`s.

Get aggregated balance

Retrieves a list of all blockchain networks currently integrated with and supported by the OneBalance platform.

List supported chains

Changelog

Latest updates and changes to OneBalance API

Overview

Integration Examples

Working with Quotes

​Quote Types

​Unified Quotes

​Contract Call Quotes

​Quote Lifecycle