Paralyx

Turkish lira liquidity without selling your XLM. Post XLM as collateral to a Blend v2 pool, borrow USDC, cash the USDC out as lira through a SEP-6 anchor, repay in lira. Paralyx is non-custodial software: the Blend pool is the lender, the anchor is the regulated party, the contract never holds funds.

Live app: https://paralyx.vercel.app · Testnet contract: CDZ22YMZ…L5Z4B · Mainnet contract: CDCYHJPS…C7ITC · Rise In x Stellar Pro Hackathon, Scale track, Istanbul, 19 to 20 September 2026

One switch in the top bar, two networks. Testnet is the hackathon deliverable: Blend TestnetV2 plus the sandbox TRY anchor, the full loop in both directions, no real money. Mainnet is the same wasm deployed against Blend's Fixed pool with real XLM and USDC; the lira leg goes through a licensed exchange until a production TRY anchor exists. The mainnet contract is unaudited, use small amounts.

Contents

1. Özet (TR)
2. Why
3. What the user does
4. Demo and proof
5. Architecture
6. Integrations and why they are load-bearing
7. Deployed artifacts
8. Mainnet
9. The contract
10. The app
11. The testnet USDC seam
12. Run it
13. Stellar Skills used
14. Design decisions
15. Regulatory posture
16. Roadmap
17. Team

Özet (TR)

Paralyx, kripto varlığını satmak istemeyen ama liraya ihtiyacı olan kullanıcı için teminatlı likidite hattı. XLM teminat konur, Blend v2 havuzundan USDC borç alınır, USDC anchor üzerinden lira olarak IBAN'a ödenir. Geri ödeme yine lirayla yapılır: anchor'a lira yatırılır, gelen USDC borcu kapatır, teminat serbest kalır. Paralyx hiçbir noktada fon tutmaz; kredi karşı tarafı Blend havuzu, lira bacağı anchor'dır. Testnet'te tam döngü sandbox anchor ile çalışır; mainnet'te aynı sözleşme Blend Fixed havuzunda gerçek XLM ve USDC ile canlıdır, lira bacağı lisanslı TRY anchor'ı açılana kadar lisanslı borsa üzerinden gider.

Why

Turkey is among the world's largest crypto markets and households already dollarize against inflation. Holders who need lira today have one option: sell. Paralyx gives them the second option every mature market has, borrowing against the asset. The user keeps XLM exposure, gets lira in minutes, and closes the position later by depositing lira.

• Users. Crypto holders in Türkiye who need short term lira liquidity, small businesses that hold stablecoins but pay suppliers in lira.
• Value. One screen, three actions: open a line, cash out lira, repay in lira. No manual bridging, no selling.
• Why Stellar. Blend already runs the credit engine, anchors already speak SEP-6 for the fiat leg, fees are negligible and the whole loop settles in seconds.

What the user does

1. Connect a wallet through Stellar Wallets Kit. On testnet the app funds it through friendbot and adds the two USDC trustlines.
2. Open a line. One Soroban transaction: the Paralyx contract submits SupplyCollateral and Borrow to the Blend v2 pool on the user's behalf. USDC lands in the wallet.
3. Cash out. The app authenticates with the anchor (SEP-10), takes a lira quote (SEP-38), opens a withdrawal (SEP-6 withdraw-exchange) and pays the anchor treasury with the memo it returned. The anchor pays lira to the IBAN and reports a bank reference. The app records the payout on the contract.
4. Repay in lira. The app opens a SEP-6 deposit-exchange, the user sends lira to the anchor's IBAN (the sandbox simulates the bank), USDC arrives, and one transaction repays the Blend debt and withdraws collateral.
5. Withdraw collateral at any time the health factor allows, with repay_line(user, 0, amount). On mainnet, while Blend has borrowing paused, this is how posted collateral comes back.

Demo and proof

The demo video walks the testnet loop first, then the same actions on mainnet with real money. Everything it shows is on chain; the wallet in the recording is GCWOMS4D…KUSW.

