Pontifex API Reference

function claim(address recipient, uint256 cumulativeBurned, uint256 deadline, bytes[] calldata signatures) external

const domain = {
  name: "Pontifex",
  version: "1",
  chainId: 4663,
  verifyingContract: "0x7b1D080d2485E63791468d73418e2B262c25C402", // KskdEntry
};
const types = {
  Claim: [
    { name: "recipient", type: "address" },
    { name: "cumulativeBurned", type: "uint256" },
    { name: "deadline", type: "uint256" },
  ],
};

{
  "state": "ready",
  "signer": "0x7d3B23a631501a35cafe4F00133653A1b90f2CC3",
  "version": "1",
  "pcr0": "0x8761b33a338db4fab12c9201eef87e1c582310d59645848c2574061d1e070d71238976ea1af05ad4b4e645004621aac6",
  "registered": false,
  "igraFinalized": 19788720,
  "rhFinalized": 94217640
}

{ "attestation": "0x8444a101…", "signer": "0x7d3B23a631501a35cafe4F00133653A1b90f2CC3", "pcr0": "0x8761b33a…aac6" }

curl -s -X POST https://nuntius.kaskad.live/bridge/sign \
  -H 'Content-Type: application/json' \
  -d '{"recipient":"0xYourRecipientAddress"}'

{
  "signer": "0x7d3B23a631501a35cafe4F00133653A1b90f2CC3",
  "signature": "0x…",
  "cumulativeBurned": "50000000000000000000000",
  "deadline": 1792479236,
  "igraBlock": 19740001
}

mkdir pontifex-scripts && cd pontifex-scripts
npm init -y && npm pkg set type=module
npm install viem@2.57.7 tsx@4.23.15

// Chain definitions shared by the examples.
import { defineChain } from "viem";

export const igra = defineChain({
  id: 38833,
  name: "Igra",
  nativeCurrency: { name: "iKAS", symbol: "iKAS", decimals: 18 },
  rpcUrls: { default: { http: [process.env.IGRA_RPC ?? "https://rpc.igralabs.com:8545"] } },
});

export const robinhood = defineChain({
  id: 4663,
  name: "Robinhood Chain",
  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
  rpcUrls: { default: { http: [process.env.RH_RPC ?? "https://rpc.mainnet.chain.robinhood.com"] } },
});

// Print a recipient's bridge status and the current mint window, read from both chains.
import { createPublicClient, formatUnits, http, parseAbi, type Address } from "viem";
import { igra, robinhood } from "./chains.ts";

const KSKD_EXIT = "0x5A818D42cA142483f72AE7D426E199324FEc4871"; // Igra
const KSKD_ENTRY = "0x7b1D080d2485E63791468d73418e2B262c25C402"; // Robinhood Chain
const KSKD_BRIDGED = "0x6ddb8541Af17DAdEA47dF41D1C13faf8Deee1902"; // Robinhood Chain
const IGRA_DEPTH = 800n; // the enclave signs at the older of Igra's finalized block and head - 800

const exitAbi = parseAbi(["function burned(address recipient) view returns (uint256)"]);
const tokenAbi = parseAbi([
  "function bridgedIn(address recipient) view returns (uint256)",
  "function totalSupply() view returns (uint256)",
  "function MAX_SUPPLY() view returns (uint256)",
]);
const entryAbi = parseAbi([
  "function mintLimit() view returns (uint256)",
  "function windowStart() view returns (uint256)",
  "function windowMinted() view returns (uint256)",
  "function WINDOW() view returns (uint256)",
]);

const recipient = process.argv[2] as Address | undefined;
if (!recipient) throw new Error("usage: npx tsx pontifex-status.ts <recipient>");

const igraClient = createPublicClient({ chain: igra, transport: http() });
const rhClient = createPublicClient({ chain: robinhood, transport: http() });

const [head, finalized] = await Promise.all([
  igraClient.getBlockNumber(),
  igraClient.getBlock({ blockTag: "finalized" }),
]);
const signBlock = finalized.number < head - IGRA_DEPTH ? finalized.number : head - IGRA_DEPTH;

