Symbiotic Protocol Default Collateral

https://github.com/symbioticfi/collateral
Admin
This repository provides a default implementation of Symbiotic's collateral token, which wraps...
Tokens:4,768
Snippets:28
Trust Score:7.1
License:MIT
Update:9 months ago
Show doc for...
Tokens:
Raw
### Complete Collateral Lifecycle Workflow (Solidity)

Source: https://context7.com/symbioticfi/collateral/llms.txt

This Solidity code demonstrates a comprehensive lifecycle of collateral management. It covers deploying a factory, creating a collateral contract, handling deposits and withdrawals for multiple users, issuing and tracking debt, and adjusting supply limits. This example requires a Solidity development environment with access to the specified token addresses and prank utilities.

```solidity
// 1. Deploy factory and create collateral
DefaultCollateralFactory factory = new DefaultCollateralFactory();
IERC20 dai = IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
address collateralAddr = factory.create(
    address(dai),
    10_000_000 * 1e18, // 10M DAI limit
    limitIncreaser
);
DefaultCollateral collateral = DefaultCollateral(collateralAddr);

// 2. Alice deposits 5000 DAI
vm.startPrank(alice);
dai.approve(address(collateral), 5000 * 1e18);
collateral.deposit(alice, 5000 * 1e18);
vm.stopPrank();

// 3. Bob deposits 3000 DAI for himself
vm.startPrank(bob);
dai.approve(address(collateral), 3000 * 1e18);
collateral.deposit(bob, 3000 * 1e18);
vm.stopPrank();

// 4. Alice issues 2000 DAI debt to a validator
vm.prank(alice);
collateral.issueDebt(validator, 2000 * 1e18);

// 5. Verify state
assert(collateral.balanceOf(alice) == 3000 * 1e18);
assert(collateral.balanceOf(bob) == 3000 * 1e18);
assert(collateral.totalSupply() == 6000 * 1e18);
assert(collateral.totalRepaidDebt() == 2000 * 1e18);
assert(dai.balanceOf(validator) == 2000 * 1e18);

// 6. Bob withdraws 1000 DAI
vm.prank(bob);
collateral.withdraw(bob, 1000 * 1e18);
assert(collateral.balanceOf(bob) == 2000 * 1e18);

// 7. Limit increaser expands supply cap
vm.prank(limitIncreaser);
collateral.increaseLimit(5_000_000 * 1e18);
assert(collateral.limit() == 15_000_000 * 1e18);
```

--------------------------------

### Create Default Collateral Factory and Instance (Solidity)

Source: https://context7.com/symbioticfi/collateral/llms.txt

Demonstrates deploying the DefaultCollateralFactory and creating a new collateral instance for a specified ERC-20 token. It sets an initial supply limit and designates a limit increaser role. The resulting collateral contract inherits decimal precision from the underlying asset.

```Solidity
// Deploy the factory
DefaultCollateralFactory factory = new DefaultCollateralFactory();

// Create a collateral for USDC with 1M initial limit and alice as limit increaser
address usdcToken = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
uint256 initialLimit = 1_000_000 * 1e6; // 1M USDC
address limitIncreaser = 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb;

address collateralAddress = factory.create(
    usdcToken,
    initialLimit,
    limitIncreaser
);

// The created collateral inherits decimals from the underlying asset
DefaultCollateral collateral = DefaultCollateral(collateralAddress);
```

--------------------------------

### Environment Configuration for Symbiotic Protocol

Source: https://github.com/symbioticfi/collateral/blob/main/README.md

This snippet shows the structure of the .env file required for setting up the Symbiotic Protocol environment. It includes essential RPC URLs and an optional Etherscan API key for network communication and verification.

```env
ETH_RPC_URL=
ETH_RPC_URL_HOLESKY=
ETHERSCAN_API_KEY=
```

--------------------------------

### Query Debt Tracking Data

Source: https://context7.com/symbioticfi/collateral/llms.txt

Retrieves comprehensive debt tracking data for monitoring collateral usage and slashing history across all participants.

```solidity
DefaultCollateral collateral = DefaultCollateral(collateralAddress);

// Alice issues debt to multiple recipients
collateral.issueDebt(recipient1, 100 * 1e6);
collateral.issueDebt(recipient2, 200 * 1e6);

// Bob also issues debt
vm.prank(bob);
collateral.issueDebt(recipient1, 150 * 1e6);

// Query global debt metrics
uint256 totalDebt = collateral.totalRepaidDebt(); // 450 * 1e6

// Query by issuer
uint256 aliceDebt = collateral.issuerRepaidDebt(alice); // 300 * 1e6
uint256 bobDebt = collateral.issuerRepaidDebt(bob); // 150 * 1e6

// Query by recipient
uint256 recipient1Debt = collateral.recipientRepaidDebt(recipient1); // 250 * 1e6
uint256 recipient2Debt = collateral.recipientRepaidDebt(recipient2); // 200 * 1e6

// Query specific issuer-recipient pair
uint256 aliceToRecipient1 = collateral.repaidDebt(alice, recipient1); // 100 * 1e6
uint256 bobToRecipient1 = collateral.repaidDebt(bob, recipient1); // 150 * 1e6
```