Testnet run, 20 September 2026:

Step	Transaction
Open a line: 100 XLM collateral, 10 USDC borrowed, one signature	75bb18cf…670bc
Cash out 4 USDC: strict-receive path payment into Circle USDC plus the payment to the anchor treasury with memo id 553221534198	32073333…4502d
The anchor settles ₺194,16 to the IBAN, bank reference FAST-2HK1C18LOO	SEP-6 transaction sep_gi7vboi4lml7b0tz4g95
record_payout writes the payout on the contract	335efaaf…94081

Earlier proof from the build session: a 2 USDC cash-out settled as 97.08 TRY with bank reference FAST-NUG8V4XHN6 (d58c43f8…dfe4c) and the market maker's own line through the contract, 8,000 XLM collateral against 2,000 USDC borrowed.

Mainnet run, 20 September 2026, real XLM and USDC:

Step	Transaction
Post 50 XLM collateral to Blend Fixed through the contract, no debt because borrowing is paused (see Mainnet)	0fc24776…8d461
Cash out 4.73 USDC to Paribu: one path payment, 24.1126 XLM arrives at the exchange deposit wallet with the account memo	e661cba9…bce80
record_payout with the lira estimate from Reflector, ₺230,75	344728c6…2d2b0
The day before: 100 XLM posted and withdrawn again through the contract	4121f4da…14a87, dc4d17bf…890de

Every open_line, repay_line and record_payout call emits an event. The Activity page reads them from RPC, and the Market page builds the cumulative lira and USDC charts from them.

Architecture

flowchart LR
  subgraph Browser
    UI[Paralyx web app<br/>React, Vite, Stellar Wallets Kit]
  end
  subgraph Stellar[Stellar, testnet or mainnet]
    CL[credit_line contract<br/>Soroban]
    BP[Blend v2 pool]
    OR[Blend oracle]
    DEX[Stellar DEX<br/>path payments]
    SAC[XLM and USDC<br/>Stellar Asset Contracts]
    RF[Reflector FX oracle<br/>USD/TRY]
  end
  subgraph Lira[Lira leg]
    AN[TR anchor<br/>SEP-1, 10, 6, 12, 38]
    BANK[(Bank<br/>IBAN payouts)]
    EX[Licensed exchange<br/>mainnet, until a TRY anchor opens]
  end
  UI -- open_line / repay_line / record_payout --> CL
  CL -- submit(from=user) --> BP
  BP -- lastprice --> OR
  BP -- transfer --> SAC
  UI -- lastprice, hourly history --> RF
  UI -- SEP-10 auth, SEP-38 quote, SEP-6 exchange --> AN
  UI -- path payment + payment with memo --> DEX
  DEX -- USDC to treasury --> AN
  DEX -- XLM with memo --> EX
  AN -- lira --> BANK
  EX -- lira --> BANK
  UI -- get_line, get_positions, events --> CL

Loading

sequenceDiagram
  autonumber
  participant U as User wallet
  participant P as Paralyx app
  participant C as credit_line
  participant B as Blend v2 pool
  participant A as TR anchor
  U->>P: Open line (100 XLM, borrow 10 USDC)
  P->>C: open_line(user, 100 XLM, 10 USDC)
  C->>B: submit(user, user, user, [SupplyCollateral, Borrow])
  B-->>U: 10 USDC
  C-->>P: Line + LineOpened event
  U->>P: Cash out 4 USDC
  P->>A: SEP-10 challenge, sign, JWT
  P->>A: SEP-38 price, SEP-6 withdraw-exchange
  A-->>P: treasury address + memo id
  U->>A: USDC payment with memo
  A-->>U: lira to IBAN, bank reference
  P->>C: record_payout(user, anchor tx id, lira)
  U->>P: Repay in lira
  P->>A: SEP-6 deposit-exchange, simulate bank
  A-->>U: USDC
  P->>C: repay_line(user, USDC, XLM)
  C->>B: submit(user, user, user, [Repay, WithdrawCollateral])

Loading

