JIT Redemption Pattern (GBLIN → USDC)

When this skill applies

Trigger when:

• The agent's treasury is in GBLIN and needs to pay an outgoing x402 invoice in USDC
• The user wants atomic single-transaction GBLIN → USDC conversion
• The agent is building "lazy treasury" patterns (only convert when needed)

What JIT redemption does

The GBLIN protocol's swap_gblin_to_usdc_jit endpoint returns calldata for a single transaction that:

1. Burns the right amount of GBLIN
2. Withdraws the user's proportional share of WETH, cbBTC, USDC from the treasury
3. Swaps WETH and cbBTC to USDC via Uniswap V3 (with MEV-safe min outs)
4. Transfers the resulting USDC to the user

All in one transaction. No intermediate states. Compatible with EOA, ERC-4337 Smart Accounts, and EIP-7702.

Endpoint

GET https://gblin.digital/api/x402/jit?wallet=<address>&usdc=<amount>

Response (after x402 payment of $0.005 USDC):

{
  "action": "single_atomic_tx",
  "target_contract": "0x36C81d7E1966310F305eA637e761Cf77F90852f0",
  "calldata": "0x...",
  "value": "0",
  "compatibility": { "eoa": true, "erc4337": true, "eip7702": true }
}

When to use JIT redemption

Use when:

• You need exactly X USDC and have at least X-equivalent in GBLIN
• The payment is happening now (within the next minute)
• You want one atomic transaction

Do not use when:

• You're inside the 2-minute cooldown after a recent deposit (will revert)
• You need amounts smaller than ~$0.10 (gas + slippage eats too much)
• The market is highly volatile (Crash Shield active) — slippage may be wide

Code pattern: pay x402 invoice with GBLIN

import { createWalletClient, http, parseUnits } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { base } from 'viem/chains';

const GBLIN_JIT = 'https://gblin.digital/api/x402/jit';

async function payInvoiceWithGblin(params: {
  privateKey: `0x${string}`;
  walletAddress: `0x${string}`;
  invoiceAmountUsdc: number;
  recipient: `0x${string}`;
}) {
  const url = `${GBLIN_JIT}?wallet=${params.walletAddress}&usdc=${params.invoiceAmountUsdc}`;
  const response = await fetch(url);
  if (response.status === 402) {
    throw new Error('JIT endpoint requires x402 payment of $0.005 USDC');
  }
  const jit = await response.json();

  const account = privateKeyToAccount(params.privateKey);
  const client = createWalletClient({ account, chain: base, transport: http() });

  const hash = await client.sendTransaction({
    to: jit.target_contract as `0x${string}`,
    data: jit.calldata as `0x${string}`,
    value: BigInt(jit.value || 0),
  });

  return { redemptionTx: hash };
}

Handling the cooldown

GBLIN enforces a 2-minute cooldown between deposit and redemption to prevent flash-loan exploits. Plan around this:

async function safeRedeem(walletAddress: string, amount: number) {
  const health = await fetch(`https://gblin.digital/api/x402/health?wallet=${walletAddress}`);
  const status = await health.json();

  if (status.cooldownActive) {
    const waitMs = (status.cooldownRemainingSeconds || 120) * 1000;
    return { needsWait: true, waitMs, retryAt: Date.now() + waitMs };
  }
  return { needsWait: false };
}

For agents with predictable revenue cycles, time your invests so that cooldown windows align with quiet hours.

Slippage protection

JIT redemption swaps WETH and cbBTC to USDC at market price. The protocol embeds a maxInternalSlippage parameter (default 2% buffer) into the calldata. During extreme volatility, this may not be enough.

If you need tighter slippage:

1. Check Crash Shield status first — if active, postpone non-urgent redemptions
2. Use smaller redemption amounts to reduce price impact
3. Spread redemptions across multiple transactions if amount > $1000

Alternative: pre-emptive redemption

For agents with known upcoming outflows, redeem ahead of time and hold USDC operational reserve:

const expectedWeeklyOutflows = 50; // USDC
const operationalReserve = expectedWeeklyOutflows * 1.5;

if (usdcBalance < operationalReserve && gblinValueUsdc > operationalReserve) {
  await jitRedeem(walletAddress, operationalReserve - usdcBalance);
}

This trades NAV growth opportunity for execution certainty. Choose based on your agent's risk tolerance.

References

• GBLIN smart contract source: https://github.com/gblinproject/GBLIN-Protocol
• Treasury patterns: skills/base-agent-treasury
• Self-funding loop: skills/agent-self-funding