client

type Backend interface {
	// ProposerBuildRequest selects the taker's UTXOs and builds the proposer
	// SwapRequest. conf says which legs are confidential (so the proposer's output
	// is blinded or explicit, and its inputs reveal real or zero blinders).
	ProposerBuildRequest(req ProposalReq, conf LegConfidentiality) (*seqdexv1.SwapRequest, error)
	// ResponderComplete runs the maker CompleteSwap responder: add own UTXOs,
	// change, the any-asset fee vout, then BlindPset IFF blind (else finalize
	// explicit), then sign the maker's own inputs.
	ResponderComplete(req *seqdexv1.SwapRequest, blind bool) (*seqdexv1.SwapAccept, error)
	// ProposerFinalize signs the taker's inputs, validates, and broadcasts.
	ProposerFinalize(acc *seqdexv1.SwapAccept) (*seqdexv1.SwapComplete, string, error)
}

type Crypter struct {
	// contains filtered or unexported fields
}

type LegConfidentiality struct {
	TakerInputsConfidential bool // taker funds with confidential UTXOs
	TakerRecvConfidential   bool // taker receives into a confidential address
	MakerInputsConfidential bool // maker funds with confidential UTXOs
	MakerRecvConfidential   bool // maker receives into a confidential address
}

type LiveSubMakerOps struct{ Sub *xchain.SubmarineSwap }

type LiveSubReverseMakerOps struct{ Sub *xchain.SubmarineSwap }

type LiveSubReverseTakerOps struct{ Sub *xchain.SubmarineSwap }

type LiveSubTakerOps struct {
	Sub *xchain.SubmarineSwap
	SEQ *xchain.Chain
}

type LiveWallet struct {
	Backend Backend

	TakerInputsConfidential  bool
	TakerRecvConfidential    bool
	MakerOutputsConfidential bool
}

type LiveXcOps struct {
	Swap *xchain.Swap
	BTC  *xchain.BitcoinChain
	SEQ  *xchain.Chain
}

type Maker struct {
	Wallet Wallet
	// Offer is the maker's OWN signed resting offer. When set, HandleRequest binds
	// every co-sign to it (asset legs, price floor, remaining size) so a malicious
	// taker cannot drain the maker at an arbitrary price. Left nil only in unit
	// tests that exercise the raw message flow.
	Offer *seqobv1.Offer
}

type MakerForwardParams struct {
	// NewOps binds the settlement engine to the taker's hashlock once it arrives
	// (the maker never knows the secret; it builds from the hash).
	NewOps  func(hashH []byte) (XcOps, error)
	Crypter *Crypter

	// Tip queries usable BEFORE the hashlock exists (terms are minted first).
	BtcTip func() (int64, error)
	SeqTip func() (int64, error)

	AssetHex  string // SEQ asset we deliver (offer pair base)
	SeqAmount uint64 // atoms we lock
	BtcAmount uint64 // sats we require
	FeeBtc    uint64 // advisory fee surfaced in terms

	// Locktime deltas above the respective tips. T_btc must be LONGER IN TIME
	// than T_seq, and T_seq must leave the taker room for a REAL parent
	// confirmation before its claim: 100 parent blocks ~16 h vs 240 SEQ slots
	// ~2 h. (The RFQ's 50-slot delta was tuned for regtest; on a live parent a
	// taker with the default 120-slot minimum window rightly refuses it.)
	BtcLocktimeDelta uint32 // default 100
	SeqLocktimeDelta uint32 // default 240

	MinBTCConf   int    // confirmations required on the taker's BTC leg (default 1; testnet-grade — depth, not anchoring, protects the maker's BTC side)
	SpendFeeSats uint64 // fee target in native sats (default 1000)
	Timing       XcTiming
	Log          func(format string, args ...interface{})

	// OnUpdate is invoked after every state transition that creates or changes
	// recoverable value (keys minted, legs funded/verified, secret learned,
	// settled/refunded). The caller must persist the result snapshot there: the
	// per-lift keys exist nowhere else, and losing them mid-swap burns a leg.
	OnUpdate func(*MakerForwardResult)
}