--------------------------------

### Build Command for Symbiotic Protocol

Source: https://github.com/symbioticfi/collateral/blob/main/README.md

This is a shell command used to build the Symbiotic Protocol project. It leverages the Forge build tool, commonly used in Ethereum development for compiling smart contracts and managing dependencies.

```shell
forge build
```

--------------------------------

### Gas Snapshot Command for Symbiotic Protocol

Source: https://github.com/symbioticfi/collateral/blob/main/README.md

This shell command generates gas snapshots for the Symbiotic Protocol's smart contracts. It helps in analyzing and optimizing gas usage during contract execution.

```shell
forge snapshot
```

--------------------------------

### Gasless ERC-20 Deposit with EIP-2612 Permit (Solidity)

Source: https://context7.com/symbioticfi/collateral/llms.txt

Illustrates depositing ERC-20 tokens using EIP-2612 permit signatures for gasless approvals. This method eliminates the need for a separate approval transaction by bundling the approval and deposit into a single transaction. It requires generating a signature off-chain.

```Solidity
// Using EIP-2612 permit (for tokens that support it)
uint256 amount = 1000 * 1e18;
uint256 deadline = block.timestamp + 1 hours;
uint256 nonce = IERC20Permit(permitToken).nonces(alice);

// Generate signature off-chain using alice's private key
bytes32 digest = keccak256(
    abi.encodePacked(
        "\x19\x01",
        IERC20Permit(permitToken).DOMAIN_SEPARATOR(),
        keccak256(abi.encode(
            PERMIT_TYPEHASH,
            alice,
            address(collateral),
            amount,
            nonce,
            deadline
        ))
    )
);
(uint8 v, bytes32 r, bytes32 s) = vm.sign(alicePrivateKey, digest);

// Deposit with permit in a single transaction
collateral.deposit(alice, amount, deadline, v, r, s);
```

--------------------------------

### Deposit with Permit

Source: https://context7.com/symbioticfi/collateral/llms.txt

Deposits underlying ERC-20 tokens using EIP-2612 permit signature for gasless approvals.

```APIDOC
## Deposit with Permit

### Description
Deposits underlying ERC-20 tokens using EIP-2612 permit signature for gasless approvals, eliminating the need for a separate approval transaction.

### Method
`POST`

### Endpoint
`/symbioticfi/collateral/{collateralAddress}/depositWithPermit`

### Parameters
#### Path Parameters
- **collateralAddress** (address) - Required - The address of the collateral contract.

#### Request Body
- **recipient** (address) - Required - The address that will receive the minted collateral tokens.
- **amount** (uint256) - Required - The amount of underlying ERC-20 tokens to deposit.
- **deadline** (uint256) - Required - The deadline for the permit signature.
- **v** (uint8) - Required - The recovery byte of the signature.
- **r** (bytes32) - Required - The r component of the signature.
- **s** (bytes32) - Required - The s component of the signature.

### Request Example
```json
{
  "recipient": "0x1234567890123456789012345678901234567890",
  "amount": "1000000000000",
  "deadline": "1678886400",
  "v": 1,
  "r": "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
  "s": "0xfedcba0987654321fedcba0987654321fedcba0987654321fedcba0987654321"
}
```

### Response
#### Success Response (200)
- **collateralTokensMinted** (uint256) - The amount of collateral tokens minted to the recipient.

#### Response Example
```json
{
  "collateralTokensMinted": "1000000000000"
}
```
```

--------------------------------

### Format Command for Symbiotic Protocol

Source: https://github.com/symbioticfi/collateral/blob/main/README.md

This command formats the codebase for the Symbiotic Protocol according to project standards. It uses Forge's formatting capabilities to maintain code consistency.

```shell
forge fmt
```

--------------------------------

### Create Default Collateral

Source: https://context7.com/symbioticfi/collateral/llms.txt

Creates a new default collateral wrapper for any ERC-20 token with an initial supply limit and optional limit increaser.