Integrations and why they are load-bearing

Piece	Role	Without it
Blend v2 lending pool (TestnetV2 on testnet, Fixed on mainnet)	Credit engine: collateral factors, interest, liquidations, oracle, pool status	No credit. Paralyx never reimplements lending math
TR Mock Anchor (SEP-1, SEP-10, SEP-6, SEP-12, SEP-38)	Fiat rail in both directions on testnet, lira out and lira in	No lira. The product is a Blend front end
Stellar Wallets Kit	Wallet connection and signing for Freighter, xBull, Lobstr, Albedo and others	Manual wallet plumbing
Reflector FX oracle	USD/TRY for the lira limit, the lira chart and the mainnet payout estimate; on testnet the anchor's SEP-38 quote carries the same rate	Static rate
Stellar DEX path payments	Converts between the two testnet USDC issuers; on mainnet delivers USDC as XLM to the exchange deposit wallet in one operation	Anchor USDC and Blend USDC cannot meet on testnet; two transactions on mainnet
USDT0 (Tether over LayerZero, mainnet)	Repay the line with USDT0 in the wallet, converted to USDC on the DEX in the same flow	USDT holders must swap by hand first

Deployed artifacts

Stellar testnet:

Item	Value
credit_line contract	CDZ22YMZKGQZVHJKRJITRZREFKCTCURUKRC63G7ABIPO6SBHXTXL5Z4B
Wasm hash	372416665b3b71cb8282c791c3ab1b021e78ccd7702f8e6eb8f8eb175b8666de
Deploy transaction	fdb56b80…6fc59
Contract admin	GDOZ44UXCLBBUTRQFOI6G5HQ5MGHG2LLEXALFKP4MTQBWEFHKPHDV52F
Blend v2 pool (TestnetV2)	CCEBVDYM32YNYCVNRXQKDFFPISJJCV557CDZEIRBEE4NCV4KHPQ44HGF
Blend oracle	CAZOKR2Y5E2OSWSIBRVZMJ47RUTQPIGVWSAQ2UISGAVC46XKPGDG5PKI
XLM Stellar Asset Contract	CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC
Blend USDC (debt asset)	CAQCFVLOBK5GIULPNZRGATJJMIZL5BSP7X5YJVMGCPTUEPFM4AVSRCJU, issuer GATALTGTWIOT6BUDBCZM3Q4OQ4BO2COLOAZ7IYSKPLC2PMSOPPGF5V56
Anchor USDC (Circle testnet)	CBIELTK6YBZJU5UP2WWQEUCYKLPU6AUNZ2BQ4WWFEIE3USCIHMXQDAMA, issuer GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5
USDC liquidity pool (both issuers)	23283282cba3c5363761ac9a7ce1ca027f6205f07107c730a76cfc021b9439e9
Anchor	tr-mock-anchor.fly.dev, treasury GCLCZEQZ2THTEDAOFI66LACNPLY4OBKN7VKLEZFMBIHYKYQOW2W7T3Z6
Paralyx market maker	GBMT43HXUDOSTBA4ALPIFJWRI72PH5YICAQIDOEJ23YEWUZ7TW2F6T7Q

Stellar mainnet:

Item	Value
credit_line contract	CDCYHJPSXA6YT5HWXOWN5R6NL2BMD5PCIXGPBVOU2C4MJHFVV6LC7ITC
Wasm hash	372416665b3b71cb8282c791c3ab1b021e78ccd7702f8e6eb8f8eb175b8666de, identical to testnet
Upload transaction	edfaa2f8…1e305
Deploy transaction	8358959d…be80e
Contract admin	GDOZ44UXCLBBUTRQFOI6G5HQ5MGHG2LLEXALFKP4MTQBWEFHKPHDV52F
Blend v2 Fixed pool	CAJJZSGMMM3PD7N33TAPHGBUGTB43OC73HVIK2L2G6BNGGGYOSSYBXBD, XLM collateral factor 0.75, USDC 0.95
Blend oracle	CCVTVW2CVA7JLH4ROQGP3CU4T3EXVCK66AZGSM4MUQPXAI4QHCZPOATS
Reflector FX oracle	CBKGPWGKSKZF52CFHMTRR23TBWTPMRDIYZ4O2P5VS65BMHYH4DXMCJZC
XLM Stellar Asset Contract	CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA
USDC (Circle)	CCW67TSZV3SSS2HXMBQ5JFGCKJNXKZM7UQUWUZPUTHXSTZLEO7SJMI75, issuer GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN
USDT0 (Tether over LayerZero)	USDT0:GATISXX6BZ6NC7IKQBY37CJD4SOZL3CYZJWXEDG6JVIY4WBS6KXJHN6Q