type MakerForwardResult struct {
	HashH        []byte
	BtcClaimKey  *xchain.Key // claims the taker's BTC leg once the secret is known
	SeqRefundKey *xchain.Key // refunds our SEQ leg after T_seq
	BtcLocktime  uint32
	SeqLocktime  uint32
	BtcLeg       *xchain.LegLock // the taker's verified BTC leg
	SeqLeg       *xchain.LegLock
	SeqBlockHash string
	Secret       []byte
	BtcClaimTxid string
	SeqRefundTx  string
	Settled      bool
}

type MakerForwardResumeParams struct {
	Ops          XcOps
	BtcLeg       *xchain.LegLock // the taker's BTC leg (we claim it with the secret)
	SeqLeg       *xchain.LegLock // our asset leg (we watch it / refund it)
	BtcClaimKey  *xchain.Key
	SeqRefundKey *xchain.Key
	HashH        []byte
	BtcLocktime  uint32
	SeqLocktime  uint32
	AssetHex     string
	BtcAmount    uint64
	SeqAmount    uint64
	SpendFeeSats uint64
	Timing       XcTiming
	OnUpdate     func(*MakerForwardResult)
	Log          func(string, ...interface{})
}

type MakerReverseParams struct {
	// NewOps binds the settlement engine to the freshly minted SECRET (the
	// maker is the secret holder in reverse).
	NewOps  func(secret []byte) (XcOps, error)
	Crypter *Crypter

	// Tip queries usable BEFORE the engine exists.
	BtcTip func() (int64, error)
	SeqTip func() (int64, error)

	AssetHex  string // SEQ asset we buy (offer pair base)
	SeqAmount uint64 // atoms we require
	BtcAmount uint64 // sats we pay
	FeeBtc    uint64 // advisory fee surfaced in terms

	BtcLocktimeDelta uint32 // default 100 (our BTC refund if the taker vanishes; ~16h)
	SeqLocktimeDelta uint32 // default 240 (the taker's refund horizon; ~2h)

	MinBTCConf     int    // confirmations we need on our OWN BTC leg before the anchor gate (default 1)
	SeqClaimMargin uint32 // never reveal the secret closer than this to T_seq (default 10)
	SpendFeeSats   uint64
	Timing         XcTiming
	Log            func(format string, args ...interface{})

	// OnUpdate persists the evolving result; in reverse the SECRET is the
	// maker's crown jewel and is minted here, so the first call (before any
	// coins move) must already durably hold it and both keys.
	OnUpdate func(*MakerReverseResult)
}

type MakerReverseResult struct {
	Secret       []byte
	HashH        []byte
	SeqClaimKey  *xchain.Key // claims the taker's asset leg (reveals the secret)
	BtcRefundKey *xchain.Key // refunds our BTC leg after T_btc
	BtcLocktime  uint32
	SeqLocktime  uint32
	BtcLeg       *xchain.LegLock // our funded BTC leg
	BtcLegHeight int64
	SeqLeg       *xchain.LegLock // the taker's verified asset leg
	SeqBlockHash string
	SeqClaimTxid string
	BtcRefundTx  string
	Settled      bool
}

type MakerReverseResumeParams struct {
	Ops            XcOps
	BtcLeg         *xchain.LegLock // ours; refunded after T_btc if we cannot settle
	SeqLeg         *xchain.LegLock // the taker's asset leg (nil if never funded/verified)
	SeqBlockHash   string          // the taker leg's confirming block (for the anchor gate)
	Secret         []byte
	HashH          []byte
	SeqClaimKey    *xchain.Key // claims the taker's asset leg (reveals the secret)
	BtcRefundKey   *xchain.Key // refunds our BTC leg after T_btc
	BtcLocktime    uint32
	SeqLocktime    uint32
	AssetHex       string
	BtcAmount      uint64
	SeqAmount      uint64
	SeqClaimMargin uint32
	MinBTCConf     int
	SpendFeeSats   uint64
	Timing         XcTiming
	OnUpdate       func(*MakerReverseResult)
	Log            func(string, ...interface{})
}

