This project contains the implementation of a money market contract native to the Archway blockchain.

The contract allows users to deposit funds for lending, withdraw lent funds, provide collateral to borrow against, withdraw collateral, borrow funds, and repay loans.

• Deposit: Deposit funds for lending.
• Withdraw: Withdraw lent funds.
• Provide Collateral: Deposit collateral to borrow against.
• Withdraw Collateral: Withdraw collateral after repaying loans.
• Borrow: Borrow funds from the lending market.
• Repay: Repay borrowed funds to the lending market.

• Config: Stores the contract owner.
• Collateral: Represents collateral deposited by borrowers.
• Deposit: Represents deposits made by lenders.
• Loan: Represents loans taken by borrowers.

• InstantiateMsg: Initializes the contract with an optional owner address.
• ExecuteMsg: Defines the executable messages:
  • DepositCollateral { amount, valuation }
  • WithdrawCollateral { amount }
  • AdjustValuation { new_valuation }
  • PayTax
  • LiquidateCollateral { collateral_id }
  • Deposit { amount }
  • Withdraw { amount }
  • Borrow { amount }
  • Repay { amount }
• QueryMsg: Queries the state of a specific collateral using its ID.

Instantiate the contract with an optional owner address:

{
  "owner": "archway1..."
}

Deposit collateral to borrow against:

{
  "deposit_collateral": {
    "amount": "1000000",
    "valuation": "1500000"
  }
}

Withdraw collateral after repaying loans:

{
  "withdraw_collateral": {
    "amount": "500000"
  }
}

Adjust the valuation of the deposited collateral:

{
  "adjust_valuation": {
    "new_valuation": "1600000"
  }
}

Pay taxes on the collateral:

{
  "pay_tax": {}
}

Liquidate collateral of a borrower:

{
  "liquidate_collateral": {
    "collateral_id": "12345"
  }
}

Deposit funds for lending:

{
  "deposit": {
    "amount": "1000000"
  }
}

Withdraw lent funds:

{
  "withdraw": {
    "amount": "500000"
  }
}

Borrow funds from the lending market:

{
  "borrow": {
    "amount": "700000"
  }
}

Repay borrowed funds to the lending market:

{
  "repay": {
    "amount": "700000"
  }
}

Query the state of a specific collateral using its ID:

{
  "collateral_id": "12345"
}

1. Collateral Management:

   • Users can deposit CONST tokens as collateral (deposit_collateral function).
   • They can withdraw deposited collateral (withdraw_collateral function).
   • Collateral valuation can be adjusted (adjust_valuation function).
   • Taxes can be paid on collateral (pay_tax function).
   • Collateral can be liquidated (liquidate_collateral function).

2. Funds Management:

   • Users can deposit CONST tokens (deposit_funds function).
   • They can withdraw deposited tokens (withdraw_funds function).
   • Users can borrow CONST tokens against their deposited collateral (borrow_funds function).
   • They can repay borrowed tokens (repay_funds function).

3. Borrowing Limit Calculation:

   • The borrowing capability typically depends on the collateral valuation (collateral.valuation) and the requested loan amount (amount).
   • In the borrow_funds function, there is a check to ensure that the collateral's valuation is greater than or equal to the requested loan amount (if collateral.valuation < amount).

Given this setup, if a user wants to borrow CONST tokens, they need to deposit collateral valued sufficiently high relative to the amount they wish to borrow. For example, if a user deposits $10 worth of CONST tokens as collateral, the borrowing limit depends on how the contract determines the valuation of this collateral (collateral.valuation). Typically, the contract would enforce a borrowing limit that doesn't exceed a certain fraction (like 50% or 70%) of the collateral's valuation to ensure safety and to account for potential fluctuations in token value.

Let's assume:

• User deposits $10 worth of CONST tokens.
• The contract determines the collateral's valuation (collateral.valuation) to be $12.

If the contract allows borrowing up to 50% of the collateral's valuation:

• Borrowing limit = 50% of $12 = $6.

Therefore, in this scenario, the user could borrow up to $6 worth of CONST tokens.

Usefulness of Tax Payments

• Sustainability and Maintenance: Tax payments help sustain the operation of the smart contract by collecting fees. These fees can cover the costs associated with contract execution, such as computational resources used by validators or oracles.

• Risk Management: Tax payments can act as a risk management tool. By imposing fees on collateral, the contract ensures that borrowers are incentivized to manage their positions effectively. This discourages users from holding excessive amounts of collateral without actively using them for borrowing, thus reducing systemic risk.

• Revenue Generation: Depending on the contract design, tax payments may generate revenue for the contract owner or community governance. This revenue can be used to fund further development, community incentives, or ecosystem growth.

• Compliance and Regulation: In some cases, tax payments might also serve regulatory compliance purposes. For example, in decentralized finance (DeFi) applications, taxes could represent regulatory fees or compliance costs that the contract needs to cover to operate legally.

Economic Stability: By periodically deducting taxes, the contract stabilizes the economic environment within its ecosystem. This stabilization can help mitigate volatility and ensure a more predictable environment for borrowers and lenders alike.

• Rust
• Cargo
• Archway SDK

Build the contract:

cargo build --release

Run tests:

cargo test

Generate JSON schemas for the contract messages:

cargo run --bin schema

This project is licensed under the MIT License.

This contract is inspired by various DeFi lending protocols and adapted for use on the Archway blockchain.

Feel free to reach out with any questions or suggestions for improvement!