Mainnet

The same credit_line wasm is deployed on Stellar mainnet against Blend v2's Fixed pool. Switching the top bar to Mainnet points the app at it. What changes:

• One USDC. Blend's USDC and the anchor USDC are the same Circle asset, so the testnet conversion seam disappears.
• Lira leg through a licensed exchange. There is no production SEP-6 TRY anchor on Stellar yet. The exchange page sends the borrowed USDC to your exchange deposit address as XLM in a single path payment with the exchange's memo; you sell there and withdraw lira to your IBAN. The app then records the payout on the contract with the lira value at Reflector's rate, so the lira charts stay live on mainnet. When a licensed anchor opens, the SEP-6 adapter used on testnet takes over with a home domain change.
• Repay with USDT0 or USDC. USDT0 in the wallet converts to USDC on the Stellar DEX and repays the line in the same flow; USDC repays directly.
• Pool status is enforced in the UI. Blend gates new borrows when a pool is on ice (status above 1) and supplying when it is frozen (above 3). The app reads get_config, shows the status on the line card, the market page and the live market card, disables the borrow field and switches the action to collateral only while borrowing is closed. As of 20 September 2026 both Blend v2 mainnet pools are on ice after the late August exploit of the Comet BLND-USDC pool that backs the backstop, so the mainnet contract accepts collateral, repayments and withdrawals but no new debt until Blend resumes. Nothing in Paralyx needs to change for that: lines open the moment the pool status allows it.
• Exchange transfers are verified before signing. The cash-out card checks the destination on Horizon (the account must exist and must not be the sender), reads the SEP-29 config.memo_required flag and blocks memo-less sends to accounts that declare it, looks the address up in the stellar.expert directory and locks the send if it belongs to a different exchange than the one selected, shows a transfer summary with the minimum XLM that will arrive, and requires an explicit confirmation that the address and memo match the exchange deposit page.
• Fees are real. Uploading the 9.5 KB wasm cost about 15 XLM of code storage rent; creating the contract about 2 XLM. Inclusion fees needed 2,000 stroops during the deploy because the default 100 was below the network's Soroban minimum at the time.

The contract

contracts/credit_line is a thin, auditable composition layer over Blend. It never holds tokens. All value moves between the user and the Blend pool; the contract records the line and emits events.

Function	Auth	What it does
__constructor(admin, pool, collateral_asset, debt_asset)	deploy time	Stores config in instance storage. Runs once, so there is no reinitialization surface
open_line(user, collateral_amount, borrow_amount)	user	Builds SupplyCollateral and Borrow requests (a zero amount skips that request), calls pool.submit(user, user, user, requests), creates or tops up the line, emits LineOpened
repay_line(user, repay_amount, withdraw_collateral)	user	Repay and WithdrawCollateral requests (zero skips), updates the line, emits LineRepaid. Blend clamps over-repayment and over-withdrawal
record_payout(user, anchor_tx_id, try_amount)	user	Records a completed lira payout (amount in kuruş), emits PayoutRecorded
get_line(user), get_config(), get_line_count()	none	Views
positions(user)	none	Passes through to pool.get_positions
upgrade(new_wasm_hash)	admin from storage	Upgrades the code

Patterns worth pointing at:

