Verify swap settlement

Verify a submitted swap by checking its transactions and returned token records. The examples default to mainnet and read existing state. For a Quickstart trade, select the testnet lookup and use its original testnet account and recovery store. A completed trade has an accepted swap, an accepted claim for that swap, and returned token records available to the account. Check these separately:

Check	What it establishes
Both transactions report `accepted`	The ledger accepted the swap and claim.
The swap and claim reference the same swap ID	The claim belongs to the trade being checked.
`swap_outputs[swap_id]` is absent after acceptance	No pending output remains for that swap. Absence alone does not prove a swap ever existed.
An unspent ETH record matches the claim’s output commitment and amount	The account can find the exact proceeds from this claim. A total balance alone cannot identify their source.

Keep the swap transaction ID, claim transaction ID, swap ID, and actual received amount from the execution output. Use the swap ID including its field suffix. Do not substitute the quoted estimate or minimum for the received amount.

Check both transactions

Use the lookup for the network that received the trade. The response includes status, transaction, and finalize. Replace each placeholder with the original transaction ID:

Mainnet
Testnet

curl --fail-with-body --silent --show-error \
  "https://api.explorer.provable.com/v1/mainnet/transaction/confirmed/SWAP_TRANSACTION_ID"
curl --fail-with-body --silent --show-error \
  "https://api.explorer.provable.com/v1/mainnet/transaction/confirmed/CLAIM_TRANSACTION_ID"

curl --fail-with-body --silent --show-error \
  "https://api.explorer.provable.com/v1/testnet/transaction/confirmed/SWAP_TRANSACTION_ID"
curl --fail-with-body --silent --show-error \
  "https://api.explorer.provable.com/v1/testnet/transaction/confirmed/CLAIM_TRANSACTION_ID"

Inspect status in each JSON response. HTTP success alone is not transaction acceptance.

Result	Next action
`accepted` for both	Verify the matching output record below.
`rejected` for the swap	Inspect the rejection and input-record state before preparing a new trade.
Swap accepted, claim rejected	Recover the existing swap after checking whether its output remains claimable.
Not found, timeout, or another lookup error	The outcome is unknown. Check the network, ID, and connectivity, then repeat the lookup. Do not resubmit based on this result.

For TypeScript SDK 0.12.1, the equivalent lookup is await publicClient.getConfirmedTransaction({ id }). Keep publicClient from aleo.createAleoClient({ privateKey }); the wallet client extended with shieldSwapActions does not expose this method by default. See Swap History & Recovery to check an uncertain transaction before retrying.

Verify the output record

This TypeScript verifier checks a USDCx to ETH trade using the 0.12.1 SDK packages. It uses the network selected by the configured clients. It checks the ETH proceeds; a trade with an input refund also needs its USDCx refund record checked. Run verification before spending or combining the returned ETH record. A later spend can make this unspent-record check fail even though settlement succeeded. The verifier uses the configured ledger gateway and account scanner. It is independent of CLI history summaries, but is not a standalone cryptographic ledger proof. Record plaintext stays in memory and is never printed.

1. Load the existing account

For mainnet, use the client and publicClient initialized in Setup. For testnet, use the clients from the Quickstart. Keep the original private key and recovery store; do not generate a new account. If the trade came from a packaged SDK example, load that example’s account and store instead. The verification snippet also uses transaction types from the core package:

npm install @provablehq/veil-core@0.12.1

For a CLI trade, load the saved session from the directory containing its .shield-swap/ account:

import { loadSession } from "@provablehq/shield-swap-cli/session"
import { getConfirmedTransaction } from "@provablehq/veil-core"

const { client } = await loadSession({ network: "mainnet" })
const publicClient = {
  getConfirmedTransaction: (params: Parameters<typeof getConfirmedTransaction>[1]) =>
    getConfirmedTransaction(client, params),
}

The session helper requires @provablehq/shield-swap-cli@0.12.1 in the application’s dependencies. It reuses the saved account for the selected network. Pass network: "testnet" for a CLI Quickstart trade.

2. Match the claim to its output record

The following snippet performs one verification pass with the existing clients. Replace the four input placeholders with the original transaction IDs, swap ID, and actual received ETH amount. receivedEth is a decimal string without the token symbol. If confirmation or scanning has not caught up, repeat the checks without submitting a transaction.

import assert from "node:assert/strict"
import type { Execution } from "@provablehq/veil-core"
import { parseTokenRecordInfo, parseUnits, formatUnits } from "@provablehq/shield-swap-sdk"

const swapTx: string = "SWAP_TRANSACTION_ID"
const claimTx: string = "CLAIM_TRANSACTION_ID"
const swapId = "SWAP_ID"
const receivedEth = "RECEIVED_ETH"
assert(swapTx && claimTx && swapId && receivedEth,
  "Pass swap transaction ID, claim transaction ID, swap ID, and received ETH")
