Papers
Topics
Authors
Recent
Search
2000 character limit reached

Atomic Service Channels (ASCs)

Updated 4 July 2026
  • Atomic Service Channels (ASCs) are off-chain constructions that atomically bind service execution with payment settlement to prevent intermediate state leakage.
  • They employ advanced cryptographic techniques such as zk-SNARKs, VSS, and TEE-assisted adaptor signatures to enforce fairness and secure state transitions.
  • Empirical evaluations demonstrate that ASCs achieve high throughput, significantly lower on-chain costs, and minimal settlement latency compared to standard payment channels.

Atomic Service Channels (ASCs) are off-chain channel constructions that bind service exchange to balance settlement so that the composite interaction is atomic rather than decomposed into separable payment and delivery steps. In the current arXiv literature, the term is used in two closely related but non-identical senses. In Cross-Channel, an ASC between parties S\mathcal{S} and R\mathcal{R} spanning blockchains α\alpha and β\beta is a pair of off-chain state channels Ω0α,Ω0β\Omega^\alpha_0,\Omega^\beta_0 for high-frequency cross-chain services such as payments, information exchanges, and barter trades. In A402, an ASC with respect to blockchain L\mathcal{L} is a tuple (C,S,Γ)(C,S,\Gamma) that integrates service execution into a payment channel for Machine-to-Machine commerce, with explicit exec-pay-deliver atomicity and optional private settlement through a TEE-based Liquidity Vault (Guo et al., 2022, Li et al., 1 Mar 2026).

1. Definitions and conceptual scope

Cross-Channel defines the atomicity goal as an all-or-nothing property over the paired channels: either S\mathcal{S} and R\mathcal{R} remain in their pre-service states, or they swap states atomically so that S\mathcal{S} obtains R\mathcal{R}-offered assets and R\mathcal{R} obtains S\mathcal{S}-offered assets, with no intermediate leakage. Its notion of fairness is that neither party can learn or enjoy the exchanged object—cryptocurrency, encrypted data, or digital commodity—before the other party has irrevocably committed its own side. A402 formalizes an ASC as (C,S,Γ)(C,S,\Gamma), where Γ=(B,σ)\Gamma=(\mathbf{B},\sigma), B=⟨bc,bs⟩\mathbf{B}=\langle b^c,b^s\rangle, and σ∈{OPEN,LOCKED,PENDING,CLOSED}\sigma\in\{OPEN,LOCKED,PENDING,CLOSED\}. It exposes three interfaces: openASC(C,S,v)→{Γ0,tx(create)},Γ0=(⟨v,0⟩,OPEN),\texttt{openASC}(C,S,v)\to\{\Gamma_0,tx_{(create)}\},\quad \Gamma_0=(\langle v,0\rangle,OPEN),

execPayDeliver(Γk,req,δ)→{Γk+1,res,ok},\texttt{execPayDeliver}(\Gamma_k,req,\delta)\to\{\Gamma_{k+1},res,ok\},

closeASC(Γfinal)→tx(close).\texttt{closeASC}(\Gamma_{final})\to tx_{(close)}.

A402 also contrasts ASCs with a standard payment channel ΠPC\Pi_{PC}, which tracks only B\mathbf{B} and supports Open, Pay, and Close. In that formulation there is no notion of service execution or result delivery, and state transitions are purely asset-centric. The explicit consequence given is that such channels lack any binding between off-chain service execution and on-chain payment, leading to fairness violations such as free-riding or non-payment.

Dimension Cross-Channel ASC A402 ASC
Formal object pair Ω0α,Ω0β\Omega^\alpha_0,\Omega^\beta_0 tuple (C,S,Γ)(C,S,\Gamma)
Primary setting cross-chain services across α,β\alpha,\beta Web 3.0 payments bound to Web 2.0 services
Native operations hierarchical off-chain service exchange and cross-chain settlement openASC\texttt{openASC}, execPayDeliver\texttt{execPayDeliver}, closeASC\texttt{closeASC}
Core enforcement hierarchical settlement, general fair exchange, HTLC-style hash-timelock TEE-assisted adaptor signatures, dispute window, TEE-based Liquidity Vault

These definitions place ASCs at the intersection of payment channels, fair exchange, and interoperability. This suggests that the term is not merely a synonym for a faster payment channel, but a label for protocols that make service semantics part of the channel state and settlement logic (Guo et al., 2022, Li et al., 1 Mar 2026).