• Nested authorization. The user signs once. open_line calls user.require_auth(), then Blend's submit calls spender.require_auth() and the token contracts require the same address again inside the sub-invocation tree. One signed authorization covers the whole tree, which is what makes a router contract possible on Soroban.
• Storage. Config and the line counter live in instance storage; each user's Line lives in persistent storage under DataKey::Line(user). Every read and write extends the TTL (14 day threshold, 60 day extension), and every entrypoint bumps the instance TTL.
• Events. Typed #[contractevent] structs with the user as a topic, so wallets and the Activity page can filter by address.
• Validation. Negative amounts panic with a typed error, empty request lists are rejected before any cross-contract call, and repay or payout on a missing line fails.
• Line totals are requested amounts. Blend clamps an over-sized repay or withdrawal to the real position, so the app passes amounts close to the position and the authoritative balances always come from get_positions.

Tests (cargo test, 8 tests) run against a mock pool that records the forwarded requests and cover: request forwarding, auth requirement without mocked auths, rejection of empty and negative requests, aggregation on a second open, repay and withdraw forwarding, missing-line failures, payout recording and config storage.

The app

Five screens behind a collapsible sidebar, all reading from chain and from the anchor, nothing mocked. English by default, Turkish behind the TR switch.

• Dashboard. Available lira limit, collateral, debt, health factor, pool status, live USD/TRY and XLM/USD charts, lines opened per hour, recent activity.
• Market. The Blend v2 pool: total supplied and borrowed in USD, utilization, every reserve with price, supply and borrow APR from Blend's three slope rate model, collateral factors, pool status. Below it, Paralyx's own hourly and cumulative lira payouts and cumulative USDC borrowed, built from contract events.
• Activity. Protocol totals and the event feed, filterable to your address, every row linked to the explorer.
• Open a line. Wallet setup (friendbot and trustlines on testnet), the collateral plus borrow form with borrow gating by pool status, and the collateral withdrawal card.
• Exchange. Testnet: USDC to lira through the anchor, lira to USDC to repay. Mainnet: USDC to the exchange as XLM, repay with USDT0, repay with USDC.

Charts

TradingView's open source lightweight-charts: crosshair with a local-time tooltip, formatted price and time axes, a dashed last-price line, a lavender gradient area, and for XLM a candlestick view with a volume histogram and 24 hour, 7 day and 30 day ranges (Horizon trade aggregations at 15 minute, hourly and daily resolution). Calm series such as USD/TRY keep a minimum visible span so one kuruş of noise does not fill the frame; cumulative series are stepped. Colors follow the theme tokens live. Data: Reflector's mainnet FX oracle for USD/TRY (hourly points, as far back as the oracle keeps history) and Stellar DEX trade aggregations for XLM/USDC; the live values on the dashboard poll Reflector's lastprice and the mainnet XLM/USDC order book every 15 seconds.

Design system