```APIDOC
## Create Default Collateral

### Description
Creates a new default collateral wrapper for any ERC-20 token with an initial supply limit and optional limit increaser.

### Method
`POST` (simulated - this is a contract deployment and interaction)

### Endpoint
`/symbioticfi/collateral/create`

### Parameters

#### Request Body
- **underlyingAsset** (address) - Required - The address of the ERC-20 token to be wrapped as collateral.
- **initialLimit** (uint256) - Required - The initial supply limit for the collateral.
- **limitIncreaser** (address) - Optional - The address of the role that can increase the supply limit. If not provided, the deployer might be the default or it needs to be set separately.

### Request Example
```json
{
  "underlyingAsset": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
  "initialLimit": "1000000000000",
  "limitIncreaser": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb"
}
```

### Response
#### Success Response (200)
- **collateralAddress** (address) - The address of the newly created collateral contract.

#### Response Example
```json
{
  "collateralAddress": "0xAbCdEf1234567890aBcDeF1234567890aBcDeF12"
}
```
```

--------------------------------

### Deposit ERC-20 Assets into Collateral Contract (Solidity)

Source: https://context7.com/symbioticfi/collateral/llms.txt

Shows how to deposit underlying ERC-20 tokens into a collateral contract and receive corresponding collateral tokens. The deposit is subject to the maximum supply limit. This snippet also illustrates depositing assets on behalf of another user and checking balances.

```Solidity
// Assuming alice has 1000 USDC and has approved the collateral contract
IERC20 usdc = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
DefaultCollateral collateral = DefaultCollateral(collateralAddress);

// Alice deposits 1000 USDC and receives collateral tokens
usdc.approve(address(collateral), 1000 * 1e6);
uint256 amountMinted = collateral.deposit(alice, 1000 * 1e6);

// Deposit on behalf of another user (bob receives collateral tokens)
usdc.approve(address(collateral), 500 * 1e6);
collateral.deposit(bob, 500 * 1e6);

// Check balances
uint256 aliceCollateral = collateral.balanceOf(alice); // 1000 * 1e6
uint256 bobCollateral = collateral.balanceOf(bob); // 500 * 1e6
```

--------------------------------

### Withdraw Collateral and Underlying Assets (Solidity)

Source: https://context7.com/symbioticfi/collateral/llms.txt

Demonstrates the process of withdrawing underlying assets by burning collateral tokens. This function allows users to exit their collateralized positions. The snippet includes verification of the withdrawal and checks the remaining collateral balance.

```Solidity
DefaultCollateral collateral = DefaultCollateral(collateralAddress);
IERC20 usdc = IERC20(underlyingAsset);

// Alice withdraws 500 USDC (burns 500 collateral tokens)
uint256 beforeBalance = usdc.balanceOf(alice);
collateral.withdraw(alice, 500 * 1e6);
uint256 afterBalance = usdc.balanceOf(alice);

// Verify withdrawal
assert(afterBalance - beforeBalance == 500 * 1e6);
assert(collateral.balanceOf(alice) == 500 * 1e6); // Remaining collateral

// Withdraw to a different recipient
collateral.withdraw(bob, 100 * 1e6); // Burns alice's tokens, sends to bob
```

--------------------------------

### Query Factory Collateral Entities

Source: https://context7.com/symbioticfi/collateral/llms.txt

Retrieves information about all collateral contracts created by the factory. This is used for tracking and verification purposes.

```solidity
DefaultCollateralFactory factory = DefaultCollateralFactory(factoryAddress);

// Create multiple collaterals
address collateral1 = factory.create(token1, 1_000_000e18, alice);
address collateral2 = factory.create(token2, 2_000_000e18, bob);
address collateral3 = factory.create(token3, 500_000e18, charlie);

// Query total entities
uint256 total = factory.totalEntities(); // 3

// Check if address is a valid entity
bool isValid = factory.isEntity(collateral1); // true
bool isInvalid = factory.isEntity(randomAddress); // false

// Iterate through all entities
for (uint256 i = 0; i < factory.totalEntities(); i++) {
    address collateralAddr = factory.entity(i);
    DefaultCollateral col = DefaultCollateral(collateralAddr);
    console.log("Collateral:", collateralAddr);
    console.log("Asset:", col.asset());
    console.log("Limit:", col.limit());
}
```

--------------------------------

### Test Command for Symbiotic Protocol

Source: https://github.com/symbioticfi/collateral/blob/main/README.md

This shell command executes tests for the Symbiotic Protocol. It utilizes the Forge testing framework to ensure the smart contracts function as expected.

```shell
forge test
```

--------------------------------

### Set Limit Increaser Role

Source: https://context7.com/symbioticfi/collateral/llms.txt

Transfers the limit increaser role to a new address. This operation can only be initiated by the current limit increaser, ensuring secure role management.

```solidity
DefaultCollateral collateral = DefaultCollateral(collateralAddress);

// Check current limit increaser
address currentIncreaser = collateral.limitIncreaser(); // alice

// Alice transfers the role to a multisig
address newIncreaser = 0x9876...;
vm.prank(alice);
collateral.setLimitIncreaser(newIncreaser);

// Verify role transfer
assert(collateral.limitIncreaser() == newIncreaser);

// Alice can no longer increase limit
vm.prank(alice);
vm.expectRevert(IDefaultCollateral.NotLimitIncreaser.selector);
collateral.increaseLimit(1000);

// New increaser can now manage limit
vm.prank(newIncreaser);
collateral.increaseLimit(1000); // Success
```

