; }; export const AtlasSettlementExplorer = () => { const aseIsDark = () => typeof document !== "undefined" && (document.documentElement.classList.contains("dark") || document.documentElement.getAttribute("data-theme") === "dark"); const [dark, setDark] = useState(aseIsDark); useEffect(() => { if (typeof document === "undefined") return; const root = document.documentElement; const read = () => setDark(aseIsDark()); read(); const obs = new MutationObserver(read); obs.observe(root, { attributes: true, attributeFilter: ["class", "data-theme"] }); return () => obs.disconnect(); }, []); const ASE_C = dark ? { bg: "#161617", panel: "#1f1f1f", ink: "#f4f5f5", body: "#cacbce", mut: "#9a9da2", line: "rgba(228, 229, 231, 0.16)", edge: "rgba(228, 229, 231, 0.42)", soft: "rgba(228, 229, 231, 0.07)", proposer: "#90acf9", acceptor: "#e4b45c", network: "#5fd6e8", onAccent: "#141415", termBg: "#0f0f10", termInk: "#f4f5f5", termMut: "#8b8f94" } : { bg: "#f4f5f5", panel: "#ffffff", ink: "#141415", body: "#4e5055", mut: "#6b6e73", line: "#e4e5e7", edge: "#b3b7bd", soft: "#f4f5f5", proposer: "#5580f6", acceptor: "#b45309", network: "#0e8fa3", onAccent: "#ffffff", termBg: "#141415", termInk: "#f4f5f5", termMut: "#8b8f94" }; const ASE_FONT = "ui-sans-serif, system-ui, -apple-system, 'Segoe UI', sans-serif"; const ASE_MONO = "ui-monospace, SFMono-Regular, Menlo, 'IBM Plex Mono', monospace"; const ASSETS = ["USD", "USDx_ETH", "USDx_SOL"]; const fmt = n => Math.abs(n).toLocaleString("en-US"); const legsFor = (type, scope) => { const multi = scope === "multi"; if (type === "send") { return multi ? [{ a: "USD", amt: -10000 }, { a: "USDx_ETH", amt: -5000 }] : [{ a: "USD", amt: -10000 }]; } if (type === "receive") { return multi ? [{ a: "USD", amt: 10000 }, { a: "USDx_ETH", amt: 5000 }] : [{ a: "USD", amt: 10000 }]; } return multi ? [{ a: "USD", amt: -10000 }, { a: "USDx_ETH", amt: -5000 }, { a: "USDx_SOL", amt: 15000 }] : [{ a: "USD", amt: -10000 }, { a: "USDx_ETH", amt: 10000 }]; }; const acceptorLegs = legs => legs.map(l => ({ a: l.a, amt: -l.amt })); const legList = legs => legs.map(l => (l.amt < 0 ? "−" : "+") + fmt(l.amt) + " " + l.a).join(", "); const authText = (who, channel) => channel === "api" ? "API: POST /atlas/settlements/{settlementId}/authorize (requires the Authorize settlements permission)" : "UI: authorized in the app via quorum approval, per " + who + "'s organization policy"; const acceptText = channel => channel === "api" ? "API: POST /atlas/settlements/{settlementId}/accept" : "UI: accepted from the web dashboard"; const buildSteps = (type, scope, channel) => { const pLegs = legsFor(type, scope); const aLegs = acceptorLegs(pLegs); const needsAcceptorAuth = type !== "send"; const receivingSide = type === "send" ? "acceptor" : type === "receive" ? "proposer" : "both"; const chain = needsAcceptorAuth ? ["Proposed", "Authorized", "Accepted", "Authorized", "Executing", "Executed"] : ["Proposed", "Authorized", "Accepted", "Executing", "Executed"]; const steps = []; steps.push({ title: "Configuration", desc: type === "send" ? "Proposer collects the acceptor's participantId and confirms its Atlas participant vault is configured." : "Both sides collect each other's participantId and confirm their Atlas participant vaults are configured.", chan: null, network: null, chain, stateIndex: -1, edge: null, walletsActive: { proposer: [], acceptor: [] }, ledger: [] }); steps.push({ title: "Propose settlement", desc: "Proposer calls Propose a settlement with " + legList(pLegs) + ". Amounts exclude fees: negative means sending, positive means receiving.", chan: "API: POST /atlas/settlements (no dashboard alternative is documented for proposing)", network: "Proposed", chain, stateIndex: 0, edge: "propose", walletsActive: { proposer: pLegs.map(l => l.a), acceptor: [] }, ledger: [{ who: "Proposer", action: "Propose a settlement", note: "clientReferenceId set by proposer", lines: pLegs }] }); steps.push({ title: "Proposer authorizes", desc: "The proposed settlement must be authorized before it can move.", chan: authText("the proposer", channel), network: "Authorized", chain, stateIndex: 1, edge: "authP", walletsActive: { proposer: pLegs.map(l => l.a), acceptor: [] }, ledger: [{ who: "Proposer", action: "Authorize settlement", note: null, lines: [] }] }); steps.push({ title: "Acceptor detects the settlement", desc: type === "send" ? "Acceptor polls List settlements to find the pending proposal." : "Acceptor polls List settlements to find the pending proposal (having already registered its own participantId with the proposer).", chan: channel === "api" ? "API: GET /atlas/settlements (poll)" : "UI: appears in the acceptor's pending settlements queue", network: "Proposed", chain, stateIndex: 1, edge: "detect", walletsActive: { proposer: pLegs.map(l => l.a), acceptor: [] }, ledger: [] }); steps.push({ title: "Accept", desc: "Acceptor selects its vault and wallet(s), then accepts with inverted amounts: " + legList(aLegs) + ". By asset, this must exactly net to zero against the proposer's amounts.", chan: acceptText(channel), network: "Accepted", chain, stateIndex: 2, edge: "accept", walletsActive: { proposer: pLegs.map(l => l.a), acceptor: aLegs.map(l => l.a) }, ledger: [{ who: "Acceptor", action: "Accept settlement", note: "createWallet available per-asset if needed", lines: aLegs }] }); if (needsAcceptorAuth) { steps.push({ title: "Acceptor authorizes", desc: "Because this settlement requires the acceptor to fund a leg, the acceptor must also authorize before execution.", chan: authText("the acceptor", channel), network: "Authorized", chain, stateIndex: 3, edge: "authA", walletsActive: { proposer: pLegs.map(l => l.a), acceptor: aLegs.map(l => l.a) }, ledger: [{ who: "Acceptor", action: "Authorize settlement", note: null, lines: [] }] }); } const condDesc = type === "twoway" ? "All four conditions are met: proposer authorized, acceptor accepted, acceptor authorized, and both sides fund their legs plus on-chain fees. Anchorage Digital moves both legs together." : "The proposer is authorized and funded, including on-chain fees. Anchorage Digital moves the funds."; steps.push({ title: "Execute", desc: condDesc, chan: null, network: "Executing → Executed", chain, stateIndex: needsAcceptorAuth ? 4 : 3, edge: "execute", dirs: { toAcceptor: pLegs.some(l => l.amt < 0), toProposer: pLegs.some(l => l.amt > 0) }, gasLegs: pLegs.map(l => ({ asset: l.a, sender: l.amt < 0 ? "proposer" : "acceptor", native: nativeGas(l.a) })), walletsActive: { proposer: pLegs.map(l => l.a), acceptor: aLegs.map(l => l.a) }, ledger: pLegs.map(l => ({ who: l.amt < 0 ? "Proposer → Acceptor" : "Acceptor → Proposer", action: l.a + " leg settles", note: l.a === "USD" ? "Fedwire, no network fee" : "on-chain, network fee applies", lines: [l] })) }); steps.push({ title: "Confirm deposit", desc: (receivingSide === "both" ? "Both proposer and acceptor" : receivingSide === "acceptor" ? "Acceptor" : "Proposer") + " confirm receipt via List transactions, filtering on type: Deposit.", chan: null, network: "Executed", chain, stateIndex: needsAcceptorAuth ? 5 : 4, edge: "confirm", walletsActive: { proposer: pLegs.map(l => l.a), acceptor: aLegs.map(l => l.a) }, ledger: [] }); steps.push({ title: "Verify final state", desc: "Both proposer and acceptor verify the final state via List settlements.", chan: null, network: "Executed", chain, stateIndex: needsAcceptorAuth ? 5 : 4, edge: "verify", walletsActive: { proposer: [], acceptor: [] }, ledger: [] }); return steps; }; const AseSeg = ({label, options, value, onChange, accent}) =>

{label}

{options.map(o => { const on = value === o.v; return ; })}

; const AseNode = ({x, y, w, h, title, sub, accent, active, children}) => {title} {sub && {sub} } {children} ; const AseWalletChip = ({asset, active, x, y, accent}) => {asset} ; const AseEdge = ({d, active, accent, dashed}) => ; const AseChain = ({chain, idx, x0, y, xSpan}) => { const n = chain.length; const step = xSpan / (n - 1); return {idx >= 0 && } {chain.map((label, i) => { const cx = x0 + step * i; const passed = idx >= 0 && i <= idx; const active = i === idx; return {active && } ; })} ; }; const AseMesh = ({active, cx, cy, r}) => { const pts = []; for (let i = 0; i < 6; i++) { const ang = Math.PI / 180 * (i * 60 - 90); pts.push([Math.round((cx + r * Math.cos(ang)) * 10) / 10, Math.round((cy + r * Math.sin(ang)) * 10) / 10]); } return {pts.map((p, i) => { const b = pts[(i + 1) % 6]; return ; })} {pts.map((p, i) => )} {pts.map((p, i) => )} {active && } ; }; const nativeGas = asset => asset === "USD" ? null : asset === "USDx_SOL" ? "SOL" : "ETH"; const AseDiagram = ({step, gas}) => { const on = id => step.edge === id; const isConfig = step.title === "Configuration"; const netActive = !!step.network; const dirs = step.dirs || ({}); const isExecute = on("execute"); const gasLegs = step.gasLegs || []; const sentBy = side => gasLegs.filter(g => g.sender === side); const gasFor = side => { const legs = sentBy(side); const onChain = legs.filter(g => g.native); return { sendsNothing: legs.length === 0, usdOnly: legs.length > 0 && onChain.length === 0, stationActive: gas === "station" && onChain.length > 0, natives: Array.from(new Set(onChain.map(g => g.native))) }; }; const pGas = isExecute ? gasFor("proposer") : null; const aGas = isExecute ? gasFor("acceptor") : null; const hexPath = (cx, cy, r) => { const pts = []; for (let i = 0; i < 6; i++) { const ang = Math.PI / 180 * (i * 60 - 90); pts.push(`${(cx + r * Math.cos(ang)).toFixed(1)},${(cy + r * Math.sin(ang)).toFixed(1)}`); } return `M${pts.join("L")}Z`; }; const gasNode = (cx, accent, g) => { if (!g || g.sendsNothing) return null; if (g.usdOnly) { return USD leg, no gas needed ; } if (gas === "wallet") { return Gas: wallet-funded ({g.natives.join("/")}) ; } const cy = 240; const r = 22; return Gas station {g.stationActive && } {g.stationActive ? `funding ${g.natives.join("/")}` : "ETH · SOL"} ; }; return ; }; const AseLedgerPanel = ({entries, maxHeight = 220}) => { const boxRef = useRef(null); useEffect(() => { if (boxRef.current) boxRef.current.scrollTop = boxRef.current.scrollHeight; }, [entries.length]); return

{entries.length === 0 &&

No requests yet. Select play.

} {entries.map((e, i) =>

{e.action} {e.note && · {e.note}}

{e.lines.map((l, j) =>

{e.who} {l.a} {l.amt < 0 ? "−" : "+"}{fmt(l.amt)}

)}

; }; const [type, setType] = useState("send"); const [scope, setScope] = useState("single"); const [channel, setChannel] = useState("api"); const [gas, setGas] = useState("station"); const [step, setStep] = useState(0); const [playing, setPlaying] = useState(false); const [ledgerOpen, setLedgerOpen] = useState(true); const steps = buildSteps(type, scope, channel); useEffect(() => { setStep(0); setPlaying(false); }, [type, scope, channel, gas]); useEffect(() => { if (!playing) return; const t = setInterval(() => { setStep(p => { if (p >= steps.length - 1) { setPlaying(false); return p; } return p + 1; }); }, 2800); return () => clearInterval(t); }, [playing, steps.length]); const safeStep = Math.min(step, steps.length - 1); const cur = steps[safeStep]; const ledgerEntries = steps.slice(0, safeStep + 1).flatMap(s => s.ledger); const btn = (extra = {}) => ({ border: `1px solid ${ASE_C.line}`, background: ASE_C.panel, borderRadius: 9, padding: "8px 14px", fontFamily: ASE_FONT, fontSize: 13, fontWeight: 600, cursor: "pointer", color: ASE_C.ink, ...extra }); const sectionLabel = { fontFamily: ASE_MONO, fontSize: 11, letterSpacing: "0.04em", color: ASE_C.mut, fontWeight: 600, marginBottom: 10 }; return

{steps.map((_, i) =>

Step {safeStep} of {steps.length - 1}

{}

{safeStep === 0 ? "SETUP" : `STEP ${safeStep} / ${steps.length - 1}`} {cur.title}

{cur.desc}

{cur.chan &&

{cur.chan}

}

dashed = oversight/query · solid = movement of value or instruction · animated = active this step

Settlement · leg scope · channel · gas

Type: {type === "send" ? "Send (one-way)" : type === "receive" ? "Receive (one-way)" : "Two-way"}

Leg scope: {scope === "single" ? "Single-leg, one asset amount per direction" : "Multi-leg, several asset amounts bundled into one settlement instruction"}

Channel: {channel === "api" ? "API, authorize/accept called directly against the endpoints" : "UI, authorize/accept happen in the web dashboard, gated by org quorum policy"}

Gas source: {gas === "station" ? "Gas station, tops up ETH or SOL, whichever the moving leg needs; USD legs never need gas at all" : "Wallet-funded, every sending wallet covers its own ETH or SOL gas; USD legs never need gas at all"}

Requests as they post

{ledgerOpen && }

Who does what: this configuration

{[["Proposer authorization", "Required in every settlement type"], ["Acceptor authorization", type === "send" ? "Not required, accept only" : "Required, acceptor funds a leg"], ["Quorum: initiator org", "Quorum approval once initiated"], ["Quorum: acceptor org", type === "send" ? "Accept only" : type === "receive" ? "Accept + quorum approval" : "Accept and quorum approve to send"], ["Funding required before execution", type === "twoway" ? "Both sides: settlement amount plus on-chain fees" : "Proposer: settlement amount plus on-chain fees"], ["Instruction channel", channel === "api" ? "Authorizing via API requires the key to hold the Authorize settlements permission." : "Authorization happens in the app, according to your organization's policy."], ["Network fees", "USD legs are fee-exempt, per the integration guide. USDx_ETH and USDx_SOL legs are on-chain and incur a network fee."], ["Gas Station eligibility", "Gas Station covers both ETH and SOL: USDx_ETH tops up in ETH, USDx_SOL tops up in SOL. USD settles over Fedwire and needs no gas from either source, regardless of the switch."]].map((row, i) =>

{row[0]}

{row[1]}

)}

; };

← Settlement API integration guide Developers · Atlas · Settlement explorer Atlas collateral management →

# Exploring settlement workflows Send, receive, and two-way settlements share the same propose, authorize, and accept mechanics, but differ in who has to authorize and when execution can fire. This explorer walks through the exact sequence for any combination of settlement type, leg scope, and instruction channel. ## The four switches * **Settlement type**: send (one-way), receive (one-way), or two-way. See [Settlement workflows](/knowledge-base/platform/developers/atlas/atlas-settlement-api#settlement-workflows) for the source procedures. * **Leg scope**: single-leg or multi-leg, meaning how many asset amounts are bundled into one settlement instruction. * **Instruction channel**: API or UI, meaning whether authorize and accept happen directly against the endpoints, or in the web dashboard under your organization's quorum policy. * **Gas source**: gas station or wallet-funded, per [`useGasStation`](/knowledge-base/platform/developers/network-gas-fees#gas-station), meaning whether the on-chain gas for a leg is topped up from the organization's gas station, or paid from the sending wallet's own balance. USD legs never need gas at all; they settle over Fedwire, not a blockchain.

## Reading the diagram The proposer and acceptor sit on either side of the Atlas settlement network. Wallet chips light up for the asset or assets actually moving in the current step: one chip under single-leg, several under multi-leg. Solid lines are movement of value or an instruction call; dashed lines are polling or verification. The line that animates is the one active in the current step. The network node's connected-node chain is an illustrative stand-in for settlement state, not a documented enum. Only **Executing** and **Executed** are states the Settlement API integration guide actually names. Every earlier label just names the step most recently completed. This walkthrough uses the literal USD wallet alongside two illustrative on-chain stablecoins, USDx\_ETH and USDx\_SOL (not Anchorage Digital tickers). USD is fee-exempt and needs no gas, per the integration guide. It settles over Fedwire, not a blockchain. USDx\_ETH and USDx\_SOL are on-chain, so each incurs a network fee and draws gas from either the [gas station](/knowledge-base/platform/developers/network-gas-fees#gas-station) or the sending wallet, depending on the gas source switch: ETH for USDx\_ETH, SOL for USDx\_SOL. For the authoritative endpoint list, required permissions, and quorum table, see [Settlement API integration guide](/knowledge-base/platform/developers/atlas/atlas-settlement-api).

← Previous Settlement API integration guide Next → Atlas collateral management

## Related topics - [Exploring settlement workflows](/knowledge-base/platform/users/atlas-settlement-explorer.md) - [Settlement API integration guide](/knowledge-base/platform/developers/atlas/atlas-settlement-api.md) - [Exploring account structures](/knowledge-base/platform/developers/account-structure-explorer.md) - [API Changelog](/knowledge-base/porto/api-reference/changelog.md)