const [burned, burnedSignable, received, supply, maxSupply, limit, start, minted, window, rhBlock] = await Promise.all([
  igraClient.readContract({ address: KSKD_EXIT, abi: exitAbi, functionName: "burned", args: [recipient] }),
  igraClient.readContract({ address: KSKD_EXIT, abi: exitAbi, functionName: "burned", args: [recipient], blockNumber: signBlock }),
  rhClient.readContract({ address: KSKD_BRIDGED, abi: tokenAbi, functionName: "bridgedIn", args: [recipient] }),
  rhClient.readContract({ address: KSKD_BRIDGED, abi: tokenAbi, functionName: "totalSupply" }),
  rhClient.readContract({ address: KSKD_BRIDGED, abi: tokenAbi, functionName: "MAX_SUPPLY" }),
  rhClient.readContract({ address: KSKD_ENTRY, abi: entryAbi, functionName: "mintLimit" }),
  rhClient.readContract({ address: KSKD_ENTRY, abi: entryAbi, functionName: "windowStart" }),
  rhClient.readContract({ address: KSKD_ENTRY, abi: entryAbi, functionName: "windowMinted" }),
  rhClient.readContract({ address: KSKD_ENTRY, abi: entryAbi, functionName: "WINDOW" }),
  rhClient.getBlock(),
]);

// The window rolls at the first claim at or after windowStart + WINDOW.
const rolled = rhBlock.timestamp >= start + window;
const windowRoom = limit > (rolled ? 0n : minted) ? limit - (rolled ? 0n : minted) : 0n;
const supplyRoom = maxSupply - supply;
const available = windowRoom < supplyRoom ? windowRoom : supplyRoom;

const kskd = (v: bigint) => `${formatUnits(v, 18)} KSKD`;
console.log(`burned on Igra:                  ${kskd(burned)}`);
console.log(`received on Robinhood Chain:     ${kskd(received)}`);
console.log(`pending:                         ${kskd(burned - received)}`);
console.log(`signable now:                    ${kskd(burnedSignable > received ? burnedSignable - received : 0n)} (Igra block ${signBlock})`);
console.log(`bridge paused:                   ${limit === 0n}`);
console.log(`available this window:           ${kskd(available)}`);
if (!rolled) console.log(`window resets no earlier than:   ${new Date(Number(start + window) * 1000).toISOString()}`);

$ npx tsx pontifex-status.ts 0x313807B857222278FbddF36541DE2Af5a50BdCB5
burned on Igra:                  1000 KSKD
received on Robinhood Chain:     1000 KSKD
pending:                         0 KSKD
signable now:                    0 KSKD (Igra block 19788613)
bridge paused:                   false
available this window:           25000000 KSKD

cast call 0x5A818D42cA142483f72AE7D426E199324FEc4871 "burned(address)(uint256)" $RECIPIENT --rpc-url https://rpc.igralabs.com:8545
cast call 0x6ddb8541Af17DAdEA47dF41D1C13faf8Deee1902 "bridgedIn(address)(uint256)" $RECIPIENT --rpc-url https://rpc.mainnet.chain.robinhood.com

// Burn KSKD on Igra and credit a recipient on Robinhood Chain.
import { createPublicClient, createWalletClient, formatUnits, http, parseAbi, parseSignature, parseUnits, type Address, type Hex } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { igra } from "./chains.ts";

const KSKD = "0x16d92794F5B81d2CdEd0F0958779A410401e6435";
const KSKD_EXIT = "0x5A818D42cA142483f72AE7D426E199324FEc4871";

const exitAbi = parseAbi([
  "function exit(uint256 amount, address recipient)",
  "function exitWithPermit(uint256 amount, address recipient, uint256 deadline, uint8 v, bytes32 r, bytes32 s)",
  "function minBurn() view returns (uint256)",
  "function closed() view returns (bool)",
  "function burned(address recipient) view returns (uint256)",
]);
const kskdAbi = parseAbi([
  "function approve(address spender, uint256 amount) returns (bool)",
  "function allowance(address owner, address spender) view returns (uint256)",
  "function nonces(address owner) view returns (uint256)",
]);

const account = privateKeyToAccount(process.env.PRIVATE_KEY as Hex);
// Must be an address you control on Robinhood Chain. KSKD sent to any other address is lost.
const recipient = (process.env.RECIPIENT ?? account.address) as Address;
const amount = parseUnits(process.env.AMOUNT ?? "1000", 18);
const usePermit = process.env.USE_PERMIT === "1";

const publicClient = createPublicClient({ chain: igra, transport: http() });
const wallet = createWalletClient({ account, chain: igra, transport: http() });