--------------------------------

### Deposit Assets

Source: https://context7.com/symbioticfi/collateral/llms.txt

Deposits underlying ERC-20 tokens into the collateral contract and mints collateral tokens to a recipient, subject to the maximum supply limit.

```APIDOC
## Deposit Assets

### Description
Deposits underlying ERC-20 tokens into the collateral contract and mints collateral tokens to a recipient, subject to the maximum supply limit.

### Method
`POST`

### Endpoint
`/symbioticfi/collateral/{collateralAddress}/deposit`

### Parameters
#### Path Parameters
- **collateralAddress** (address) - Required - The address of the collateral contract.

#### Request Body
- **recipient** (address) - Required - The address that will receive the minted collateral tokens.
- **amount** (uint256) - Required - The amount of underlying ERC-20 tokens to deposit.

### Request Example
```json
{
  "recipient": "0x1234567890123456789012345678901234567890",
  "amount": "1000000000000"
}
```

### Response
#### Success Response (200)
- **collateralTokensMinted** (uint256) - The amount of collateral tokens minted to the recipient.

#### Response Example
```json
{
  "collateralTokensMinted": "1000000000000"
}
```
```

--------------------------------

### Issue Debt using DefaultCollateral

Source: https://context7.com/symbioticfi/collateral/llms.txt

Burns collateral tokens and transfers underlying assets to a recipient, while recording debt history. This function is crucial for tracking slashing events and managing collateralized debt.

```solidity
DefaultCollateral collateral = DefaultCollateral(collateralAddress);
IERC20 usdc = IERC20(underlyingAsset);

// Alice issues 200 USDC of debt to a network operator
address networkOperator = 0x1234...;
uint256 debtAmount = 200 * 1e6;

uint256 beforeBalance = usdc.balanceOf(networkOperator);
collateral.issueDebt(networkOperator, debtAmount);
uint256 afterBalance = usdc.balanceOf(networkOperator);

// Verify debt issuance
assert(afterBalance - beforeBalance == debtAmount);
assert(collateral.balanceOf(alice) == 300 * 1e6); // Reduced by debt

// Check debt tracking
assert(collateral.totalRepaidDebt() == debtAmount);
assert(collateral.issuerRepaidDebt(alice) == debtAmount);
assert(collateral.recipientRepaidDebt(networkOperator) == debtAmount);
assert(collateral.repaidDebt(alice, networkOperator) == debtAmount);
```

--------------------------------

### Withdraw Collateral

Source: https://context7.com/symbioticfi/collateral/llms.txt

Burns collateral tokens and transfers the underlying asset to a recipient, enabling users to exit their collateral position.

```APIDOC
## Withdraw Collateral

### Description
Burns collateral tokens and transfers the underlying asset to a recipient, enabling users to exit their collateral position.

### Method
`POST`

### Endpoint
`/symbioticfi/collateral/{collateralAddress}/withdraw`

### Parameters
#### Path Parameters
- **collateralAddress** (address) - Required - The address of the collateral contract.

#### Request Body
- **recipient** (address) - Required - The address to which the underlying asset will be transferred.
- **amount** (uint256) - Required - The amount of collateral tokens to burn (and underlying asset to withdraw).

### Request Example
```json
{
  "recipient": "0x1234567890123456789012345678901234567890",
  "amount": "500000000000"
}
```

### Response
#### Success Response (200)
- **underlyingAssetWithdrawn** (uint256) - The amount of underlying asset successfully withdrawn.

#### Response Example
```json
{
  "underlyingAssetWithdrawn": "500000000000"
}
```
```

--------------------------------

### Increase Collateral Supply Limit

Source: https://context7.com/symbioticfi/collateral/llms.txt

Increases the maximum collateral total supply limit. This function is restricted to the designated limit increaser role to manage collateral expansion.

```solidity
DefaultCollateral collateral = DefaultCollateral(collateralAddress);

// Check current limit
uint256 currentLimit = collateral.limit(); // 1_000_000 * 1e6

// Limit increaser increases the limit by 500K USDC
uint256 increaseAmount = 500_000 * 1e6;
collateral.increaseLimit(increaseAmount);

// Verify new limit
uint256 newLimit = collateral.limit(); // 1_500_000 * 1e6
assert(newLimit == currentLimit + increaseAmount);

// Non-limit increaser cannot increase limit (reverts)
vm.prank(unauthorizedUser);
vm.expectRevert(IDefaultCollateral.NotLimitIncreaser.selector);
collateral.increaseLimit(100_000 * 1e6);
```
Tokens:
Raw