TeleSwap teams can assign signing and operations work before taking live requests once they decide whether users or a service control the spending keys. A user-signed application needs compatible wallets and readable transaction review; a service-signed application also needs a protected signer and explicit authorization rules. The direction, network, and custody arrangement determine who approves each spend.
Separate Transaction Construction From Spending Authority
An application can construct a transaction without having permission to spend the funds in it. Construction selects inputs or contract calls, recipients, amounts, fees, and network details. Signing authorizes a particular transaction with a spending key. The team should record which component constructs the request, which party checks it, which key signs it, and who submits it.
That division gives the two arrangements different owners:
- Wallet-connected application: The user controls the spending key and authorizes each transaction in a compatible wallet. The application prepares the request, presents its meaning, and tracks the result.
- Backend with a separate service signer: The service controls a key that can spend the funds assigned to its flow. The backend must decide which requests may reach that signer, while the signer enforces access and spending controls.
Before choosing, identify whose funds each source transaction spends. If a service key spends only application funds, the team must define how user funds enter that flow. If it spends funds held for users, the team takes on responsibility for protecting those keys and authorizing withdrawals. An unsigned transaction from an API does not settle that ownership question.
Prepare the User-Signed Application
User signing works when the application can connect to wallets that support the required source network and transaction format. Frontend developers should establish wallet compatibility for each supported direction, including Bitcoin signing for a Bitcoin spend and the appropriate chain selection for an EVM transaction. A successful connection alone does not show that a wallet can sign the constructed request.
The review screen should show the asset leaving the wallet, the source network, the destination network, the receiving address, and the amount the user is expected to receive or have credited. Present network fees and any TeleSwap fees where they can be determined, and identify an estimate as an estimate. The wallet may display raw transaction details, so the application’s explanation must agree with the transaction the user is asked to sign.
For example, consider an illustrative Bitcoin-to-Ethereum request. If construction selects Bitcoin UTXOs, the wallet must sign the spend from those selected outputs; the frontend must show that the intended recipient is on Ethereum. The team should also decide what happens if the user changes wallets, rejects signing, or signs after the quoted terms expire. Those outcomes require a fresh review or a deliberate cancellation state, not an assumed payment.
Map TeleSwap Transfer State
A source transaction being signed, submitted, or confirmed is different from the destination outcome being complete. That distinction matters when the application promises a cross-chain result: a Bitcoin transaction ID confirms neither that the destination action has happened nor that the request needs to be paid again.
In TeleSwap cross-chain transfers, Bitcoin transaction verification supplies evidence of the source payment, while collateralized Lockers form part of the operator arrangement for moving value across networks. A TeleSwap Bitcoin bridge integration therefore needs to associate the source transaction with the expected destination result. The application should show separate states for awaiting signature, submitted on the source network, source payment verified, and destination completion, using the states the integration can actually observe.
For the illustrative Bitcoin-to-Ethereum request, persist one application request identifier alongside the selected Bitcoin inputs or submitted transaction ID, the Ethereum recipient, and the resulting destination transaction identifier when available. This record lets support distinguish a delayed handoff from a request that never received a signature. The same mapping must account for the reverse direction when the team enables it; the chain that supplies the spend and the chain that receives it change.
Prepare the Service Signer
Service signing needs a separately controlled signing system and a rule for approving each transaction before that system uses its key. Keep signing credentials outside the transaction-building service, restrict which service identities can request a signature, and log the approved request and the transaction it produced. A hardware security module or managed key service can protect keys, but the team still has to define what the signer is allowed to sign.
Authorization rules should bind a request to its asset, source network, destination, recipient, and maximum spend. Set limits that match the funds the service is meant to control, and require a deliberate process for changing those limits or adding destinations. If an API caller can replace a recipient after approval, the approval did not authorize the transaction that will be signed.
The signer also needs chain-specific state. For Bitcoin, coordinate UTXOs so two requests do not attempt to spend the same output, and reserve enough value for transaction fees. For an EVM network such as Ethereum or Arbitrum, coordinate account nonces so concurrent submissions do not collide, and fund the signing account with the native asset needed for gas. Assign these duties to the signer or a single transaction coordinator rather than leaving them to independent API workers.
Own Completion and Recovery in Both Arrangements
Both arrangements need a persistent request identifier, status monitoring, and a named support owner before accepting real requests. The application should retain enough detail to match its request to source and destination transactions, including failures or rejections. The support owner needs a documented way to inspect that record and determine whether the next action belongs to the user, the signer, or an operator.
A submission timeout is an uncertainty about the response, not proof that payment failed. If an API call times out after broadcasting, first reconcile the original transaction against the network and the stored request. Automatically constructing a new payment can spend funds twice; for a service signer, it can also consume a new nonce or different UTXOs while the first transaction is still pending.
User signing is the fitting choice when users should retain spending control and supported wallets can present the required transactions clearly. Service signing fits when the application is authorized to control the funds and can operate the signer, limits, and transaction state. Revisit that choice if a new transfer direction, network, or custody arrangement changes who holds the spending key: it changes the authorization and operational duties the TeleSwap integration must assign.
Top comments (0)