> For the complete documentation index, see [llms.txt](https://docs.canopyhub.xyz/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.canopyhub.xyz/canopys-four-layers/strategy-layer/simple-lending-strategy/moveposition-lend.md). # MovePosition Lend ## Overview The `moveposition_simple::strategy` module implements a lending strategy for the MovePosition protocol. It manages lending positions using packets (serialized tickets) for position validation and state management. ## Terminology ### Packet A signed binary packet containing a serialized ticket that authorizes the deposit. The packet is verified using Hocket and must contain valid ticket data ## Strategy Module ### Structs ### MovePositionStrategy Core strategy struct storing vault and authorization references. ```rust struct MovePositionStrategy has key { vault: Object, // used to deposit/withdraw funds to/from auth_ref: AuthRef // used to retrieve strategy signer for depositing assets } ``` ### Witness Internal witness type for strategy creation. ```rust struct Witness has drop {} ``` ## Events * **StrategyCreated**: Event emitted when a new strategy is created. ## Error Codes * `EINVALID_AMOUNT`: Invalid amount specified * `EINSUFFICIENT_BALANCE`: Insufficient balance to perform the operation * `EVAULT_MISMATCH`: Invalid vault specified * `EWITHDRAWAL_ACCOUNT_MISMATCH`: Invalid withdrawal account specified * `ECANNOT_EXCEED_DEBT`: Cannot exceed the strategy debt ## Public Functions * `create(account: &signer, vault: Object, debt_limit: u64)`: Creates a new instance of the strategy for the specified vault. Only callable by governance account. * `deposit_coin(account: &signer, strategy: Object, packet: vector, amount: u64)`: Deposits the strategy's base asset (Coin) directly into the strategy, using the internal deposit\_internal function. Requires a packet. * `vault_deposit_coin(account: &signer, strategy: Object, packet: vector, amount: u64)`: Deposits the strategy's base asset (Coin) from the vault into the strategy, using the internal deposit\_internal function. Requires a packet. * `withdraw_coin(account: &signer, strategy: Object, packet: vector, amount: u64, max_loss: Option)`: Withdraws the strategy's base asset (Coin) directly from the strategy. Uses internal functions prepare\_withdrawal\_internal to withdraw strategy shares from signer's primary fungible stores and process\_withdrawal\_internal to redeem the strategy shares for the strategy's base asset (Coin). Requires a packet. * `vault_withdraw_coin(account: &signer, request: &mut WithdrawalRequest, strategy: Object, packet: vector, amount: u64, max_loss: Option): Coin`: Withdraws the strategy's base asset (Coin) from a vault's strategy. Must be called with the vault's signer (typically via router). Uses vault's withdraw\_strategy\_shares function in the `satay::vault` module to withdraw strategy shares from vault's primary fungible stores. Then uses process\_withdrawal\_internal to redeem the strategy shares for the strategy's base asset (Coin). Requires a packet. * `tend_coin(account: &signer, strategy: Object, packet: vector)`: Deposits idle coins into the MovePosition market. * `vault_report(account: &signer, strategy: Object)`: Reports strategy performance to the vault by calling the report function in the `satay::vault` module. ## Internal Functions * `borrow_strategy(strategy: Object): &MovePositionStrategy`: Returns a reference to the strategy data. * `deposit_internal(strategy: &MovePositionStrategy, packet: vector, coin: Coin): FungibleAsset`: Internal function for Coin deposits. * `market_withdraw_internal(strategy_ref: &MovePositionStrategy, packet: vector, amount: u64): Coin`: Internal function for withdrawing Coin from market. Validates a packet using the internal validate\_ticket function, then calls the redeem function in `moveposition_block::moveposition_block` to redeem the shares for Coin. * `market_deposit_internal(strategy: &MovePositionStrategy, packet: vector, coin: Coin)`: Internal function for depositing coins to market. Validates a packet using the internal validate\_ticket function. First deposits the Coin to the strategy signer, , then calls the lend function in `moveposition_block::moveposition_block` to deposit the Coin into the market. * `validate_ticket(packet: vector, amount: u64, operation: String)`: Helper function to validate a ticket for market operations. Takes in a packet which is validated against the CoinType, amount and operation. * `process_withdrawal_internal(strategy: Object, packet: vector, shares_asset: FungibleAsset, max_loss: Option): Coin`: Internal function for processing withdrawals. Creates a withdrawal request with the provided shares and attempts base strategy withdrawal using the withdraw function in `satay::base_strategy`. If funds remain to be withdrawn, calculates needed amount and available collateral, then withdraws from market using market\_withdraw\_internal. Finally completes the withdrawal with specified loss tolerance using the complete\_withdrawal\_coin function in `satay::base_strategy` and returns the withdrawn Coin. * `prepare_withdrawal_internal(account: &signer, strategy: Object, amount: u64): FungibleAsset`: Internal function for preparing withdrawals. Withdraws and returns strategy shares from the signers account. * `get_collateral_for_shares(strategy_ref: &MovePositionStrategy, amount: u64): u64`: Calculates collateral value for given amount of shares. Retrieves the collateral balance and total shares to calculate the collateral value for a given amount using the function below: $$ \text{collateral\_value} = \frac{\text{amount} \times \text{collateral\_balance}}{\text{total\_shares}} $$