White surfaces, black text, and a lavender accent (#d9dbfc) for every interactive component: buttons, selected states, badges, chart fills and progress markers. Colors are theme tokens (web/src/index.css), so the dark theme is a variable override with the same accent. The theme follows the system preference on first visit and can be toggled from the header; the sidebar collapses to an icon rail; both choices persist. Sora Light is the only typeface. Wallet connection is a custom modal over Stellar Wallets Kit.

Data layer

Every read goes through a small cache in web/src/lib/store.ts: keyed entries with a time to live, in-flight de-duplication, background revalidation while the tab is visible, and a persisted snapshot in localStorage (bigint safe) so a returning visitor sees the last known state at first paint while fresh data loads behind it. Screens update field by field as each request lands. Contract events are kept in an incremental local log and only the ledgers after the last scan are fetched; Reflector hourly points are cached per hour; Blend reserve reads are shared between the market table and the health calculation; navigation links prefetch their page's data on hover. RPC calls run through a concurrency limited pool with retry and, on mainnet, a second endpoint as fallback.

Exchange screens

Both networks share one set of exchange primitives: a segmented mode switch, an amount field with balance, presets and inline validation, a quote bar with age and refresh, a collapsible fee breakdown, a list of reasons while the action is disabled, a receipt with copy buttons and explorer links after success, and a local history of the wallet's recent transactions. On mainnet the exchange picker carries the exchanges' own icons. Choosing Paribu fills its current XLM deposit wallet (GAMZLXGV…QNAGH, the account Paribu's app shows to depositors); the older GBZLHGDY…ZQKVA listed in the stellar.expert directory is also recognised. The user only adds the memo from their own Paribu account. Saved accounts let a device remember an exchange address and memo behind one chip; the app also ships one built-in saved account for the founder's own Paribu deposit so the demo runs from a fresh browser.

The testnet USDC seam

Blend's testnet pool lends its own test USDC (issuer GATALT…). The anchor pays and accepts Circle's testnet USDC (issuer GBBD47…). They are different assets on testnet and the same asset on mainnet. The app bridges the gap with the Stellar DEX: cash-out uses a strict-receive path payment (Blend USDC in, exactly the anchor amount of Circle USDC out) followed by the memo payment to the treasury, and repayment converts the other way before calling repay_line. During the build the shared liquidity pool between the two issuers was one-sided, so the Paralyx market maker rebalanced it to roughly 2,000 USDC per side at 1:1 (cc265840…547f0). On mainnet this whole section disappears.

Run it

contracts/            Soroban workspace (credit_line)
web/                  React + Vite + Tailwind v4 app, Sora typeface, EN and TR
scripts/              Node helpers: anchor SEP flows, market seeding, cash-out and event checks
docs/                 Demo narration, demo scenario, jury Q&A, pitch outline, brand assets

Build and test the contract

cd contracts
cargo test
stellar contract build
stellar contract optimize --wasm target/wasm32v1-none/release/credit_line.wasm

Deploy (constructor arguments after --):

stellar contract deploy \
  --wasm target/wasm32v1-none/release/credit_line.optimized.wasm \
  --source-account <deployer> --network testnet -- \
  --admin <G...> \
  --pool CCEBVDYM32YNYCVNRXQKDFFPISJJCV557CDZEIRBEE4NCV4KHPQ44HGF \
  --collateral_asset CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC \
  --debt_asset CAQCFVLOBK5GIULPNZRGATJJMIZL5BSP7X5YJVMGCPTUEPFM4AVSRCJU

Drive it from the CLI (the source account is the user; nested Blend and token auths are signed with it):

stellar tx new change-trust --source-account <user> --network testnet \
  --line USDC:GATALTGTWIOT6BUDBCZM3Q4OQ4BO2COLOAZ7IYSKPLC2PMSOPPGF5V56
stellar contract invoke --id CDZ22YMZKGQZVHJKRJITRZREFKCTCURUKRC63G7ABIPO6SBHXTXL5Z4B \
  --network testnet --source-account <user> -- \
  open_line --user <G...> --collateral_amount 1000000000 --borrow_amount 100000000

Run the web app

cd web
npm install
npm run dev

Network configuration is in web/src/config.ts. The app needs a wallet supported by Stellar Wallets Kit; Freighter is the easiest, set it to testnet or mainnet to match the switch in the top bar.

Scripts

cd scripts && npm install
node anchor.mjs deposit <secret> 1000        # SEP-10, SEP-12, deposit-exchange, simulated bank, poll
node anchor.mjs withdraw <secret> 2          # withdraw-exchange instruction (treasury + memo)
node cashout-test.mjs <secret> 2             # full cash-out: convert, pay with memo, wait for the anchor
node rebalance-pool.mjs <secret> 1990        # swap Blend USDC into the shared pool
node events-test.mjs                         # decode contract events from RPC

Stellar Skills used

• skills/cross-chain/SKILL.md and skills/cross-chain/layerzero.md from stellar/stellar-dev-skill for LayerZero, USDT0 and CCTP on Stellar (the USDT0 repayment path and the roadmap).
• skills/smart-contracts/security.md from stellar/stellar-dev-skill as the review checklist for the contract (authorization on the address loaded from storage, no reinitialization path, TTL extension in hot paths, no arbitrary contract calls).
• skills/dapp/SKILL.md from stellar/stellar-dev-skill for the Stellar Wallets Kit v2 static API and the SDK v16+ ESM notes.
• SKILL.md from yigitcangokmen/stellar-hackathon-turkiye for the TR Mock Anchor endpoints, limits and asset identifiers.
• The anchor's own machine-readable guide at tr-mock-anchor.fly.dev/llms.txt.

Design decisions

• Compose on Blend instead of writing a pool. The 2025 Paralyx prototype had its own lending pool. Rewriting it in a weekend would reproduce Blend with less safety. Composing gives real interest, liquidations and oracle handling for free and keeps the Paralyx contract small enough to read in five minutes.
• User authorizes, contract routes. Positions belong to the user on Blend, not to Paralyx. If Paralyx disappears, the user's Blend position and the Blend UI still work.
• SEP-6 over SEP-24. The hackathon anchor speaks SEP-6, and programmatic deposits let the app own the whole screen. The adapter is small, so a SEP-24 anchor is a swap, not a rewrite.
• Strict-receive path payments. The anchor needs an exact amount with a memo. Strict receive guarantees the exact Circle USDC amount regardless of testnet pricing quirks.
• Everything readable without a wallet. Views run as simulations against a read-only source account, so the Activity page and the lira limit work before connecting.
• Honest mainnet. When Blend paused borrowing, the app got pool status gating instead of a workaround. Collateral, repayment, withdrawal and the exchange leg run for real; borrowing waits for Blend.

Challenges met on the way:

• Two USDCs on testnet. Solved with the DEX and a rebalanced pool, see above.
• Anchor watcher only sees classic payments. A Soroban token transfer from a contract does not show up as a Horizon payment, so the final leg to the treasury is a classic payment operation with the memo, sent by the user's own account.
• Nested auth from a router. Verified on testnet with the CLI before writing a single line of frontend, so the riskiest assumption was retired first.
• Mainnet fees and rent. Soroban inclusion fee minimum and wasm storage rent are real numbers; the deploy is documented above so the next team member does not rediscover them.
• SDK churn. Soroban SDK 28 replaced env.events().publish with typed events and update_current_contract_wasm with update_current_contract; Wallets Kit v2 is fully static and moved to JSR. The code targets the current APIs.

Regulatory posture

Paralyx is non-custodial software. It never holds user funds, never sets rates and is not the lender; the Blend pool is the counterparty. It never touches lira; a licensed anchor or exchange is the regulated party for KYC, AML and bank payouts. Product copy says "collateralized liquidity", not consumer credit. Before scaling on mainnet the plan includes a legal opinion on the CASP framework under Türkiye's 2024 crypto asset law and the consumer credit rules that apply to marketing.

Roadmap

Toward an SCF Build award, Integration track, and InstAward:

1. Licensed TRY anchor. No production Turkish anchor exists yet; the SEP-6 adapter is written so the switch is a home domain change. Bridge and BlindPay are the fallback rails for USD and EUR.
2. Mainnet credit. The contract is live on Blend Fixed; borrowing opens the moment Blend lifts the pool status. An audit of credit_line before real volume.
3. Idle collateral yield. Route part of the collateral into a DeFindex vault so the line earns while it is open.
4. Omnichain entry. USDC from any EVM chain through Circle CCTP next to the USDT0 path that already repays lines, so a lira line can be opened from assets that live elsewhere.
5. Private payouts. Stellar Private Payments for salary style lira disbursements once it reaches mainnet.
6. Health guardian. Notifications and one-click top-up from lira when the health factor drops.

Team

Baturalp Güvenç (contracts, app, integrations) and Abdullah Valisoy (product and presentation).

Paralyx started at a 2025 Stellar hackathon as a cross-chain LSD lending prototype (paralyx-LSD/paralyx-protocol). This repository is the 2026 rebuild around what the ecosystem now offers: Blend v2 for credit and anchors for lira.

License

MIT