type MakerReverseSubmarineParams struct {
	// NewMakerOps binds the settlement engine to the maker-generated secret (the
	// maker builds the SubmarineSwap with NewHashLock(secret)).
	NewMakerOps func(secret []byte) SubReverseMakerOps
	Crypter     *Crypter
	SeqTip      func() (int64, error)

	AssetHex    string // SEQ asset the maker sells
	SeqAmount   uint64 // atoms the offer sells
	InvoiceMsat uint64 // BTC-LN the offer wants

	SeqLocktimeDelta uint32 // T_seq above the current SEQ tip (default 240)
	InvoiceCLTV      uint32 // min_final_cltv on the maker's invoice
	Timing           XcTiming
	Log              func(format string, args ...interface{})
}

type MakerReverseSubmarineResult struct {
	HashH        []byte
	SeqRefundKey *xchain.Key // refunds the asset after T_seq if the taker never pays
	SeqLeg       *xchain.LegLock
	SeqLocktime  uint32
	Bolt11       string
	Label        string
	PaidMsat     uint64
	Settled      bool
}

type MakerSubmarineParams struct {
	// NewMakerOps binds the settlement engine once H arrives (the maker knows only
	// H, so it builds the SubmarineSwap with NewHashLockFromHash(H)).
	NewMakerOps func(hashH []byte) SubMakerOps
	Crypter     *Crypter
	SeqTip      func() (int64, error)

	AssetHex    string // SEQ asset the offer sells
	SeqAmount   uint64 // atoms the offer sells (whole-HTLC lift)
	InvoiceMsat uint64 // BTC-LN the offer wants (cross-checks the taker's bolt11)

	SeqLocktimeDelta uint32 // T_seq above the current SEQ tip (default 240)
	MinAnchorDepth   int64  // the funding anchor-depth gate before paying (default 3, >=2)
	SpendFeeAtoms    uint64 // fee for the maker's asset-claim spend (default 1000)
	AnchorTimeout    time.Duration
	Timing           XcTiming
	Log              func(format string, args ...interface{})
}

type MakerSubmarineResult struct {
	HashH        []byte
	SeqClaimKey  *xchain.Key
	SeqLocktime  uint32
	Preimage     []byte
	SeqClaimTxid string
	Settled      bool
}

type ProposalReq struct {
	Offer         *seqobv1.Offer
	TakeBase      uint64
	TakerFeeAsset string
	PayAsset      string
	PayAmount     uint64
	RecvAsset     string
	RecvAmount    uint64
}

type RealBackend struct {

	// FetchUtxos returns the taker's spendable UTXOs (unblinded with blindKeys).
	FetchUtxos func(addr string, blindKeys [][]byte) ([]explorer.Utxo, error)
	// BroadcastFn publishes a raw tx hex and returns its txid.
	BroadcastFn func(txHex string) (string, error)
	// CompleteSwapFn runs the maker responder and MUST honor blind (skip BlindPset
	// for an explicit swap). Wired to wallet.Service.CompleteSwap building blocks.
	CompleteSwapFn func(req *seqdexv1.SwapRequest, blind bool) (signedPSET string, combined []swap.UnblindedInput, err error)
	// contains filtered or unexported fields
}

type StubWallet struct {
	// Name disambiguates the placeholder PSET/txid (e.g. "maker" / "taker").
	Name string
}

type SubMakerOps interface {
	// RunNormal verifies the taker's funded asset HTLC, waits for it to be
	// anchor-buried, pays the BOLT11 (learning P), and claims the asset with P.
	RunNormal(p xchain.NormalParams, makerClaimKey *xchain.Key, seqClaimFee uint64) (*xchain.NormalResult, error)
}

type SubReverseMakerOps interface {
	OfferReverseMakerSecret(p xchain.ReverseMakerSecretParams) (*xchain.ReverseMakerSecretOffer, error)
	AwaitReversePayment(label string, timeout time.Duration) (uint64, error)
	RefundReverseSEQ(leg *xchain.LegLock, key *xchain.Key, nLockTime uint32, fee uint64) (string, error)
}