assert(/^\d+field$/.test(swapId), "Swap ID must include its field suffix")
assert(swapTx !== claimTx, "Swap and claim must be different transactions")

try {
  const swap = await publicClient.getConfirmedTransaction({ id: swapTx })
  const claim = await publicClient.getConfirmedTransaction({ id: claimTx })
  assert.equal(swap.status, "accepted", "Swap is not accepted")
  assert.equal(claim.status, "accepted", "Claim is not accepted")
  assert.equal(swap.transaction.id, swapTx, "Swap transaction ID mismatch")
  assert.equal(claim.transaction.id, claimTx, "Claim transaction ID mismatch")
  console.log("Swap: accepted; claim: accepted")

  const swapCalls = (swap.transaction.execution as Execution | undefined)?.transitions ?? []
  const claimCalls = (claim.transaction.execution as Execution | undefined)?.transitions ?? []
  const swapCall = swapCalls.find((t) =>
    t.program === "shield_swap.aleo" &&
    ["swap", "swap_multi_hop"].includes(t.function) &&
    t.outputs?.some((o) => o.type === "public" && o.value === swapId))
  const claimCall = claimCalls.find((t) =>
    t.program === "shield_swap.aleo" &&
    ["claim_swap_output", "claim_swap_output_no_refund"].includes(t.function) &&
    t.inputs?.[2]?.type === "public" && t.inputs[2].value === swapId)
  assert(swapCall && claimCall, "Transactions do not reference the supplied swap ID")

  const eth = await client.tokenData("ETH")
  const expected = parseUnits(receivedEth, eth.decimals)
  assert(expected > 0n, "Received ETH must be positive")
  // In these claim entry points, inputs 4 and 5 are token_out and amount_out.
  assert.equal(claimCall.inputs?.[4]?.value, eth.id, "Claim output token is not ETH")
  assert.equal(claimCall.inputs?.[5]?.value, `${expected}u128`,
    "Received amount does not match the accepted claim")

  const pending = await client.getSwapOutput({ swapId })
  assert.equal(pending, null, "Pending swap output still exists; check ledger state")
  console.log("Swap ID: matched; pending output: absent")

  const program = eth.underlyingProgram ?? eth.ammTokenProgram
  assert(program, "ETH token metadata has no output program")
  const commitments = new Set(claimCalls
    .filter((t) => t.program === program)
    .flatMap((t) => t.outputs ?? [])
    .filter((o) => ["record", "record_with_dynamic_id"].includes(o.type))
    .map((o) => o.id))
  assert(commitments.size > 0, "Claim has no ETH record output")

  const records = await client.requestRecords({
    program,
    statusFilter: "unspent",
    includePlaintext: true,
  })
  const matched = records.some((record) => {
    if (record.spent !== false || record.programName !== program ||
        !record.commitment || !commitments.has(record.commitment) ||
        !("recordPlaintext" in record) ||
        typeof record.recordPlaintext !== "string" || !record.recordPlaintext) return false
    const info = parseTokenRecordInfo(record.recordPlaintext)
    return info !== null && !info.recipientBound && info.amount === expected &&
      (info.tokenId === undefined || info.tokenId === eth.id)
  })
  assert(matched,
    "No matching unspent ETH record. Check scanner progress, account, or later spends")
  console.log(`ETH record: unspent; commitment matched; amount ${formatUnits(expected, eth.decimals)}`)
  console.log("VERIFIED: swap accepted, claim accepted, pending output cleared, ETH record available")
} catch (error) {
  console.error(error instanceof assert.AssertionError
    ? error.message
    : "Verification read failed. Check connectivity and inputs, then rerun verification.")
  process.exitCode = 1
}

The commitment comparison identifies an output created by this claim, even if the account already held ETH. Amounts use bigint base units throughout, avoiding floating-point rounding.

3. Inspect the result

A successful run ends with:

VERIFIED: swap accepted, claim accepted, pending output cleared, ETH record available

If a check fails, inspect the last completed stage. A scanner delay, wrong account, wrong ID, or later record spend can prevent verification. An empty getUnclaimedSwaps() result or an absent mapping alone is insufficient evidence. Repeat read-only checks or follow Failures and recovery; do not rerun the original swap to obtain a verification result.

Packaged trading examples

The TypeScript example in Veil and Python example in python-sdk include complete trading programs. Their run commands submit new testnet swaps. Use the read-only checks above to verify an existing trade.

Understand Shield Swap

Trading reference

Concepts

Data and confidentiality

Security and controls

Math and accounting

Program reference

Verify swap settlement

Check both transactions

Verify the output record

1. Load the existing account

2. Match the claim to its output record

3. Inspect the result

Packaged trading examples

​Check both transactions

​Verify the output record

​1. Load the existing account

​2. Match the claim to its output record

​3. Inspect the result

​Packaged trading examples

Check both transactions

Verify the output record

1. Load the existing account

2. Match the claim to its output record

3. Inspect the result

Packaged trading examples