2. Channel architecture and state semantics

The Cross-Channel construction is organized around a hierarchical channel structure designed to avoid the “Unsettled-Amount Congestion” problem, namely funds that are reserved but cannot be re-used until channel closure. Each channel Ω\Omega carries a state

StateΩ=[p1↦v1,  p2↦v2,  … ]Ω\mathsf{State}_\Omega = \bigl[p_1\mapsto v_1,\;p_2\mapsto v_2,\;\dots\bigr]_\Omega

subject to the invariant

∑ivi=CΩ,\sum_i v_i = C_\Omega,

where CΩC_\Omega is the on-chain deposit of Ω\Omega. At layer $0$, the ASC consists of the main channels Ω0α,Ω0β\Omega^\alpha_0,\Omega^\beta_0. When a party needs to spend an unsettled receipt TrTr of value vv in Ω\Omega, it negotiates a sub-channel Ω′\Omega' at layer $1$ with another counterparty to re-use that vv off-chain. More generally, a layer-kk channel Ωk\Omega_k may spawn a layer-(k+1)(k+1) sub-channel Ωk+1\Omega_{k+1} to mobilize newly issued, unsettled receipts of its parent. If the network contains NN nodes and each pair shares a persistent channel at layer $0$, then exchanged receipts flow off-chain until closure, giving effectively O(N)O(N) parallel throughput.

A402 uses a narrower but more explicit state machine. During atomic exchange, the state variable maintained by U\mathcal{U} and SS is

Γ(cid)=(C,S,⟨bfreec,blockedc,bs⟩,σ,k),\Gamma_{(cid)}=(C,S,\langle b^c_{free},b^c_{locked},b^s\rangle,\sigma,k),

where kk is a version counter and σ∈{OPEN,LOCKED,PENDING}\sigma\in\{OPEN,LOCKED,PENDING\} during channel operation. The creation phase begins when CC calls C.reqOpenASC(U,S,v,L,π)C.\texttt{reqOpenASC}(\mathcal{U},S,v,\mathcal{L},\pi). The delegated manager U\mathcal{U} initializes its TEE committee per policy π\pi, checks that no existing ASC(C,S)ASC(C,S) exists, and ensures a secure channel SCSC with SS. It then runs U.openASC(C,S,v)\mathcal{U}.\texttt{openASC}(C,S,v), submits tx(create)tx_{(create)} to L\mathcal{L}, and awaits confirmation. On-chain, L\mathcal{L} locks vv funds in a 2-of-2 or smart-contract address; locally, U\mathcal{U} and SS record Γ0\Gamma_0 in state OPENOPEN.

The architectural difference is direct. Cross-Channel generalizes balance mobility by recursively nesting sub-channels, whereas A402 serializes service execution inside one channel by enforcing the state trajectory OPEN→LOCKED→PENDING→OPENOPEN\to LOCKED\to PENDING\to OPEN, thereby ensuring exactly one request in flight (Guo et al., 2022, Li et al., 1 Mar 2026).

3. Atomic exchange and fair-service enforcement

Cross-Channel’s general fair exchange protocol Θ\Theta is built from zk-SNARK and Pedersen (t,n)(t,n)-VSS. In setup, the parties build an arithmetic circuit CΘC_\Theta that, on private inputs w⃗=(m,k,[k1,…,kn])\vec{w}=(m,k,[k_1,\ldots,k_n]), verifies three conditions: mm encrypts under key kk to ciphertext m‾\overline m; kk shares into {ki}\{k_i\} via (t,n)(t,n)-VSS; and the hash-locks h(m),h(k)h(m),h(k) match public values. Then Setup(1λ,CΘ)→(pk,vk)\mathsf{Setup}(1^\lambda,C_\Theta)\to(\mathsf{pk},\mathsf{vk}). In the share phase, each party runs Pedersen (t,n)(t,n)-VSS.Share on the secret key kk, commits h(k)h(k), uploads {h(ki)}\{h(k_i)\} on-chain, selects nn random miners, and encrypts and signs shares to them; miners verify commitments and may appeal on-chain if a share is invalid. In the exchange phase, the sender computes m‾\overline m and

π=Prove(pk,(h(m),h(k)),(m‾,m,k,[ki])),\pi=\mathsf{Prove}(\mathsf{pk},(h(m),h(k)),(\overline m,m,k,[k_i])),

