We will be undergoing planned maintenance on January 16th, 2026 at 1:00pm UTC. Please make sure to save your work.

LoanFlow Tokenizer

SynTrade Ledger: Transforming illiquid Loans into Instant Assets. Real-time risk scoring via SBTs and instant secondary market trading.

Comment

Inspiration

The inspiration for SynTrade Ledger stems directly from the LMA's core mission: enhancing liquidity and efficiency within the multi-trillion dollar loan market. We recognized the critical bottleneck in the secondary market—settlements taking weeks—which is a direct contradiction to modern capital market expectations. We were driven to apply blockchain technology to create a commercially viable, desktop-first solution that transforms an illiquid loan contract into a liquid, verifiable digital asset.

What it does

SynTrade Ledger reimagines the loan lifecycle by tokenizing debt and creating a trustless secondary market layer for it. The platform allows a bank to:

  1. Tokenize: Convert a signed loan agreement into a non-custodial digital asset pair.
  2. Manage Risk: Maintain an immutable, real-time health score for the underlying loan via the Soulbound Token (SBT) structure, transparent to potential buyers.
  3. Trade Instantly: List the asset on a secondary market for immediate liquidity via Fixed-Price Sales.
  4. Simulate Servicing: The owner can initiate a Claim Interest process, proving the asset generates cash flow.

How we built it

We utilized a modern and robust stack to build the protocol and the user interface:

  • Smart Contracts (The Backend): Built using Solidity (v0.8.31) and Foundry. We developed the LoanNFT (ERC721 for trading) and the LoanFactory (to mint the NFT and the associated risk record). We also deployed a secure LoanMarketplace contract to handle the listing and buying process.
  • Frontend (The Desktop Prototype): Built with React/Vite for speed. We integrated Wagmi/Viem for wallet connectivity (MetaMask on Sepolia) and Tailwind CSS for a professional, enterprise-grade UI.
  • Data Binding: We used useReadContract extensively to make the UI reactively update based on the blockchain state (e.g., showing cards only if they exist, showing the correct price if listed).

Challenges we ran into

The complexity of bridging a legacy financial concept to immutable code presented several challenges:

  1. The SBT/NFT Connection: Ensuring the NFT was transferable but its associated SBT was not required careful Solidity inheritance and custom logic.
  2. Asynchronous Transactions (The Big One): When selling, a user must first approve() the Marketplace contract before they can listLoan(). Managing these two sequential, asynchronous blockchain transactions in React/Wagmi without crashing the UI (the "wait-for-it" logic) required careful state management and the use of waitForTransactionReceipt.
  3. Access Control: We ran into issues where the script defaulted to a test address instead of the actual owner address. We solved this by hardcoding the deployment address in the script to guarantee that only the designated owner wallet has the authority to mint new tokens.

Accomplishments that we're proud of

We are most proud of creating a system that integrates three distinct concepts into one coherent product:

  1. Tokenization for Liquidity.
  2. SBT for Immutable Risk Visibility.
  3. A functioning two-step marketplace flow (Approve/List).

The privacy feature in the UI, where asset value is blurred for non-owners, demonstrates a keen awareness of commercial sensitivity in a way a purely technical project might miss.

What we learned

We learned that building on-chain systems requires anticipating real-world operational complexity. Specifically, we learned:

  • The absolute necessity of pinning library versions (wagmi v2 vs v3 issue).
  • The importance of error handling in asynchronous calls (using try/catch with writeContractAsync) to provide better user feedback than just "stuck on pending."
  • That a clear, multi-step UI flow is essential to guide non-crypto experts through complex transaction processes.

What's next for SynTrade Ledger

If we had more time, we would implement:

  1. Servicing Automation: Full integration of the claimPayment function, allowing the NFT owner to automatically claim accrued interest based on on-chain oracles.
  2. Off-Chain Bidding: Implementing secure off-chain bidding via signed messages (like OpenSea does) for the negotiation phase before a final on-chain execution.
  3. Metadata Standards: Deploying metadata to IPFS instead of using local simulation data, which would make the token truly interoperable.

Built With

Share this project:

Updates