Automatic username claiming

import { SoranOwner, type TxSigner } from "@sorandomains/owner";

declare const operatorSigner: TxSigner;
declare const deployment: {
  registryId: string;
  rpcUrl: string;
  passphrase: string;
};
declare const treasuryG: string;

const owner = new SoranOwner({
  signer: operatorSigner,
  ...deployment,
});
const capability = await owner.nativeClaimCapability("acme");
if (!capability.supported) throw new Error("Native claiming is unavailable");

const nativeToken = await owner.nativeClaimFeeToken("acme");
await owner.reserveNames("acme", ["admin", "support", "payments"]);
await owner.configureClaims("acme", {
  mode: "public",
  enabled: false,
  admission: { type: "open" },
  feeToken: nativeToken,
  feeAmount: 0n,              // This example deliberately offers free claims.
  feeRecipient: treasuryG,    // A G wallet that does not require a memo.
  walletLimit: 0n,            // Deliberately unlimited, not one name per person.
  approvalAllowance: 0n,
  approvalRateLimit: 0n,
  approvalWindowSecs: 0n,
  approvalTtlSecs: 0n,
});

// Enable only after you have reviewed the confirmed configuration.
await owner.setClaimsEnabled("acme", true);

import {
  SoranHolder,
  createClaimIntent,
  stringifyNativeIntent,
  type TxSigner,
} from "@sorandomains/holder";

declare const userSigner: TxSigner;
declare const deployment: {
  registryId: string;
  rpcUrl: string;
  passphrase: string;
};
declare function persistPublicClaim(reference: {
  intent: string;
  hash?: string;
  transactionXdr?: string;
}): Promise<void>;

const holder = new SoranHolder({ signer: userSigner, ...deployment });
const quote = await holder.claimQuote("alice.acme");
if (!quote.available || quote.reserved) throw new Error("Choose another name");

const requestId = Array.from(
  crypto.getRandomValues(new Uint8Array(32)),
  byte => byte.toString(16).padStart(2, "0"),
).join("");
const intent = createClaimIntent(quote, {
  address: await userSigner.publicKey(),
  memo: { type: "none" },
}, {
  requestId,
  deadline: quote.now + 300n,
});

// Show the exact fee, receiving details and ownership terms before proceeding.
const savedIntent = stringifyNativeIntent(intent);
await persistPublicClaim({ intent: savedIntent });
const result = await holder.claim(intent, {
  onPrepared: prepared => persistPublicClaim({
    intent: savedIntent,
    hash: prepared.hash,
    transactionXdr: prepared.transactionXdr,
  }),
});
console.log(result.status, result.receipt.generation, result.transaction?.hash);

import {
  SoranHolder,
  parseNativeClaimIntent,
  type TxSigner,
} from "@sorandomains/holder";

declare const userSigner: TxSigner;
declare const deployment: {
  registryId: string;
  rpcUrl: string;
  passphrase: string;
};
declare const savedIntentJson: string;

const holder = new SoranHolder({ signer: userSigner, ...deployment });
const intent = parseNativeClaimIntent(savedIntentJson);
const receipt = await holder.recoverClaim(intent);
if (receipt) {
  console.log("Previously completed", receipt.node, receipt.generation);
} else {
  console.log("Reconcile the original transaction hash before any replacement");
}

import {
  signClaimEligibility,
  type ClaimApprovalContext,
  type ClaimIntent,
  type EligibilitySigner,
} from "@sorandomains/holder";

declare const dedicatedApprovalSigner: EligibilitySigner;
declare function assertAuthenticatedMemberOwnsWallet(claimantG: string): Promise<void>;
declare function readTrustedApprovalContext(): Promise<ClaimApprovalContext>;

export async function approveSignupClaim(
  intent: ClaimIntent,
  unsignedEntryXdr: string,
): Promise<string> {
  await assertAuthenticatedMemberOwnsWallet(intent.claimant);
  const trusted = await readTrustedApprovalContext();
  return signClaimEligibility(
    intent,
    unsignedEntryXdr,
    trusted,
    dedicatedApprovalSigner,
  );
}