Mint Onchain Subnames on Ethereum or L2

BASE_RPC_URL=https://your-base-rpc.example
WALLET_PRIVATE_KEY=0xYOUR_PRIVATE_KEY

import 'dotenv/config';
import { createMintClient } from '@thenamespace/mint-manager';
import {
  createPublicClient,
  createWalletClient,
  http,
  type Hex,
} from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { base } from 'viem/chains';

const rpcUrl = process.env.BASE_RPC_URL;
const privateKey = process.env.WALLET_PRIVATE_KEY as Hex | undefined;

if (!rpcUrl) throw new Error('Missing BASE_RPC_URL');
if (!privateKey) throw new Error('Missing WALLET_PRIVATE_KEY');

export const account = privateKeyToAccount(privateKey);
export const mintClient = createMintClient({ mintSource: 'my-app' });
export const publicClient = createPublicClient({
  chain: base,
  transport: http(rpcUrl),
});
export const walletClient = createWalletClient({
  account,
  chain: base,
  transport: http(rpcUrl),
});

import { base } from 'viem/chains';
import { mintClient } from './clients';

const fullName = 'alice.example.eth';
const isAvailable = await mintClient.isL2SubnameAvailable(
  fullName,
  base.id,
);

if (!isAvailable) throw new Error(`${fullName} is not available on Base`);

import { account, mintClient } from './clients';

export const parentName = 'example.eth';
export const label = 'alice';

export async function getQuote() {
  const details = await mintClient.getMintDetails({
    parentName,
    label,
    minterAddress: account.address,
  });

  if (!details.canMint) {
    throw new Error(details.validationErrors.join(', '));
  }

  console.log({
    priceEth: details.estimatedPriceEth,
    feeEth: details.estimatedFeeEth,
  });

  return details;
}

import { ChainName } from '@thenamespace/mint-manager';
import { account, mintClient } from './clients';
import { label, parentName } from './quote';

export async function getTransaction() {
  return mintClient.getMintTransactionParameters({
    parentName,
    label,
    minterAddress: account.address,
    owner: account.address,
    records: {
      texts: [
        { key: 'description', value: 'Minted with Namespace' },
      ],
      addresses: [
        { chain: ChainName.Ethereum, value: account.address },
      ],
    },
  });
}

import {
  account,
  publicClient,
  walletClient,
} from './clients';
import { getQuote } from './quote';
import { getTransaction } from './transaction';

async function main() {
  await getQuote();
  const transaction = await getTransaction();

  const { request } = await publicClient.simulateContract({
    account,
    address: transaction.contractAddress,
    abi: transaction.abi,
    functionName: transaction.functionName,
    args: transaction.args,
    value: transaction.value,
  });

  const hash = await walletClient.writeContract(request);
  console.log(`Submitted transaction: ${hash}`);
}

main().catch((error: unknown) => {
  console.error(error);
  process.exitCode = 1;
});