type SubReverseTakerOps interface {
	VerifySEQLeg(hashH, claimPub, refundPub, providedScript []byte, seqLocktime uint32,
		txid string, vout uint32, amount uint64, assetID string, minConf int) (*xchain.VerifiedSEQLeg, error)
	VerifySeqAnchorBuried(seqBlockHash string, minAnchorDepth int64) (*xchain.SubAnchorEvidence, error)
	PayInvoice(bolt11 string, wantHash []byte, amountMsat uint64) ([]byte, error)
	InjectSecret(secret []byte) error
	ClaimSEQLeg(leg *xchain.LegLock, key *xchain.Key, fee uint64) (string, error)
}

type SubTakerOps interface {
	SeqTip() (int64, error)
	// LockSEQLeg funds the asset HTLC (claim=maker, refund=taker) from the taker's
	// wallet, returning the leg and the confirming Sequentia block hash.
	LockSEQLeg(claimPub, refundPub []byte, amountCoins, assetLabel string, locktime uint32) (*xchain.LegLock, string, error)
	// MintInvoice mints a plain BOLT11 on the taker's node bound to preimage P.
	MintInvoice(preimage []byte, amountMsat uint64, cltv uint32, label, desc string) (string, error)
	// AwaitInvoicePaid blocks until that invoice is paid (the taker's BTC-LN).
	AwaitInvoicePaid(label string, timeout time.Duration) (uint64, error)
	// RefundSEQLeg reclaims the asset HTLC via its CLTV branch after T_seq.
	RefundSEQLeg(leg *xchain.LegLock, key *xchain.Key, nLockTime uint32, fee uint64) (string, error)
	// SeqBlockAnchorHeightOf reports a Sequentia block's Bitcoin-anchor height
	// (conveyed to the maker for transparency; the maker re-reads it).
	SeqBlockAnchorHeightOf(blockHash string) (int64, error)
}

type Taker struct {
	Wallet Wallet
}

type TakerForwardParams struct {
	Ops     XcOps
	Crypter *Crypter

	Secret       []byte      // 32-byte preimage; Ops' hashlock must be built from it
	BtcRefundKey *xchain.Key // refunds our BTC leg after T_btc
	SeqClaimKey  *xchain.Key // claims the SEQ leg (the claim reveals Secret on-chain)

	ExpectAsset     string // SEQ asset hex the offer sells (required)
	ExpectSeqAmount uint64 // atoms the offer promises (required; whole-HTLC lift)
	ExpectBtcAmount uint64 // sats the offer wants (required)
	MaxFeeBtc       uint64 // refuse terms whose fee_btc exceeds this

	// Locktime sanity. T_btc bounds how long our BTC can be locked before the
	// refund path opens; T_seq must leave us a real window to claim after the
	// anchor gate, and we must never reveal the secret when the maker's refund
	// path is about to open (it could race our claim with its refund). The
	// window must cover a REAL parent confirmation (median ~10 min, long tail)
	// plus the maker's SEQ lock (~3 min worst) plus the anchor gate, in ~30 s
	// SEQ slots — hence the 120-slot (~1 h) default; a maker quoting less is
	// refused BEFORE any BTC moves.
	MaxBtcLockDelta   uint32 // default 400 parent blocks
	MinSeqClaimWindow uint32 // default 120 SEQ blocks at terms time
	SeqClaimMargin    uint32 // default 10 SEQ blocks: refuse to claim closer than this to T_seq

	MinBTCConf   int    // confirmations before announcing our BTC leg (default 1)
	SpendFeeSats uint64 // fee target in native sats (default 1000)
	Timing       XcTiming
	Log          func(format string, args ...interface{})

	// OnBtcLegFunded is invoked the moment the BTC leg is funded, BEFORE the
	// confirmation wait: the caller must persist the result's leg, locktime,
	// and its own keys/secret there, so a crash during the (potentially long)
	// wait never strands coins behind an unknowable redeem script.
	OnBtcLegFunded func(*TakerForwardResult)
}