and the parties swap (π,m‾,h(m),h(k))(\pi,\overline m,h(m),h(k)), after which each runs Verify(vk,⋅)\mathsf{Verify}(\mathsf{vk},\cdot). In the recover phase, both send on-chain Recover\mathsf{Recover} requests, VSS recipients submit TxRecover(ki)\mathsf{Tx}_{\text{Recover}(k_i)}, the contract verifies {h(ki)}\{h(k_i)\}, and once at least tt valid shares are collected, the requester reconstructs kk by Lagrange interpolation and decrypts.

Cross-chain settlement in Cross-Channel then uses an HTLC-style hash-timelock on final channel balances. Parties lock final states under hash h(pre)h(\mathsf{pre}) with time-outs T3>T4T_3>T_4, and the “lock”, “update”, and “refund” steps mirror classic HTLC. The fairness guarantee in Θ\Theta rests on

n≥t+ℓ,t>ℓ,n \ge t+\ell,\qquad t>\ell,

where ℓ\ell is the maximum number of Byzantine miners. The stated consequence is twofold: no ℓ\ell-colluding adversaries can reconstruct kk, and at least tt honest nodes can always supply shares for correct recovery.

A402 replaces zk-SNARK/VSS fair exchange with an atomic exchange protocol based on TEE-assisted adaptor signatures. After U\mathcal{U} locks δ\delta by moving balance from bfreecb^c_{free} to blockedcb^c_{locked} and setting σ←LOCKED\sigma\leftarrow LOCKED, SS executes the request inside a TEE, samples t∈Zqt\in\mathbb{Z}_q, sets T=t⋅GT=t\cdot G, encrypts the result as EncRes=Enct(res)EncRes=Enc_t(res), computes h=H(res)h=H(res) and m=H(cid∥rid∥δ∥h)m=H(cid\|rid\|\delta\|h), and generates the adaptor pre-signature σ^S←pSign(skS,m,T)\hat{\sigma}_S\leftarrow pSign(sk_S,m,T). The manager verifies pVerify(pkS,m,T,σ^S)=1pVerify(pk_S,m,T,\hat{\sigma}_S)=1, issues the conditional payment signature σU←SignU(m,δ)\sigma_U\leftarrow Sign_U(m,\delta), and moves the state to PENDINGPENDING. The provider then either reveals tt off-chain or performs on-chain fallback by computing σS←Adapt(σ^S,t)\sigma_S\leftarrow Adapt(\hat{\sigma}_S,t) and calling S.forceCloseASC(cid,σS)S.\texttt{forceCloseASC}(cid,\sigma_S). On secret reveal, U\mathcal{U} decrypts res=Dect(EncRes)res=Dec_t(EncRes), adjusts balances, returns the channel to OPENOPEN, and delivers the result to CC.

A402 states the end-to-end property as exec-pay-deliver atomicity. Its formal definition is

Pr[(S obtains δ∧U does not obtain res) ∨ (U obtains res∧S does not obtain δ)]≤negl(λ).Pr[(S\ \text{obtains}\ \delta \land \mathcal{U}\ \text{does not obtain}\ res)\ \lor\ (\mathcal{U}\ \text{obtains}\ res \land S\ \text{does not obtain}\ \delta)] \le negl(\lambda).

The accompanying argument is that the TEE enforces execution before pSignpSign, while the adaptor signature ensures that payment finalization reveals tt, which is the decryption key for the result (Guo et al., 2022, Li et al., 1 Mar 2026).

4. Closure, settlement, and liquidity aggregation

Cross-Channel closes by running the same close routine simultaneously in ξα\xi^\alpha and ξβ\xi^\beta. After CloseRequest messages from all parties, the smart contract ξ\xi sets the state to COLLECTINGCOLLECTING, starts a timer TcloseT_{close}, and broadcasts a CloseEvent. While TcloseT_{close} has not expired, each party uploads fif_i, its computed final balance vector at its channel level, together with the set {Sri}\{Sr_i\} of sub-channel receipts it opened. On expiry, ξ\xi verifies each channel layer by layer from level $0$ to level LL. If ∑fi≠deposit(Ω)\sum f_i\neq deposit(\Omega) or signatures are invalid, then Ω\Omega and all its descendants are marked FAILEDFAILED; otherwise the contract sets on-chain balances per fif_i. Any failure at layer kk invalidates that layer and all higher layers. Every successful layer deposits its final state; failed ones revert to parent balances.

