Swift SDK

dependencies: [
    .package(url: "https://github.com/layerhop/layerhop-swift", from: "0.6.0"),
],
targets: [
    .target(name: "MyApp", dependencies: [.product(name: "LayerHop", package: "layerhop-swift")]),
]

import LayerHop

let lh = LayerHopClient(apiKey: ProcessInfo.processInfo.environment["LAYERHOP_API_KEY"])

// 1. Quote
let q = try await lh.quote(QuoteParams(
    srcChain: "base", srcToken: "USDC", amount: "100000000",
    dstChain: "solana", dstToken: "SOL",
    sender: "0xYourEvmAddress", recipient: "YourSolanaAddress"))

// 2. Build the unsigned transaction
let tx = try await lh.buildTx(quoteId: q.best.quoteId)

// 3. Sign + send with YOUR wallet
let txHash: String
switch tx {
case .evm(let evm):
    // send evm.approval first when set, then {to, data, value} on evm.chainId,
    // then each of evm.extraTxs in order
    txHash = try await wallet.sendEvm(evm)
case .svm(let svm):
    let signed = try await wallet.signSolana(base64: svm.serializedTx)
    // submitViaApi: sign only and let LayerHop broadcast
    txHash = svm.submitViaApi
        ? try await lh.submit(quoteId: q.best.quoteId, signedTransaction: signed)
        : try await wallet.broadcastSolana(signed)
}

// 4. Report the broadcast
_ = try await lh.reportSubmitted(quoteId: q.best.quoteId, txHash: txHash)

// 5. Watch until filled / refunded / failed
for try await st in lh.watch(provider: q.best.provider, id: txHash) {
    print(st.state)
}

let s = try await lh.createCheckoutSession(CreateCheckoutParams(
    amount: "49000000", settleChain: "base", settleToken: "USDC", // 49 USDC
    recipient: "0xYourPayoutAddress", reference: "order_1042",
    successUrl: "https://shop.example.com/thanks"))
// open s.url; fulfil on the checkout.session.completed webhook

// Your own payment page: quote, then pay with buildTx + reportSubmitted as usual
let cq = try await lh.quoteCheckoutSession(id: s.id, CheckoutQuoteParams(srcChain: "arbitrum", srcToken: "ETH", sender: payer))
let tx = try await lh.buildTx(quoteId: cq.best.quoteId) // cq.best.srcAmount is what the payer sends

let p = try await lh.createCheckoutProduct(CreateCheckoutProductParams(
    name: "Pro plan", amount: "49000000", settleChain: "base", settleToken: "USDC",
    recipient: "0xYourPayoutAddress", allowedOrigins: ["https://shop.example.com"]))
_ = try await lh.updateCheckoutProduct(id: p.id, UpdateCheckoutProductParams(active: false))
// Public (no key): a session on the product's terms
let session = try await LayerHopClient().startProductCheckout(id: p.id, StartProductCheckoutParams(reference: "order_1042"))

let inv = try await lh.createInvoice(CreateInvoiceParams(
    lineItems: [InvoiceLineItem(description: "Design work", quantity: 2, unitAmount: "100000000")],
    settleChain: "base", settleToken: "USDC", recipient: "0xYourPayoutAddress",
    customerEmail: "jane@example.com", dueAt: "2026-11-01", send: true))
// inv.status == .open; inv.url is the hosted page

let r = try await lh.createRefund(sessionId: sessionId, CreateRefundParams(amount: "10000000", reason: "Damaged item"))
let refundTx = try await lh.buildTx(quoteId: r.quote.quoteId)
// sign and broadcast refundTx from r.quote.from, then reportSubmitted(quoteId:txHash:)

let d = try await lh.createDepositAddress(CreateDepositAddressParams(
    srcChain: "base", srcToken: "USDC", dstChain: "arbitrum", dstToken: "USDC",
    recipient: "0xUserOnArbitrum", refundTo: "0xUserOnBase", label: "user_42"))
print(d.address, d.estimate?.dstAmount ?? "")
// later: refreshDepositAddress(id:) · disableDepositAddress(id:) · simulateDeposit(id:amount:) (test keys)

let sub = try await lh.createSubscription(CreateSubscriptionParams(
    customerEmail: "ada@example.com", interval: .month, productId: "prod_..."))
_ = try await lh.cancelSubscription(id: sub.id, atPeriodEnd: true)

let lo = try await lh.createLimitOrder(CreateLimitOrderParams(
    wallet: "YourSolanaAddress", srcToken: "USDC", dstToken: "SOL",
    amount: "100000000", dstAmount: "600000000"))
if let tx = lo.tx?.svm {
    let signed = try await wallet.signSolana(base64: tx.serializedTx)
    _ = try await lh.submitLimitOrder(id: lo.id, signedTransaction: signed)
}
// cancelLimitOrder(id:) returns the cancel tx to sign and submit the same way

for try await order in lh.streamOrder(quoteId: quoteId) {
    print(order.status ?? "", order.dstTxHash ?? "")
}

do {
    _ = try await lh.buildTx(quoteId: quoteId)
} catch let e as LayerHopError where e.code == "QUOTE_EXPIRED" {
    // re-quote
}

do {
    let event = try Webhook.constructEvent(
        secret: webhookSecret, body: rawBody, header: request.value(forHTTPHeaderField: "LayerHop-Signature"))
    if event.type == .orderFilled { /* … */ }
} catch {
    // respond 401
}