type TakerForwardResult struct {
	Terms        *XcMsg
	BtcLeg       *xchain.LegLock
	BtcLegHeight int64
	BtcLocktime  uint32
	SeqLeg       *xchain.LegLock
	SeqClaimTxid string
	Evidence     *xchain.AnchorEvidence
}

type TakerReverseParams struct {
	// NewOps binds the settlement engine to the hashlock H once the maker's
	// terms arrive. The taker does not know the secret, but its SEQ leg script
	// and its BTC claim both embed H, so the swap must be built from the H in
	// the terms (mirrors the forward maker's NewOps(hashH)).
	NewOps  func(hashH []byte) (XcOps, error)
	Crypter *Crypter

	BtcClaimKey  *xchain.Key // claims the maker's BTC leg once the secret is revealed
	SeqRefundKey *xchain.Key // refunds our SEQ leg after T_seq if the maker never claims

	ExpectAsset     string // SEQ asset hex we sell (required)
	ExpectSeqAmount uint64 // atoms we deliver (required; whole-HTLC lift)
	ExpectBtcAmount uint64 // sats the offer pays (required)
	MaxFeeBtc       uint64 // refuse terms whose fee_btc exceeds this

	// Locktime sanity. T_btc is when the MAKER can take its BTC back, so it
	// must leave us real runway to claim after the secret appears; T_seq is
	// when WE can refund our asset leg, so it must fit the funding +
	// confirmation + the maker's gate-and-claim.
	MinBtcClaimDelta uint32 // T_btc >= btcTip + this (default 30 parent blocks)
	MinSeqFundWindow uint32 // T_seq >= seqTip + this (default 120 SEQ blocks)
	BtcClaimMargin   uint32 // refuse to claim closer than this to T_btc (default 6)

	MinBTCConf   int    // confirmations required on the MAKER's BTC leg before we fund (default 1)
	SpendFeeSats uint64 // fee target in native sats (default 1000)
	Timing       XcTiming
	Log          func(format string, args ...interface{})

	// OnSeqLegFunded is invoked the moment our SEQ leg is funded, BEFORE any
	// further wait: the caller must persist the result there so a crash never
	// strands the asset behind an unknowable redeem script.
	OnSeqLegFunded func(*TakerReverseResult)
}

type TakerReverseResult struct {
	Terms        *XcMsg // the maker's XcBtcLegLocked (terms ride in it)
	BtcLeg       *xchain.LegLock
	BtcLocktime  uint32
	SeqLeg       *xchain.LegLock
	SeqBlockHash string
	SeqLocktime  uint32
	Secret       []byte
	BtcClaimTxid string
	SeqRefundTx  string
}

type TakerReverseSubmarineParams struct {
	// NewTakerOps binds the engine once H arrives (taker builds the SubmarineSwap
	// with NewHashLockFromHash(H); it learns P only by paying).
	NewTakerOps func(hashH []byte) SubReverseTakerOps
	Crypter     *Crypter

	SeqClaimKey *xchain.Key // claims the asset with the learned P

	ExpectAsset       string // SEQ asset hex the offer sells (required)
	ExpectSeqAmount   uint64 // atoms the offer promises (required)
	ExpectInvoiceMsat uint64 // BTC-LN we expect to pay (required)

	MinAnchorDepth int64  // anchor-depth gate we require before paying (>=2, default 3)
	SpendFeeAtoms  uint64 // asset-claim fee (default 1000)
	Timing         XcTiming
	Log            func(format string, args ...interface{})

	// OnPaid is invoked the instant the invoice is paid and P is learned, BEFORE
	// the asset claim, so the caller persists P + the leg: a crash between paying
	// (irreversible) and claiming must not lose P (the only key to the asset).
	OnPaid func(preimage []byte, leg *xchain.LegLock)
}

type TakerReverseSubmarineResult struct {
	Terms        *XcMsg
	SeqLeg       *xchain.LegLock
	Anchor       *xchain.SubAnchorEvidence
	Preimage     []byte
	SeqClaimTxid string
	Settled      bool
}

