name: alldomains description: > Solana domain name service for registering Web3 domains (.molt, .bonk, etc). Use when: (1) Checking domain availability, (2) Getting domain prices, (3) Registering Solana domains, (4) Working with TLDs like .molt, .bonk, .poor, etc.

AllDomains

Solana domain name service API for checking and registering Web3 domains.

Website: https://alldomains.id Supported TLDs: .molt, .bonk, .poor, .abc, and many more

API Base URL

https://alldomains.id

Check Domain Availability

Endpoint

GET /api/check-domain/{domain.tld}

Response

type DomainCheckResponse = {
  tld: string;
  exists: boolean | (Record<string, any> | undefined)[];
  domainPrice: {
    mint: string;
    pricing: number;
  }[] | undefined | null;
};

Example

const domain = "myname.molt";
const response = await fetch(`https://alldomains.id/api/check-domain/${domain}`);
const data = await response.json();

// Check if taken
const domainTaken = data.exists === true || 
  (Array.isArray(data.exists) && data.exists.some(v => v != null));

if (domainTaken) {
  console.log("Domain is taken");
} else {
  console.log("Domain available! Price:", data.domainPrice);
}

Register Domain

Endpoint

POST /api/create-domain

Request Body

{
  domain: string;      // Domain name without TLD (e.g., "myname")
  durationRate: number; // Years: 1-5
  tld: string;         // TLD with dot (e.g., ".molt")
  publicKey: string;   // Buyer's Solana public key
  simulate?: boolean;  // Optional: simulate first
}

Response

type CreateDomainApiResponse = {
  status: "success" | "error";
  error: string | null;
  msg: string | null;
  instructionBase64: string | null;
  preInstructionsBase64?: string[];
  addressLookupTableAccountsKeys?: string[];
  insufficientFunds?: boolean;
  slippageToleranceExceeded?: boolean;
  simulationError?: boolean;
};

Complete Registration Flow

import {
  Connection,
  PublicKey,
  Keypair,
  TransactionInstruction,
  AddressLookupTableAccount,
  VersionedTransaction,
  TransactionMessage,
} from "@solana/web3.js";

const BASE_URL = "https://alldomains.id";
const RPC_URL = "https://viviyan-bkj12u-fast-mainnet.helius-rpc.com";

// Helper: Create versioned transaction
function createTransaction(
  payerKey: PublicKey,
  instructions: TransactionInstruction[],
  blockhash: string,
  lutAddresses: AddressLookupTableAccount[] = []
): VersionedTransaction {
  const messageV0 = new TransactionMessage({
    payerKey,
    recentBlockhash: blockhash,
    instructions,
  }).compileToV0Message(lutAddresses);
  return new VersionedTransaction(messageV0);
}

// Helper: Get lookup table accounts
async function getAddressLookupTableAccounts(
  connection: Connection,
  keys: string[]
): Promise<AddressLookupTableAccount[]> {
  const accountInfos = await connection.getMultipleAccountsInfo(
    keys.map((key) => new PublicKey(key))
  );
  
  return accountInfos.reduce((acc, accountInfo, index) => {
    if (accountInfo) {
      acc.push(new AddressLookupTableAccount({
        key: new PublicKey(keys[index]),
        state: AddressLookupTableAccount.deserialize(
          Uint8Array.from(accountInfo.data)
        ),
      }));
    }
    return acc;
  }, [] as AddressLookupTableAccount[]);
}

// Helper: Decode base64 instructions
function decodeInstructions(base64Instructions: string[]): TransactionInstruction[] {
  return base64Instructions.map((instructionBase64) => {
    const decoded = JSON.parse(
      Buffer.from(instructionBase64, "base64").toString()
    );
    return new TransactionInstruction({
      keys: decoded.keys.map((key: any) => ({
        pubkey: new PublicKey(key.pubkey),
        isSigner: key.isSigner,
        isWritable: key.isWritable,
      })),
      programId: new PublicKey(decoded.programId),
      data: Buffer.from(decoded.data),
    });
  });
}

// Main: Register domain
async function registerDomain(
  domain: string,
  tld: string,
  payer: Keypair,
  durationYears: number = 1
) {
  const connection = new Connection(RPC_URL);
  
  // Step 1: Check availability
  const checkResponse = await fetch(
    `${BASE_URL}/api/check-domain/${domain}${tld}`
  );
  const checkData = await checkResponse.json();
  
  const isTaken = checkData.exists === true ||
    (Array.isArray(checkData.exists) && checkData.exists.some((v: any) => v != null));
  
  if (isTaken) {
    throw new Error(`Domain ${domain}${tld} is already taken`);
  }
  
  console.log("Domain available! Price:", checkData.domainPrice);
  
  // Step 2: Get registration instructions
  const createResponse = await fetch(`${BASE_URL}/api/create-domain`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      domain,
      durationRate: durationYears,
      tld,
      publicKey: payer.publicKey.toString(),
      simulate: true,
    }),
  });
  
  const createData = await createResponse.json();
  
  if (createData.status === "error") {
    throw new Error(`Failed: ${createData.error} | ${createData.msg}`);
  }
  
  if (!createData.instructionBase64 || 
      !createData.addressLookupTableAccountsKeys ||
      !createData.preInstructionsBase64) {
    throw new Error("Missing instruction data");
  }
  
  // Step 3: Decode instructions
  const mainInstruction = decodeInstructions([createData.instructionBase64])[0];
  const preInstructions = decodeInstructions(createData.preInstructionsBase64);
  
  // Step 4: Get lookup tables
  const lookupTables = await getAddressLookupTableAccounts(
    connection,
    createData.addressLookupTableAccountsKeys
  );
  
  // Step 5: Build transaction
  const { blockhash } = await connection.getLatestBlockhash();
  const transaction = createTransaction(
    payer.publicKey,
    [...preInstructions, mainInstruction],
    blockhash,
    lookupTables
  );
  
  // Step 6: Simulate first
  const simulation = await connection.simulateTransaction(transaction, {
    commitment: "confirmed",
    sigVerify: false,
  });
  
  if (simulation.value.err) {
    throw new Error(`Simulation failed: ${JSON.stringify(simulation.value.err)}`);
  }
  
  console.log("Simulation passed, sending transaction...");
  
  // Step 7: Sign and send
  transaction.sign([payer]);
  const txid = await connection.sendRawTransaction(transaction.serialize());
  
  console.log(`Transaction sent: ${txid}`);
  
  // Step 8: Confirm
  await connection.confirmTransaction(txid);
  console.log(`Domain ${domain}${tld} registered! TX: ${txid}`);
  
  return txid;
}

// Usage
const payer = Keypair.fromSecretKey(/* your keypair */);
await registerDomain("myname", ".molt", payer, 1);

Supported TLDs

| TLD | Description | |-----|-------------| | .molt | Moltbook domains | | .bonk | Bonk community domains | | .poor | Community domains | | .abc | ABC domains | | And more... | Check alldomains.id for full list |

Pricing

Prices vary by:

• TLD (different registries have different prices)
• Domain length (shorter = more expensive)
• Duration (1-5 years)

The domainPrice field in the check response shows available payment options with mint addresses (usually USDC, SOL, or TLD-specific tokens).

Error Handling

Common errors from the API:

• insufficientFunds: true - Wallet doesn't have enough tokens
• slippageToleranceExceeded: true - Price changed, retry
• simulationError: true - Transaction would fail

Notes

• Always simulate before sending (simulate: true)
• Use versioned transactions with lookup tables for lower fees
• Domain registration is 1-5 years, renewable
• Some TLDs may require specific tokens for payment