Estimate Costs and Handle Upload Payments

In this guide, you use antd, the local daemon used by the SDKs, to estimate costs, check balances, approve token spend, and choose a payment mode before you upload data.

If you want to work from the command line instead, see Use the CLI. If you want direct Rust access, see Build Directly in Rust.

Featured examples on this page use cURL, Python, Node.js / TypeScript, and Rust. Other SDK languages are available in the Language Bindings section.

Prerequisites

antd running on http://localhost:8082 (see Start the Local Daemon)
A configured wallet for write operations, or a local devnet started with ant dev start

Steps

1. Check the configured wallet

curl http://localhost:8082/v1/wallet/address
curl http://localhost:8082/v1/wallet/balance

import { createClient } from "antd";

async function main() {
  const client = createClient();
  const address = await client.walletAddress();
  const balance = await client.walletBalance();

  console.log(address.address);
  console.log(balance.balance);
  console.log(balance.gasBalance);
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});

use antd_client::{Client, DEFAULT_BASE_URL};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new(DEFAULT_BASE_URL);
    let address = client.wallet_address().await?;
    let balance = client.wallet_balance().await?;

    println!("{}", address.address);
    println!("{}", balance.balance);
    println!("{}", balance.gas_balance);
    Ok(())
}

The wallet balance response returns token balance as atto tokens and gas balance as wei.

On public EVM networks, both values matter:

ANT covers storage payment
gas covers the transaction itself

2. Approve token spend

Fresh wallets may need an approval transaction before uploads can spend tokens through the payment contracts.

This approval grants the payment contracts an unlimited token allowance.

curl -X POST http://localhost:8082/v1/wallet/approve \
  -H "Content-Type: application/json" \
  -d '{}'

import { createClient } from "antd";

async function main() {
  const client = createClient();
  const approved = await client.walletApprove();
  console.log(approved);
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});

use antd_client::{Client, DEFAULT_BASE_URL};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new(DEFAULT_BASE_URL);
    let approved = client.wallet_approve().await?;

    println!("{}", approved);
    Ok(())
}

3. Estimate storage cost

The daemon exposes cost-estimation endpoints and returns a structured estimate that includes cost, file size, chunk count, estimated gas, and the payment mode that would be used.

Use this step before uploads when you want to show a user the likely storage cost or validate that the wallet has enough balance.

DATA_B64=$(printf 'Hello, Autonomi!' | base64)

curl -X POST http://localhost:8082/v1/data/cost \
  -H "Content-Type: application/json" \
  -d "{\"data\":\"$DATA_B64\"}"

import { createClient } from "antd";

async function main() {
  const client = createClient();
  const cost = await client.dataCost(Buffer.from("Hello, Autonomi!"));
  console.log(cost);
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});

use antd_client::{Client, DEFAULT_BASE_URL};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new(DEFAULT_BASE_URL);
    let cost = client.data_cost(b"Hello, Autonomi!").await?;

    println!("{}", cost);
    Ok(())
}

4. Choose a payment mode when uploading

The daemon accepts three payment modes: auto, merkle, and single.

auto is the default
merkle forces Merkle batch payments
single forces per-chunk payments

For larger uploads, merkle reduces gas by using a batch payment flow.

5. Understand local versus public-network testing

On a local devnet, the test wallet is provisioned for you. On Arbitrum Sepolia or Arbitrum One, you must bring your own funded wallet.

That makes the local devnet the easiest place to verify upload payment logic before you move to a public EVM network.

DATA_B64=$(printf 'Hello, Autonomi!' | base64)

curl -X POST http://localhost:8082/v1/data/public \
  -H "Content-Type: application/json" \
  -d "{\"data\":\"$DATA_B64\",\"payment_mode\":\"merkle\"}"

import { createClient } from "antd";

async function main() {
  const client = createClient();
  const result = await client.dataPutPublic(Buffer.from("Hello, Autonomi!"), {
    paymentMode: "merkle",
  });
  console.log(result.address);
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});

use antd_client::{Client, DEFAULT_BASE_URL};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new(DEFAULT_BASE_URL);
    let result = client
        .data_put_public(b"Hello, Autonomi!", Some("merkle"))
        .await?;

    println!("{}", result.address);
    Ok(())
}

Verify it worked

Check the wallet balance before and after a paid upload, then fetch the stored data by address. The upload response also tells you which payment mode the daemon actually used.

Common errors

402 Payment Required: Fund the wallet or use a local devnet.

503 Service Unavailable: The daemon does not have wallet configuration.

400 Bad Request: Check the base64 payload and payment_mode value.

Next steps

PreviousPrepare a Wallet for Uploads NextBuild Read-Only Features

Last updated 1 day ago

hashtagPrerequisites

hashtagSteps

hashtag1. Check the configured wallet

hashtag2. Approve token spend

hashtag3. Estimate storage cost

hashtag4. Choose a payment mode when uploading

hashtag5. Understand local versus public-network testing

hashtagVerify it worked

hashtagCommon errors

hashtagNext steps