A402 separates cooperative closure, unilateral client closure, unilateral provider closure, and vault settlement. In the cooperative path, CC or SS requests closure, U\mathcal{U} runs closeASC(Γ)\texttt{closeASC}(\Gamma), L\mathcal{L} executes txclosetx_{close}, and the state becomes CLOSEDCLOSED. In unilateral client closure, C.forceCloseASC(cid,Γ)C.\texttt{forceCloseASC}(cid,\Gamma) starts an on-chain procedure with dispute window Δ\Delta; if no challenge is raised, CC finalizes closure and the state becomes CLOSEDCLOSED. In unilateral provider closure, S.forceCloseASC(cid,σS)S.\texttt{forceCloseASC}(cid,\sigma_S) acts differently depending on channel state: if σ=OPEN\sigma=OPEN, the result is cooperative-style close; if σ=PENDING\sigma=PENDING, the on-chain close with adaptor signature reveals tt on-chain, allowing U\mathcal{U} to extract it and decrypt the result before final closure.

The TEE-based Liquidity Vault extends A402 from per-channel settlement to private balance aggregation. Each participant pp has off-chain vault state Vp=(vpfree,vplocked)\mathcal{V}_p=(v_p^{free},v_p^{locked}). After pp submits txinittx_{init} to L\mathcal{L}, the vault committee records the deposit by increasing vpfreev_p^{free}. Opening a private ASC from vault balances requires no on-chain transaction: the vault debits vCfreev_C^{free}, generates cidcid, and creates Γ=(C,S,⟨v,0,0⟩,OPEN,k=0)\Gamma=(C,S,\langle v,0,0\rangle,OPEN,k=0) off-chain. Closure credits balances back when Γ.σ=OPEN\Gamma.\sigma=OPEN. Settlement later aggregates the free balance into a single on-chain transaction

txsettle=U.buildSettleTX(p,vpfree),tx_{settle}=\mathcal{U}.buildSettleTX(p,v_p^{free}),

after which vpfree←0v_p^{free}\leftarrow 0. The exposed on-chain quantity is only the aggregate

total_vout=∑i∈settlementsΔi,total\_vout=\sum_{i\in settlements}\Delta_i,

in one txsettletx_{settle} (Guo et al., 2022, Li et al., 1 Mar 2026).

5. Security model, dispute handling, and interpretive issues

Cross-Channel assumes that S\mathcal{S} and R\mathcal{R} may be arbitrarily malicious and that miners run a BFT chain tolerating ℓ<N−13\ell<\tfrac{N-1}{3} Byzantine nodes. The fairness of Θ\Theta is attributed to zk-SNARK soundness and zero-knowledge together with the (t,n)(t,n)-VSS thresholds, so that there is no information leak and proofs are unforgeable. Invalid share appeals are stated to abort safely even under asynchronous delays. Atomicity of cross-chain settlement is guaranteed by the HTLC timers T3>T4T_3>T_4. To mitigate asynchrony, an extra timer T5T_5 allows any honest miner who learns pre\mathsf{pre} after timeout to complete the settlement and claim a small on-chain reward. Latency avoidance is achieved because payments, data swaps, and sub-channel openings occur off-chain, while on-chain interaction is limited to channel open and close, key-share appeals, and final HTLC locks and updates.

A402 frames its guarantees as trust-minimized asset security, exec-pay-deliver atomicity, and unlinkability in vault mode. Regardless of U\mathcal{U} or SS availability or honesty, CC and SS can unilaterally force on-chain settlement via forceCloseASC\texttt{forceCloseASC} or forceSettleVault\texttt{forceSettleVault}, and assets are never locked indefinitely because of the challenge windows. Its primitive set explicitly includes adaptor signatures ΠAS\Pi_{AS}, collision-resistant hash HH, symmetric encryption Enct/DectEnc_t/Dec_t, and TEE remote attestation VerifyAttVerifyAtt. In vault mode, on-chain observers see vault initialization and settlement, but not individual ASC creation and closure, so the observer cannot link δi\delta_i or the client-service graph for individual ASCs.

A recurring misunderstanding addressed directly by the literature is the identification of ASCs with ordinary payment channels. A402 rejects that equivalence by defining the absence of service execution and result delivery as the central limitation of ΠPC\Pi_{PC}. Cross-Channel broadens the exchange object beyond coins to encrypted data and digital commodities, while preserving on-chain recourse. This suggests that the defining feature of an ASC is not simply off-chain balance movement, but an enforceable coupling between service execution, counter-performance, and final settlement (Guo et al., 2022, Li et al., 1 Mar 2026).