const [minBurn, closed] = await Promise.all([
  publicClient.readContract({ address: KSKD_EXIT, abi: exitAbi, functionName: "minBurn" }),
  publicClient.readContract({ address: KSKD_EXIT, abi: exitAbi, functionName: "closed" }),
]);
if (closed) throw new Error("the migration is closed");
if (amount < minBurn) throw new Error(`minimum per exit is ${formatUnits(minBurn, 18)} KSKD`);

let hash: Hex;
if (usePermit) {
  // One transaction: an EIP-2612 permit for exactly `amount`, consumed by exitWithPermit.
  const deadline = BigInt(Math.floor(Date.now() / 1000) + 30 * 60);
  const nonce = await publicClient.readContract({ address: KSKD, abi: kskdAbi, functionName: "nonces", args: [account.address] });
  const signature = await wallet.signTypedData({
    domain: { name: "Kaskad", version: "1", chainId: igra.id, verifyingContract: KSKD },
    types: {
      Permit: [
        { name: "owner", type: "address" },
        { name: "spender", type: "address" },
        { name: "value", type: "uint256" },
        { name: "nonce", type: "uint256" },
        { name: "deadline", type: "uint256" },
      ],
    },
    primaryType: "Permit",
    message: { owner: account.address, spender: KSKD_EXIT, value: amount, nonce, deadline },
  });
  const { r, s, yParity } = parseSignature(signature);
  hash = await wallet.writeContract({
    address: KSKD_EXIT, abi: exitAbi, functionName: "exitWithPermit",
    args: [amount, recipient, deadline, 27 + yParity, r, s],
  });
} else {
  // Two transactions: approve, then exit.
  const allowance = await publicClient.readContract({ address: KSKD, abi: kskdAbi, functionName: "allowance", args: [account.address, KSKD_EXIT] });
  if (allowance < amount) {
    const approveHash = await wallet.writeContract({ address: KSKD, abi: kskdAbi, functionName: "approve", args: [KSKD_EXIT, amount] });
    await publicClient.waitForTransactionReceipt({ hash: approveHash });
  }
  hash = await wallet.writeContract({ address: KSKD_EXIT, abi: exitAbi, functionName: "exit", args: [amount, recipient] });
}

const receipt = await publicClient.waitForTransactionReceipt({ hash });
const burned = await publicClient.readContract({ address: KSKD_EXIT, abi: exitAbi, functionName: "burned", args: [recipient] });
console.log(`exit ${receipt.status} in block ${receipt.blockNumber}; cumulative burned for ${recipient}: ${formatUnits(burned, 18)} KSKD`);

PRIVATE_KEY=0x… AMOUNT=1000 npx tsx exit.ts
PRIVATE_KEY=0x… AMOUNT=1000 USE_PERMIT=1 npx tsx exit.ts

// Request a claim signature from the bridge enclave and submit it to KskdEntry yourself.
import { createPublicClient, createWalletClient, formatUnits, http, parseAbi, type Address, type Hex } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { robinhood } from "./chains.ts";

const BRIDGE_API = process.env.BRIDGE_API ?? "https://nuntius.kaskad.live/bridge";
const KSKD_ENTRY = "0x7b1D080d2485E63791468d73418e2B262c25C402";
const KSKD_BRIDGED = "0x6ddb8541Af17DAdEA47dF41D1C13faf8Deee1902";

interface SignedClaim {
  signer: Address;
  signature: Hex;
  cumulativeBurned: string; // decimal string, 18 decimals
  deadline: number; // unix seconds
  igraBlock: number; // Igra block the burn total was read at
  cached?: boolean;
}

const entryAbi = parseAbi([
  "function claim(address recipient, uint256 cumulativeBurned, uint256 deadline, bytes[] signatures)",
  "function threshold() view returns (uint256)",
]);
const tokenAbi = parseAbi(["function bridgedIn(address recipient) view returns (uint256)"]);

const account = privateKeyToAccount(process.env.PRIVATE_KEY as Hex); // pays Robinhood Chain gas; need not be the recipient
const recipient = (process.env.RECIPIENT ?? account.address) as Address;

const res = await fetch(`${BRIDGE_API}/sign`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ recipient }),
});
const body = await res.json();
if (!res.ok) throw new Error(`bridge refused (${res.status}): ${body.error}`); // e.g. nothing_burned, not_ready
const grant = body as SignedClaim;

