Skip to content

Notes

Jump to bottom
Nathan de Maestri edited this page Sep 18, 2021 · 1 revision

What needs to be figured out/built:

CORE

  • capital pool first vs credit first => how to manage different time to maturity? => pools organized around the loans or capital to be deployed? Or 2 different set of pools like Goldfinch (idle pools of capital vs capital matched to loans) => to make the loans roll: give interest to participants at end of loan, then reinvest in other loans if they are okay to leave funds in the pool (like for ETH staking) => one pool with tranches (risk, time-to-maturity) or multiple pools? https://www.investopedia.com/terms/t/tranches.asp Make it so that anyone can call the actions of the loan, in particular the ones related to expiration dates

  • credit conditions => standard or individualized? Let's begin with standard...

  • assess borrowers

Code simplicity key

LATER

  • improve speed, gas cost (=> rely on one sponsor for that) Build on Polkadot or other speedy blockchain but bridge on Ethereum for liquidity, like centrifuge.io
  • find way to bring more capital in
    • integration with a defi thing like compound? Understand how Goldfinch integrates/leverages Compound in its v1.1
    • agreements with institutions?
  • find solutions to bring more loans in, e.g. offer commission to people recommending the protocol to people who then go on to create a loan
  • legal contract build on top TrueFi: legal contract is passed (under California law) with borrower after biz is assessed. If case of default, some staked tokens are used to recover the loss from the loan, then they are restored when legal action is done. src: https://blog.trusttoken.com/mitigating-risk-truefis-loan-default-process-454359a8c4b Centrifuge creates a SPV: https://docs.centrifuge.io/learn/legal-offering/ => Good to integrate with a legal company/protocol to automate this.
  • improve the quality of the assessing algo and include more data sources
  • secondary market: trade loans as NFTs? The Rocket protocol works on that (@scottfits wants to work on such a thing)
  • inject more privacy
  • provision fund/SAFU mechanism to further secure the lenders
  • place investors funds (but also borrowers and everything else) to a defi lending protocol (or a liquidity pool) till they are allocated to loans. Examples of project: 88mph, Uniswap, Balancer, Paraswap, DXDAO's Swapr, Yearn, etc

2 different visions:

  • individual loans: borrowers tell a story to investors. People like it, feels authentic. Relative good success in plateform doing it like LendingClub.
  • capital pools based system with matching loans => more volume (but needs to be working). Can come in different flavors: standard short loans for developing countries or in the West as well. Or any loan. => solution: build base protocol, then create custom products on top

Sponsors that could be used:

  • better execution environment: Skale or Polygon or Metis

  • biconomy: improves transactions (speed, costs, less buggy). Can be paired with Polygon but not necessarily with Skale

  • oracle for off-chain data (?): Chainlink or Umbrella network

  • our provider: Pocket, Moralis, Achemy

  • store frontend: Skynet, IPFS or Textile (uses IPFS underneath)

  • fluence: decentralized execution environment for backend services with its own language (quite different than what I'm used to)

  • NuCypher: store/manage secrets ($4k to share among the projects using it)

  • use Radicle to collaborate among the developers of the team (actually no prize for just using them)

  • get on-chain data; Covalent (à la TheGraph but with probably less competition)

  • DAI prize, so use them as the stablecoin of the project

  • stream investment and repayment with Superfluid (many people will participate in this one, because the team does a great job in reaching out to the community) https://showcase.ethglobal.com/ethonline2021/prizes Note: to maximize proba of winning build application products, not something too low level, but a product leveraging other protocols

Inspiration sources

Type of loan: consumer loans (no way we start going into asset-backed loans or home-backed loans/mortgages) because both are too complex to set-up and imply in-person verifications. https://www.ratesetter.com/invest/investing-with-us/lending-criteria

Credit score: https://tala.co/

How does competition manages capital pools?

TrueFi

https://docs.truefi.io/faq/pool#lending-pools-smart-contracts

Teller

High-level Capital pools at the base.

  • As presented in page 11 of whitepaper, this model requires protocol to come up with the APY that borrowers will borrow at. This can be tricky, instead in the loan-based model the APY is determined by the market.
  • tTokens are being issued when investors put capital in one of the pools of the protocol.
  • debt collection by collection agency (I'd assume that implies some form of legal contract on top) https://teller-hosting.s3-us-west-1.amazonaws.com/Teller+Protocol+V1.0+Whitepaper.pdf

Code The link between capital pools and loans is not obvious to me in the code.

Several structs used to represent the loans and a weird/unknown way to store this info: https://github.com/teller-protocol/teller-protocol-v1/blob/1377bb03552e0480651f270a0921c740859e3daf/contracts/storage/market.sol then the values are accessed using a layer of indirection which wraps the level stored at the base layer: https://github.com/teller-protocol/teller-protocol-v1/blob/1377bb03552e0480651f270a0921c740859e3daf/contracts/market/libraries/LibLoans.sol Actually the values are sometimes accessed using multiple layers: https://github.com/teller-protocol/teller-protocol-v1/blob/1377bb03552e0480651f270a0921c740859e3daf/contracts/market/LoanDataFacet.sol

Here is where loans get created and taken out (either as NFTs or not, the treatment is different). It's done using a bunch of custom structs: https://github.com/teller-protocol/teller-protocol-v1/blob/1377bb03552e0480651f270a0921c740859e3daf/contracts/market/CreateLoanFacet.sol

Sublime High-level Individual loans at the base.

2 products:

  1. loan based on social relations ("social graph of credit")
    • You can only borrow from someone you know, or someone who knows this person. It's extended trust. Ref: https://docs.sublime.finance/sublime-docs/the-social-graph-for-credit
    • Loan-centric. Loans are called pools because they can be funded by multiple lenders/investors. Loans follow the same steps as the ones floan do.
    • When putting funds in the loan pool, lenders get ERC20 tokens in proportion of their investment.
  2. direct credit lines
    • borrower can remain anonymous
    • borrower's reputation is backed by someone public/trusted

Issues:

  • set of users with set of responsabilities/roles a bit unclear to me, a mix between the backers/auditors in Goldfinch who do verification and automatic action coming from their backend
  • social graph is limiting to scale and not very effective if relation between parties is too distant and too spread out
  • 2nd product is not really used, or if it is well let's them build it
  • offering collateralizing loans is not very useful, liquidation is a fuitile treat
  • should focus on growing user adoption on core product, instead of diverting effort to secondary product and features

Nice things:

  • money locked in the protocol but not withdrawn can be used/invested in defi protocols like Compound
  • lenders can withdraw the interests+money repaid when this amount is available in the (loan) pool
  • capital pools exist in a way but as a secondary layer to loans, in the form of CDOs (collateralized debt obligations). ERC20 tokens issue to represent debt help in creating this. Still unlike capital loans of different risk tolerant and time-to-matury buying the loans, the CDOs first need to be bought before coming to existence. NOTE: it doesn't exist yet, no trace of that in the code base.
  • possible to ask loans in different token. Not really needed, but actually a cool thing for a low level, generic protocol to be able to support that

Code: PoolFactory create Pool (1 pool by loan) https://github.com/sublime-finance/sublime-v1/blob/master/contracts/Pool/Pool.sol Separate ERC20 token per pool https://github.com/sublime-finance/sublime-v1/blob/master/contracts/Pool/PoolToken.sol => lot of contracts being created. Isn't it too costly?

Goldfinch

Maple

High-level Capital pool based

  • Deposited funds is locked for 6 months
Clone this wiki locally