6. Empirical evaluation and practical significance

Cross-Channel was deployed on two 100-node Ethereum testnets (PoW) across 50 AliCloud VMs, simulating up to 1 0001\,000 transactions per chain. Reported gas consumption at Gwei price =1=1 is approximately $70$ k gas for Open, approximately $345$ k gas for Upload (key shares), approximately $150$ k gas for Close (hierarchical settlement), $79$–$146$ k gas for Lock/Update, and approximately $109$ k gas for Update-EIE (with key recovery). For NN cross-chain exchanges, the paper reports that Cross-Channel uses approximately $1.33$ M gas total, while a naïve HTLC uses $0.43$ M ×N\times N and MAD-HTLC uses $0.76$ M ×N\times N. Transaction confirmation latency for open, lock, update, and close remains $3$–$7$ s even at $100$ nodes. Throughput scales linearly in NN channels: with $500$ channels, approximately $100$ nodes ×5\times 5 per channel, the system sustained 3×1063\times 10^6 receipts/s in pure coin exchange and 3×1053\times 10^5 Tr/s in encrypted-info exchange. Off-chain cryptographic overhead is also quantified: zk-SNARK proving time is sub-second even for 10 00010\,000-block messages, proof size is approximately $1$ kB, verification is approximately ms, and VSS.Share, Verify, and Recover are all msec-level at (t,n)(t,n) up to (51,151)(51,151).

A402 reports both Ethereum and Bitcoin integrations and evaluates them against x402. On Ethereum, the ASC Manager contract exposes createASC, closeASC, initForceClose, finalForceClose, forceClose, initVault, settleVault, initForceSettle, and finalForceSettle. Standard ASC mode costs 26 05026\,050 gas for createASC and 57 63757\,637 gas for closeASC, for a total of 83 68783\,687 gas (%\%%%%0%%%%2.05). The x402 baseline is 22 580+23 530×n22\,580+23\,530\times n gas, stated as %\%%%%1%%%%0.94\times n per request. On Bitcoin, using Taproot (P2TR) with MAST, createASC costs $153$ vB (%\%%%%2%%%%0.775), and total channel cost is $308$ vB (%\%%%%3%%%%1.04) and C.forceCloseC.\texttt{forceClose} costs $192$ vB (%\%%%%4%%%%1.455) per request, which the paper characterizes as linear O(n)O(n).

For off-chain performance, A402 reports a peak throughput of 2 8752\,875 RPS at 5 0005\,000 concurrent requests and average latency rising from $340$ ms to $370$ ms as load scales from $100$ to 10 00010\,000. It compares this with on-chain baselines of approximately $30$ TPS for Ethereum and approximately $7$ TPS for Bitcoin, yielding approximately 95×95\times and approximately 410×410\times higher throughput respectively, and contrasts sub-second ASC latency with seconds-to-minutes on mainnets, including approximately $13$ s for Solana, approximately $13$ min for Ethereum, and approximately $60$ min for Bitcoin. At n=100n=100 requests on Ethereum, the reported costs are 83 68783\,687 gas =%=\%%%%5%%%%2.05 for vault A402, and 2 375 5802\,375\,580 gas =%=\%%%%6%%%%1.54 for A402 versus $291$ vB $\times 100=$145.50forx402,fora for x402, for a 94\times$ reduction. Appendix results further state that adding more vault replicas scales capacity linearly while per-request latency remains stable because it is dominated by service execution and network delay.

Taken together, the empirical record distinguishes two operating regimes. Cross-Channel emphasizes high-frequency and large-scale cross-chain services with amortized on-chain cost across many off-chain operations, while A402 emphasizes real-time micropayments for Web 3.0/Web 2.0 service composition with private settlement aggregation. A plausible implication is that the ASC label now covers at least two protocol lineages: one centered on cross-chain fair exchange with hierarchical settlement, and one centered on service-integrated payment channels with TEE-assisted execution and vault-based balance privacy (Guo et al., 2022, Li et al., 1 Mar 2026).

Topic to Video (Beta)

No one has generated a video about this topic yet.

Whiteboard

No one has generated a whiteboard explanation for this topic yet.

Follow Topic

Get notified by email when new papers are published related to Atomic Service Channels (ASCs).