Get Solana refund

GET /v1/onchain/{orderId}/refund The refund of an order opened on a Solana escrow, built by the hub as a serialized, unsigned transaction for the order’s own user, who is its fee payer and its only signer. The user’s wallet signs it and sends it.

Item	Value
Route key	`infinityOnchainRefund`
Credential	API key or project id

Not scoped to your organization. An EVM refund needs no such route: refund(order) is one call, built from Get escrow order. A Solana refund names ten accounts plus three per input, in an order the program defines, so the hub builds it and the client only signs.

Request

Path parameters

Param	Rules	Meaning
`orderId`	`0x` + 64 lowercase hex	the on-chain order id: `onchainOrderId` in `GET /orders`

Query parameters

Param	Rules	Meaning
`unwrap`	`true` or `false`, default `false`; any other value is `EIN0001` (reference `unwrap`)	also close the user’s wrapped-SOL account, so the refund arrives as SOL. Ignored for an order with no wrapped-SOL input

Response

data (OnchainRefund):

Field	Type	Meaning
`onchainOrderId`	string	the id
`chainDomain`	string	the origin escrow’s chain, e.g. `solana-localnet`
`program`	string	the escrow program the refund calls (base58). Check it is one of the chain’s `inputSettlers` in `GET /catalog`
`transaction`	string	the serialized transaction, in `encoding`: one empty signature slot, then the legacy message. The wallet signs it as it is
`encoding`	string	`base64`
`feePayer`	string	the order’s user (base58): it pays the fee and is the only signer. The signing wallet must be this account
`signers`	string[]	the accounts that must sign: `[feePayer]`
`recentBlockhash`	string	the blockhash the transaction is valid under (base58)
`lastValidBlockHeight`	integer	past this block height the cluster refuses the transaction: ask again
`refundableAfter`	integer	unix seconds: the deadline the refund had to be past, the later of the order’s expiry and any extension
`unwrap`	boolean	`true` when the transaction also closes the user’s wrapped-SOL account
`computeUnits`	integer	what the hub’s simulation of the transaction consumed
`inputs[]`	object[]	what the refund pays back, in the order’s input order: `token` (the mint, base58), `amount` (base units, decimal string) and `tokenAccount` (the user’s token account it is paid to, base58; the refund creates it when missing)

Behavior

Built from the chain when you ask. The hub reads the escrow’s order record, the cluster’s clock and each input’s mint at request time, and simulates the transaction before serving it, so it never hands out one the program would refuse.
Short-lived. The transaction carries a recent blockhash and lives about a minute: send it before lastValidBlockHeight, or ask again. Fetch it right before the user signs.
The cluster’s clock decides. The refund needs the cluster’s clock strictly past refundableAfter. Before that, the route answers EIN0007 NOT_YET_REFUNDABLE with both values, so you can show when the refund opens.
unwrap=true closes the whole wrapped-SOL account, so wrapped SOL the user already held there becomes SOL too.
Anyone may fetch it. A refund is permissionless on chain and pays only the order’s user, so the transaction needs availability, not confidentiality: the same reasoning as Get escrow order.
Check before signing: feePayer is the user’s connected wallet; program is a declared escrow; and the transaction holds only the escrow’s refund for this order, plus, with unwrap, one SPL Token CloseAccount that pays the user. The TypeScript SDK runs these checks (SDK — Refunds).

Errors

Code	When
`EIN0007`	the hub will not build this refund: `error_reference` is the reason (below) and `error_params` its values
`EIN0009`	an id the hub has not observed, or one the escrow holds no record of (a just-opened order: poll again)
`EIN0001`	`unwrap` is not `true` or `false` (reference `unwrap`)
`EIN0050`	the Solana node was unavailable: retry

The EIN0007 reasons:

`error_reference`	`error_params`	Meaning, and what to do
`NOT_YET_REFUNDABLE`	`[refundableAfter, clusterNow]`, unix seconds	the deadline has not passed on the cluster’s clock: show “refundable from …” and try again after it
`ALREADY_REFUNDED`	—	the order was refunded already: nothing to do
`ALREADY_CLAIMED`	—	the order was filled and claimed: the recipient was paid
`NOT_OPEN`	—	the escrow holds no open order under this id: nothing to refund
`FEE_PAYER_UNFUNDED`	`[feePayer]`	the user needs a little SOL, for the fee or the rent of a token account the refund recreates
`ORIGIN_NOT_SUPPORTED`	`[family]`	not a Solana-origin order: refund an EVM order from Get escrow order
`CHAIN_NOT_WIRED`	`[chainDomain]`	this hub cannot refund on that chain: report it
`SIMULATION_FAILED`	`[the node's error, as JSON]`	the program would refuse the refund: report the order id
`UNBUILDABLE`, `UNREADABLE`	`[detail]`	hub side (`UNREADABLE`: what the chain holds for the order cannot be trusted): report the order id

The gateway’s own refusals — a refused credential, a route not open to it, a rate limit, the hub unreachable or too slow — can come back from every route, with an EPX code and a real HTTP status (Errors — gateway codes); EIN0049 (internal, scrubbed) can come back from any route.

Example

curl -sS -G https://proxy-api.infinimesh.net/v1/onchain/0x5a8d3c61f0b24e97a1c6d8e2b4f7093a6c1e5d9b2f8a4c7e0d3b6a9f1c2e5d80/refund \
  --data-urlencode 'unwrap=true' \
  -H "x-api-key: $HUB_API_KEY"

Response

Illustrative values; formats follow the Response table. The program, the transaction, the blockhash and the token account are elided: real ones are not derivable from the documented sources.

{
  "success": true,
  "request_id": "c4d5e6f7-a8b9-4c0d-9e1f-2a3b4c5d6e7f",
  "data": {
    "onchainOrderId": "0x5a8d3c61f0b24e97a1c6d8e2b4f7093a6c1e5d9b2f8a4c7e0d3b6a9f1c2e5d80",
    "chainDomain": "solana-localnet",
    "program": "…",
    "transaction": "AQAAAA…",
    "encoding": "base64",
    "feePayer": "CCckTaUo6jc8Q6HydkjKjvGX3MHJS77uwis2DN7UFoqZ",
    "signers": ["CCckTaUo6jc8Q6HydkjKjvGX3MHJS77uwis2DN7UFoqZ"],
    "recentBlockhash": "…",
    "lastValidBlockHeight": 1204517,
    "refundableAfter": 1790000000,
    "unwrap": true,
    "computeUnits": 41250,
    "inputs": [
      {
        "token": "So11111111111111111111111111111111111111112",
        "amount": "250000000",
        "tokenAccount": "…"
      }
    ]
  }
}

// client: your InteropClient (see /infinity-interop/sdk/installation)
const refund = await client.api.getOnchainRefund(onchainOrderId, { unwrap: true });

// or fetch it, check it, and have the user's wallet sign and send it, in one call:
await client.refundSolanaOrder({ onchainOrderId, wallet: solana, unwrap: true });

Get started

Core concepts

Resources

API reference

SDK

SDK reference

Request

Path parameters

Query parameters

Response

Behavior

Errors

Example

Response

See also

​Request

​Path parameters

​Query parameters

​Response

​Behavior

​Errors

​Example

​Response

​See also

Request

Path parameters

Query parameters

Response

Behavior

Errors

Example

Response

See also