type TakerSubmarineParams struct {
	Ops     SubTakerOps
	Crypter *Crypter

	Secret       []byte      // 32-byte preimage P (taker chooses; the invoice is minted on it)
	SeqRefundKey *xchain.Key // refunds the asset HTLC after T_seq

	ExpectAsset       string // SEQ asset hex the offer sells (required)
	ExpectSeqAmount   uint64 // atoms the offer promises (required)
	ExpectInvoiceMsat uint64 // BTC-LN we expect to receive (mint the invoice for this)

	MinSeqClaimWindow uint32 // refuse terms whose T_seq leaves less than this window (default 120)
	InvoiceCLTV       uint32 // min_final_cltv on the minted invoice (0 = node default)
	SpendFeeAtoms     uint64 // refund fee (default 1000)
	Timing            XcTiming
	Log               func(format string, args ...interface{})

	// OnAssetFunded is invoked the moment the asset HTLC is funded, so the caller
	// persists the leg + keys + secret before the (potentially long) settle wait.
	OnAssetFunded func(*TakerSubmarineResult)
}

type TakerSubmarineResult struct {
	Terms        *XcMsg
	SeqLeg       *xchain.LegLock
	SeqBlock     string
	SeqLocktime  uint32
	Bolt11       string
	InvoiceLabel string
	PaidMsat     uint64
	Settled      bool
}

type Wallet interface {
	// ProposerBuildRequest (taker side): build the proposer PSET that pays the
	// maker its want_asset and receives the offer_asset, for takeBase base atoms
	// (partial fills allowed). takerFeeAsset selects the open-market fee asset.
	ProposerBuildRequest(o *seqobv1.Offer, takeBase uint64, takerFeeAsset string) (*seqdexv1.SwapRequest, error)

	// ResponderComplete (maker side): run the existing CompleteSwap responder
	// path against the taker's SwapRequest -> SwapAccept.
	ResponderComplete(req *seqdexv1.SwapRequest) (*seqdexv1.SwapAccept, error)

	// ProposerFinalize (taker side): blind+sign own inputs, validate, broadcast ->
	// SwapComplete plus the broadcast txid.
	ProposerFinalize(acc *seqdexv1.SwapAccept) (*seqdexv1.SwapComplete, string, error)
}

type XcLeg struct {
	Txid         string `json:"txid"`
	Vout         uint32 `json:"vout"`
	Amount       uint64 `json:"amount"`
	Asset        string `json:"asset,omitempty"` // SEQ leg only (asset id hex)
	RedeemScript string `json:"redeem_script"`   // hex
	Locktime     uint32 `json:"locktime"`
	Height       int64  `json:"height,omitempty"`        // confirmed height (BTC leg, for anchor ordering)
	BlockHash    string `json:"block_hash,omitempty"`    // SEQ leg, for the anchor gate
	AnchorHeight int64  `json:"anchor_height,omitempty"` // SEQ leg's Bitcoin-anchor height
}

type XcMsg struct {
	Type XcMsgType `json:"type"`

	// Terms (maker -> taker, forward) / BtcLegLocked terms (reverse).
	MakerBtcClaimPub string `json:"maker_btc_claim_pub,omitempty"` // forward: maker claims BTC with s
	MakerSeqClaimPub string `json:"maker_seq_claim_pub,omitempty"` // reverse: maker claims SEQ with s
	MakerRefundPub   string `json:"maker_refund_pub,omitempty"`    // forward: maker's SEQ refund; reverse: maker's BTC refund
	BtcLocktime      uint32 `json:"btc_locktime,omitempty"`        // T_btc (the longer leg)
	SeqLocktime      uint32 `json:"seq_locktime,omitempty"`        // T_seq (the shorter leg)
	BtcAmount        uint64 `json:"btc_amount,omitempty"`          // sats
	SeqAmount        uint64 `json:"seq_amount,omitempty"`          // asset atoms
	FeeBtc           uint64 `json:"fee_btc,omitempty"`

	// Secret hash + taker pubkeys.
	HashH             string `json:"hash_h,omitempty"`               // sha256(secret), hex
	TakerSeqClaimPub  string `json:"taker_seq_claim_pub,omitempty"`  // forward: taker claims SEQ with s
	TakerBtcRefundPub string `json:"taker_btc_refund_pub,omitempty"` // forward: taker refunds BTC after T_btc
	TakerSeqRefundPub string `json:"taker_seq_refund_pub,omitempty"` // reverse: taker refunds SEQ after T_seq
	TakerBtcClaimPub  string `json:"taker_btc_claim_pub,omitempty"`  // reverse: taker claims BTC with s

	Leg *XcLeg `json:"leg,omitempty"` // the leg this message conveys

	// Submarine-swap (Lightning) fields. The BTC leg is a BOLT11 payment, not an
	// on-chain HTLC, so these carry it instead of an XcLeg. See xcourier_submarine.go.
	Bolt11         string `json:"bolt11,omitempty"`           // submarine: the invoice bound to H
	MinAnchorDepth uint32 `json:"min_anchor_depth,omitempty"` // submarine: the gate depth (transparency)
	SettleTxid     string `json:"settle_txid,omitempty"`      // submarine: the on-chain asset-claim txid (informational)

	Preimage string `json:"preimage,omitempty"` // XcSecretRevealed
	Code     string `json:"code,omitempty"`     // XcFail
	Message  string `json:"message,omitempty"`  // XcFail
}