const publicClient = createPublicClient({ chain: robinhood, transport: http() });
const wallet = createWalletClient({ account, chain: robinhood, transport: http() });

const [threshold, bridgedIn] = await Promise.all([
  publicClient.readContract({ address: KSKD_ENTRY, abi: entryAbi, functionName: "threshold" }),
  publicClient.readContract({ address: KSKD_BRIDGED, abi: tokenAbi, functionName: "bridgedIn", args: [recipient] }),
]);
const cumulativeBurned = BigInt(grant.cumulativeBurned);
if (cumulativeBurned <= bridgedIn) throw new Error("nothing to claim: already minted");
if (threshold > 1n) throw new Error(`entry needs ${threshold} signatures; collect them sorted by signer address`);

const hash = await wallet.writeContract({
  address: KSKD_ENTRY, abi: entryAbi, functionName: "claim",
  args: [recipient, cumulativeBurned, BigInt(grant.deadline), [grant.signature]],
});
const receipt = await publicClient.waitForTransactionReceipt({ hash });
console.log(`claim ${receipt.status}; up to ${formatUnits(cumulativeBurned - bridgedIn, 18)} KSKD minted to ${recipient}`);

PRIVATE_KEY=0x… RECIPIENT=0xYourRecipientAddress npx tsx self-claim.ts

// Recover the enclave signer of a KskdEntry.claim transaction and check it is registered.
import { createPublicClient, decodeFunctionData, http, parseAbi, recoverTypedDataAddress, type Hex } from "viem";
import { robinhood } from "./chains.ts";

const KSKD_ENTRY = "0x7b1D080d2485E63791468d73418e2B262c25C402";

const entryAbi = parseAbi([
  "function claim(address recipient, uint256 cumulativeBurned, uint256 deadline, bytes[] signatures)",
  "function validSigner(address signer) view returns (bool)",
]);

const txHash = process.argv[2] as Hex | undefined;
if (!txHash) throw new Error("usage: npx tsx verify-claim.ts <claim tx hash>");

const client = createPublicClient({ chain: robinhood, transport: http() });
const tx = await client.getTransaction({ hash: txHash });
if (tx.to?.toLowerCase() !== KSKD_ENTRY.toLowerCase()) throw new Error("not a direct call to KskdEntry");
const call = decodeFunctionData({ abi: entryAbi, data: tx.input });
if (call.functionName !== "claim") throw new Error("not a claim call");
const [recipient, cumulativeBurned, deadline, signatures] = call.args;

for (const signature of signatures) {
  const signer = await recoverTypedDataAddress({
    domain: { name: "Pontifex", version: "1", chainId: robinhood.id, verifyingContract: KSKD_ENTRY },
    types: {
      Claim: [
        { name: "recipient", type: "address" },
        { name: "cumulativeBurned", type: "uint256" },
        { name: "deadline", type: "uint256" },
      ],
    },
    primaryType: "Claim",
    message: { recipient, cumulativeBurned, deadline },
    signature,
  });
  const registered = await client.readContract({ address: KSKD_ENTRY, abi: entryAbi, functionName: "validSigner", args: [signer] });
  console.log({ recipient, cumulativeBurned, deadline: new Date(Number(deadline) * 1000).toISOString(), signer, registered });
}

$ npx tsx verify-claim.ts 0xfd16d94972dbdbad093c5f9e455dea326300abc054b781a50613faa4849a70f7
{
  recipient: '0x313807B857222278FbddF36541DE2Af5a50BdCB5',
  cumulativeBurned: 1000000000000000000000n,
  deadline: '2026-10-12T17:20:23.000Z',
  signer: '0x7d3B23a631501a35cafe4F00133653A1b90f2CC3',
  registered: true
}

# Burns on Igra
cast logs --address 0x5A818D42cA142483f72AE7D426E199324FEc4871 \
  "Exited(address indexed sender, address indexed recipient, uint256 amount, uint256 cumulative)" \
  --from-block 18880615 --to-block 18979615 --rpc-url https://rpc.igralabs.com:8545

# Mints on Robinhood Chain
cast logs --address 0x7b1D080d2485E63791468d73418e2B262c25C402 \
  "Claimed(address indexed recipient, uint256 minted, uint256 cumulative, uint256 attested)" \
  --from-block 84780080 --rpc-url https://rpc.mainnet.chain.robinhood.com