Build with the SDK

import {
  PaymentGatewayClient,
  createSenderSigner,
  signPaymentRequest,
  waitForTerminalStatus,
  assetChainId,
  getErrorResponse,
} from '@atumlabs/payment-gateway-client';

const GATEWAY_URL = 'https://payment-gw.production-testnet.atum.xyz';

const SOURCE_ASSET =
  'eip155:421614/erc20:0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d';
const DESTINATION_ASSET =
  'eip155:11142220/erc20:0x01C5C0122039549AD1493B8220cABEdD739BC44E';
const AMOUNT = '10000'; // 0.01 USDC (6 decimals)

// Your idempotency key: names this ONE payment, so a re-attempt with the SAME
// requestId resolves onto it instead of creating a second payment. The SDK
// requires it and never generates one for you — a library-chosen id is an id you
// cannot reuse on a retry. This sample mints a fresh one per run, so each run is
// a NEW payment.
// Set REQUEST_ID to resume a payment that was interrupted while still settling:
//   REQUEST_ID=<the id printed below> npx tsx send-payment.ts
const REQUEST_ID = process.env.REQUEST_ID || `sdk-quickstart-${Date.now()}`;

async function main() {
  const privateKey = process.env.PRIVATE_KEY ?? process.env.ATUM_TESTNET_PRIVATE_KEY;
  const depositor = process.env.SENDER ?? process.env.ATUM_TESTNET_SOURCE_ADDRESS;
  const destination =
    process.env.RECEIVER ?? process.env.ATUM_TESTNET_DESTINATION_ADDRESS;

  if (!privateKey || !depositor || !destination) {
    throw new Error('Set PRIVATE_KEY, SENDER, and RECEIVER in .env');
  }

  const client = new PaymentGatewayClient({ BASE: GATEWAY_URL });

  const paymentRequest = await client.preparePaymentRequest({
    depositor,
    requestId: REQUEST_ID,
    fulfillmentAmount: AMOUNT,
    sourceAsset: SOURCE_ASSET,
    destinationAccount: destination,
    destinationAsset: DESTINATION_ASSET,
  });
  console.log(`Prepared payment request (requestId: ${REQUEST_ID})`);
  console.log(`To retry this exact payment later: REQUEST_ID=${REQUEST_ID} npx tsx send-payment.ts`);

  // pinnedAddress makes the signer refuse if the key does not derive `depositor`.
  // Without it a typo signs as the wrong payer, which the gateway accepts and the
  // chain then reverts at settlement.
  // createSenderSigner takes the CAIP-2 CHAIN id, not the CAIP-19 asset id.
  // assetChainId extracts it: eip155:421614/erc20:0x75f… -> eip155:421614
  const signer = createSenderSigner(assetChainId(SOURCE_ASSET), {
    privateKey,
    pinnedAddress: depositor,
  });
  await signPaymentRequest(paymentRequest, signer);
  console.log('Signed payment authorization');

  const response = await client.payments.submitPayment({ requestBody: paymentRequest });
  console.log('Submitted payment');
  console.log(JSON.stringify(response, null, 2));

  if (!response.payment_id) {
    throw new Error('Submit response missing payment_id');
  }

  // true means this requestId already existed and you were handed the original
  // payment — nothing additional was charged.
  if (response.idempotent_replay) {
    console.log(`Replay: payment ${response.payment_id} already existed for this requestId`);
  }

  if (response.fulfillment_confirmation) {
    console.log('Settlement completed synchronously');
    return;
  }

  // waitForTerminalStatus owns the definition of "terminal" and keeps polling
  // through a failed status check, which is the worst moment to stop looking.
  console.log(`Waiting on payment_id ${response.payment_id}…`);
  const outcome = await waitForTerminalStatus({
    fetchStatus: () => client.payments.getPaymentStatus({ paymentId: response.payment_id! }),
    budgetMs: 120_000,
  });

  // Exit codes match the CLI's, so either tool can drive the same script:
  // 0 settled, 2 still settling (NOT a failure), 3 terminal failure.
  if (outcome.timedOut) {
    console.log(`Still settling — re-run with REQUEST_ID=${REQUEST_ID} to resume.`);
    process.exit(2);
  }
  console.log(JSON.stringify(outcome.snapshot, null, 2));
  if (outcome.snapshot?.status !== 'completed') {
    // `waitForTerminalStatus` only returns on `completed` or `failed`, so this
    // payment can never settle. A fresh attempt needs a NEW requestId.
    console.error(`Payment ${outcome.snapshot?.status} — this is final.`);
    process.exit(3);
  }
}

main().catch((err) => {
  // Gateway refusals carry a typed body: branch on `code`, not on the message text.
  const gatewayError = getErrorResponse(err);
  console.error(gatewayError ?? err);
  process.exit(1);
});