• Hardened JavaScript: Enhanced security for smart contract development.
• Eventual Send with E(): Asynchronous message passing for robust applications.
• Far(), Remotable, and Marshaling: Secure object communication.
• Notifiers and Subscriptions: Reactive programming for real-time updates.

• Earning Interest: Interest accrues per block, increasing over time.
• COMP Governance Tokens: Users earn COMP tokens, which can be traded or used for governance voting.

• Who are you?

• What’s your income?

• Have you repaid previous debts?

• Under-collateralisation: The collateral value is less than the loan amount. For example, with a 30% collateralisation factor, you’d need to provide £30 to borrow £100. This is a more traditional approach.
• Over-collateralisation: The collateral must exceed the loan value. For instance, with £100 collateral and an 80% collateralisation factor, you can borrow £80. This ensures the lender is covered even if the borrower defaults.

• Automated Market Maker (AMM): Sell collateral via an automated market system.
• Manual Sale: Sell at a slightly lower price to attract buyers.

• Utilisation Ratio
• Borrow Rate
• Exchange Rate

• ERTP: Agoric's framework for digital assets or tokens.
• Zoe: A smart contract development framework that safeguards users' assets from bugs and malicious code.
• Agoric Offers: The basic logic used when interacting with contracts.
• Agoric Native AMM: An Automated Market Maker for trading various tokens, including those imported via IBC.
• PriceAuthority: An interface between Zoe and price oracles.

• Deposit Money

• Borrow Money

• Redeem Deposited Money

• Adjust Loan

• Close Loan

• LendingPool: Entry point directing users to the correct pools after necessary checks. See the code.
• PoolManager: Manages pools for specific assets (e.g., VAN Pool for VAN token), storing underlying assets, minting protocol tokens (e.g., AgVAN), and handling deposits, borrowing, and redemptions. See the code.
• PriceManager: Central hub for managing multiple price authorities used by the protocol. See the code.
• ProtocolMath: Implements key financial formulas, including exchange rate, utilisation ratio, and borrow rate. See the code.
• DebtsPerCollateral: Groups loans with the same collateral and debt type, ensuring consistent responses to market changes, such as liquidation triggers. See the code.
• Loan: Core module for loan management, enabling balance adjustments, loan closures, and dapp notifications. See the code.
• LiquidationObserver: Monitors price changes and initiates liquidation if loans become undercollateralised. See the code.

• Linux shell or equivalent

• Node.js (LTS version >= 14.x.x)

• Yarn

• Git

git clone https://github.com/Agoric/agoric-sdk.git
cd agoric-sdk
git checkout beta
git pull

yarn install

yarn link-cli ~/bin/agoric

agoric --version

Our protocol is built on the agoric-sdk beta branch so the version should be 0.15.0

git clone https://github.com/anilhelvaci/dapp-pool-lending-protocol.git
cd dapp-pool-lending-protocol
git checkout blog/bytepitch
git pull

In Agoric there are two types of local test chains; a sim-chain and a local-chain. A sim-chain, simulated chain, is where we can test our dapps and contracts but there's no transaction cost. So it's simulated, not real. On the other hand there's a local-chain which is based on the cosmos-sdk, therefore it's based on GoLang. Starting a local-chain requires building some go packages. If you plan to test with multiple clients interacting with the same chain, local-chain is the way to go. Check

this page

for further information.

cd dapp-pool-lending-protocol 
agoric start --verbose --reset

For Agoric CLI reference, check

this page

.

cd dapp-pool-lending-protocol
agoric deploy contract/deploy/deploy.js api/deploy.js

• contract/deploy/deploy.js: Sets up the environment (AMM, price authorities, etc.) and starts the LendingPool contract.
• api/deploy.js: Requests test tokens and adds liquidity to the pools, bootstrapping the protocol.

agoric open --repl

cd dapp-pool-lending-protocol/ui
yarn start

• Markets: Displays general market data and enables you to Supply or Borrow money from a selected pool.
• Activity: Shows the user’s activity such as deposited assets and borrows. Also enables the user Redeem, Close or Adjust Loan.

• APY: Annual Percentage Yield represents the interest paid on debt and earned on supplied assets. In our protocol, the Supply and Borrow APYs are the same since we don’t use a ReserveFactor.
• MMR: Minimum Margin Requirement is the ratio between collateral and debt value. For example, with $150 collateral, you can borrow up to $100.

The protocol is pre-bootstrapped with liquidity, so the deposits section isn’t empty.

1. Depositing funds into a pool.

2. Borrowing from another pool using protocol tokens as collateral.

3. Adjusting the loan by repaying part of the debt.

4. Closing the loan by repaying in full and reclaiming collateral.

5. Redeeming the initial deposit.

You might notice that the numbers you see in supply screenshots is inconsistent with rest of the screenshots, that's because I took them out of sync from the rest of the sequence.

• What Agoric is, how it works, and how to develop with it.

• How to build a smart contract using Agoric.

• The fundamentals of a pool-based lending protocol and its most well-known implementation, Compound Finance.

• Our approach to implementing a pool-based lending protocol.

• A step-by-step user journey, from depositing funds to repaying loans.

• Real-world applications in blockchain, DeFi, DApp development, Web3, Ethereum, smart contracts, and blockchain protocols.