type XcMsgType string

type XcOps interface {
	// BTC side.
	BtcTip() (int64, error)
	BtcConfirmations(txid string) (int, error)
	LockBTCLeg(claimPub, refundPub []byte, amountCoins string, locktime uint32) (*xchain.LegLock, int64, error)
	VerifyBTCLeg(hashH, makerClaimPub, takerRefundPub, providedScript []byte, btcLocktime uint32,
		txid string, vout uint32, amount uint64, minConf int) (*xchain.VerifiedBTCLeg, error)
	ClaimBTCLeg(leg *xchain.LegLock, key *xchain.Key, fee uint64) (string, error)
	RefundBTCLeg(leg *xchain.LegLock, key *xchain.Key, nLockTime uint32, fee uint64) (string, error)

	// SEQ side (always the anchored Sequentia/Elements node).
	SeqTip() (int64, error)
	SeqAnchorHeightOf(blockHash string) (int64, error)
	SeqBlockHashOfTx(txid string) (string, error)
	SeqFeeRate(assetHex string) (uint64, bool)
	LockSEQLeg(claimPub, refundPub []byte, amountCoins, assetLabel string, locktime uint32) (*xchain.LegLock, string, error)
	VerifySEQLeg(hashH, claimPub, refundPub, providedScript []byte, seqLocktime uint32,
		txid string, vout uint32, amount uint64, assetID string, minConf int) (*xchain.VerifiedSEQLeg, error)
	VerifySeqLegSafe(seqBlockHash string, btcLegHeight int64) (*xchain.AnchorEvidence, error)
	ClaimSEQLeg(leg *xchain.LegLock, key *xchain.Key, fee uint64) (string, error)
	WatchSEQClaim(leg *xchain.LegLock) (claimTxid string, secret []byte, err error)
	InjectSecret(secret []byte) error
	RefundSEQLeg(leg *xchain.LegLock, key *xchain.Key, nLockTime uint32, fee uint64) (string, error)
	SeqBroadcast(rawHex string) (string, error)
}

type XcRecv func(timeout time.Duration) ([]byte, error)

type XcSend func(sealed []byte) error

type XcTiming struct {
	Poll         time.Duration // chain/watch polling cadence (default 5s)
	TermsWait    time.Duration // taker: wait for XcTerms (default 2m)
	BtcConfWait  time.Duration // taker: wait for own BTC-leg confirmation (default 90m)
	SeqLockWait  time.Duration // taker: wait for XcSeqLegLocked after announcing (default 15m; maker's LockSEQLeg alone can take ~3m)
	AnchorWait   time.Duration // taker: wait for the anchor gate to pass (default 20m)
	TermsReqWait time.Duration // maker: wait for XcTermsRequest (default 2m)
	BtcFundWait  time.Duration // maker: wait for XcBtcLegFunded (default 2h; covers the taker's conf wait)
}