# Welcome to Velo-Protocol
Welcome to Velo Protocol's documentation site. Here will help you get up to speed with Velo Protocol, from basic concepts to how to interact with Velo Protocol. No matter you are a developer, a trusted partner, or a blockchain enthusiast, you can learn how's Velo Protocol works here.
### What is Velo Protocol?
The Velo Protocol allows Trusted Partners to issue and manage digital credits used for financial services. Through a series of smart contracts, the value of these digital credits is stabilized and backed up by fiat currencies. The smart contracts are deployed on Evrynet that forks from Ethereum, and we add the characteristics of enterprise on it .For example , Evrynet makes Trusted Partners to transfer or issue digital currencies without the consumption of gas,and then Evrynet uses the BFT and PoS consensus that can ensure the characteristics of enterprise and security,also make Evrynet\`s tps more efficient than Ethereum, so Velo choose to use Evrynet instead of Ethereum,and Evrynet is an enterprise blockchain system built to support financial services.All digital credits are fully collateralized 1 to 1 by the VELO token. Velo tokens as well all digital credits are issued on the Stellar blockchain network. All settlement for these assets occurs on Stellar as well. Future releases intend to support additional collateralization options. VELO tokens and the digital credits are ordinary Stellar assets, subject to all the rules and semantics of all Stellar assets. Stellar’s platform provides the core layer 1 asset capabilities of transparent ledger accounting, fast/efficient settlement and high transactional throughput. Velo pairs Stellar together with Evrynet’s smart contract capabilities to provide formula based transaction processing, custom asset staking, collateralization level calculation and other advanced features. Velo’s smart contracts implemented on decentralized networks create a reliable, transparent and intelligent financial service platform. The Velo Protocol utilizes “Warp”, a cross-chain protocol, co-developed with Evrynet, to provide a bridge between two different blockchains. It connects Stellar, designed for real-time, reliable digital assets movement and Velo’s Smart Contract Chain, which provides the ability to deploy and execute smart contracts. These components are used to build the Digital Reserve System which stabilizes the value of VELO and its digital credits.
To issue a price-stable credit in Velo protocol, the trusted partner must have **VELO** token available in their account. In the Testnet phase, VELO is obtainable via faucet. In Mainnet, VELO is obtainable via one of the following channels:
# Prerequisite
What to do before you can use Velo?
## To use Velo you should
1. Have `git` installed - Instruction on how to install can be found [here](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
2. Have `go` installed - Instruction on how to install can be found [here](https://golang.org/doc/install)
## System Requirements
Any modern computer should be able to run CLI and use SDK to interact with Velo
Recommended Operating System:
* Ubuntu 18.04 LTS x86-64
* macOS
Experimentally Supported System:
* Windows x86-64
# Architecture
The core of Velo Protocol is the Digital Reserve System (DRS). DRS consists of 4 main smart contracts.
## **1. Heart**
It is a state storage smart contract,some data is stored here,this way make the data is credible
## 2. Digital Reserve System
It creates digital currency,issues digital credit,and redeems staked Velo tokens.It also rebalances staked Velo tokens.
## **3.** Reserve Manager
It is a reserve pool to rebalance velo in staking address
## 4. Stable Credit
It is used as an token collateral pool and is also the digital credit\`s smart contract
# DRS Mechanism
The Digital Reserve System will algorithmically rebalance the VELO token Collateral Pools backing the issued digital credit to maintain a 1:1 value link between the digital credit and the VELO token and the original fiat deposit. When a Trusted Partner received a fiat deposit from a end user, they then engage the Velo Protocol to generate a digital credit by posting and locking an equivalent value of VELO tokens via the Velo Protocol. The DRS then tracks these pooled tokens by assigning them to a collateral pool that is linked with the digital credit issued and adjusting the amount of tokens in the pool at any given time to maintain the value at initial issuance. At the time of creation, the value of the digital credit equals the value of VELO tokens deposited as well as the fiat original deposited with the Trusted Partner. After this period, however, the price of VELO tokens will naturally fluctuate on the open market as a function of supply and de- mand. In response, the DRS will automatically rebalance the amount of VELO tokens in the Col- lateral Pool to maintain the 1:1 value link with the value of digital credits created. If the price of VELO tokens goes up, then VELO tokens will be removed from the Collateral Pool and returned to the Reserve Pool. This action reduces the number of tokens in the Collateral Pool to maintain 1:1 link between collateral value and digital credit value. If the price of Velo Token goes down relative to the digital credit, then the DRS will add VELO tokens to the Collateral Pool from the Reserve Pool, to maintain the value link of collateral value and digital credit value.
{% content-ref url="/pages/-MHzC8Oh-UM9u4sDRfKp" %}
[Setup stable credit](/base-concepts/setup-stable-credit)
{% endcontent-ref %}
{% content-ref url="/pages/-MHzGy2lmkajgJtMK-wo" %}
[Mint stable credit](/base-concepts/mint-stable-credit)
{% endcontent-ref %}
{% content-ref url="/pages/-MHzHn0KE2KYaOYjiuID" %}
[Redeem stable credit](/base-concepts/redeem-stable-credit)
{% endcontent-ref %}
{% content-ref url="/pages/-MHzIor6rHfL7uDAYSqm" %}
[Rebalancing the Reserve and Collateral Pool](/base-concepts/rebalancing-the-reserve-and-collateral-pool)
{% endcontent-ref %}
# Setup stable credit
In the DRS, Trusted Partners follow the specified workflow to create new types of stable credit that can are pegged to a fiat currency. Stable credits are tied to and controlled by the original issuing Trusted Partner.
The information required is:
1\. The name of the stable credit
2\. The fiat currency which the digital credit is pegged to
3\. The pegged value of the stable credit to the fiat currency
4\. The collateral asset
## Workflow
# Mint stable credit
After the setup process is completed, the Trusted Partner will be able to mint the digital credit. The DRS will be responsible for calculating and deducting the amount of credit required.
## Information required
1\. Asset code of the digital credit to be minted.
2\. Amount of collateral staked or Amount of digital credit to be minted. (Depending on which function is used)
## Workflow
# Redeem stable credit
## Anyone who owns digital credit issued by a Velo associated TP can redeem their digital credit for VELO.Two pieces of information are needed to redeem:
1. Asset code (digital credit name)
2. Amount to be exchanged
## Upon redemption, the amount of VELO that can be exchanged will be calculated based on:
1. The amount of digital credit.
2. The current exchange rate between the pegged currency of the fiat credit,VELO and pegged value.
3. The collateral ratio of the collateral backing the digital credit.
The formula used for calculation is similar to the one we use for mint, but there is no fee involved (i.e. fee = 0):
## Workflow
# Rebalancing the Reserve and Collateral Pool
Collateral asset values may change every day. As a result, collateralization levels will increase and decrease. The DRS continually checks the collateral health and transfers tokens between the collateral and reserve pools to maintain a consistent level of collateralization.
## Logic
### 1. run the collateral health check to determine the amount of mismatch for the specified stable credit.
● If there are no mismatched amounts then no rebalancing is required.
### 2. If a mismatch is detected, then initiate transfer between the Collateral and the Reserve pool to ensure that the amount of collateral in the Token Collateral Pool is always in line with the amount of collateral required.
● If the amount of collateral in the Collateral account exceeds the required amount, DRS executes a payment operation to return the excess collateral to the Token Reserve Pool.
● If the amount of collateral in the Token Collateral Pool is less than the required amount, DRS executes a payment operation to get the missing collateral from the Token Reserve Pool.
## Workflow
# Using CLI
Trying out Velo protocol with CLI
## To use CLI
{% hint style="info" %}
Velo does not keep your account on the server. The account record only exists on your computer.
{% endhint %}
If you have completed the complete walkthrough section then you will not need to do any set up here. If not, please follow the instruction in complete walkthrough
## Account-related commands in CLI
{% hint style="info" %}
Unlike in SDK, CLI will submit all your operations to Evrynet (when required). This is possible since the CLI has access to your secret key which is encrypted using your passphrase in your local storage.
{% endhint %}
Aside from commands to do with stable credits, we have additional commands for account operations.
### Create an account
`gvel account create`
This command creates an account on Evrynet Testnet, fund the created account with 10,000 XLM and stores the credentials in local storage that was set up using `gvel init`.
### Import an account
`gvel account import`
Import an existing account to gvel. The account should already exists in Evrynet Testnet chain. The account is added to gvel locally. The command will ask for your secret key.
### Assign default account
`gvel account default`
Set an account in gvel as a default account for executing other commands. The account is added using public key.
### List all accounts in gvel
`gvel account list`
List all accounts in local storage. This command shows all accounts regardless whether they are added via creation or import. Only the public keys are shown.
### Export credentials from gvel
`gvel account export`
Output account public and private key pair to the command line. In order to do so, you will be asked to input your passphrase to decrypt the key pair.
# Setup table credit
## Parameters
{% hint style="info" %}
In Testnet, we only support 3 currencies; SGD, THB and USD
{% endhint %}
| Name | Description | Required? | Validation |
| ---------------- | ------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------- |
| `assetCode` | The name of your custom asset. | Yes | - Unique for trusted partner.
- Correct format (1-7 alphanumeric characters).
|
| `peggedCurrency` | The currency you want to pegged this asset to. | Yes | - Must be in \[SGD, THB, USD].
|
| `peggedValue` | The ratio of currency value vs 1 unit of custom asset. | Yes | - Must be a positive number greater than 0 and has less than or equal to 7 decimal places.
|
{% tabs %}
{% tab title="CLI" %}
```
$ gvel credit setup
Please input asset code: vTHB
Please input pegged value: 1
Please input pegged currency: THB
🔑 Please input passphrase: ****
💖 Setting up stable credit
// Where GB... is the default account
Stable credit vTHB set up for account GB... successfully.
🔗 txHash is ${txHash}
```
{% endtab %}
{% endtabs %}
## What's next?
Now that you have set up your stable credit, go to Mint stable credit to mint it into existence!
# Mint stable credit
## Parameters
| Name | Description | Required? | Validation |
| --------------------- | --------------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------- |
| `assetCodeToBeIssued` | The asset code of price-stable credit that you want to mint. | Yes | - Already been setup
- Correct format (1-7 alphanumeric characters)
|
| `collateralAmount` | The amount of collateral that you which to exchange into the stable credit. | Yes | - Must be a positive number greater than 0 and has less than or equal to 7 decimal places
|
{% tabs %}
{% tab title="CLI" %}
```
$ gvel credit mint-by-collateral
Please input asset code of credit to be minted: vTHB
Please input amount of collateral: 100
🔑 Please input passphrase: ****
💖 Minting stable credit
100 vTHB minted successfully. The stable credit is in GF...
🔗 txHash is ${txHash}
```
{% endtab %}
{% endtabs %}
## What's next?
You now have stable credit. Play around with it! When you are ready, you can redeem the collateral back.
# Redeeming stable credit
## Parameters
| Name | Description | Required? | Validation |
| ----------- | ------------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------- |
| `assetCode` | The asset code of price-stable credit that you want to redeem. | Yes | - Already been setup
- Correct format (1-7 alphanumeric characters)
|
| `issuer` | The issuing account of the stable credit to be redeem. | Yes | - Stellar account format
- Issuing account of stable credit created in Velo system
|
| `amount` | The amount of stable credit you which to exchange into VELO token. | Yes | - Must be a positive number greater than 0 and has less than or equal to 7 decimal places
|
{% tabs %}
{% tab title="CLI" %}
```
$ gvel credit redeem
Please input amount of stable credit: 1000
Please input asset code of credit to be redeemed : vTHB
🔑 Please input passphrase: ****
💖 Redeeming vTHB
Redeem successfully. You got XX VELO.
🔗 txHash is ${txHash}
```
{% endtab %}
{% endtabs %}
## What's next?
You have now completed the flow of stable credit. Let's take a look at the price stablisation mechanism.
# Rebalancing the Reserve and Collateral Pool
{% tabs %}
{% tab title="CLI" %}
```
$ gvel collateral rebalance
🔑 Please input your passphrase: ****
💖 Rebalancing the Collateral and Reserve pool
Rebalancing completed.
🔗 txHash is ${txHash}
```
{% endtab %}
{% endtabs %}
## What's next?
That's it! If you have gone through this document step-by-step from setup through to rebalance, you have mastered Velo.
# Using SDK
Using Go SDK in your project
When using SDK, the client will make a request to Velo Node and response with a Evrynet Transaction. The SDK will then submit it to Evrynet.
{% hint style="info" %}
At the moment, only have SDK available for Go Lang
{% endhint %}
### Initialisation
Import the SDK into your project path.
```
github.com/velo-protocol/DRSv2_Evrynet/vclient
```
```go
package main
import "github.com/velo-protocol/DRSv2_Evrynet/vclient"
func main() {
// ...
// Init Velo SDK client
client, err := vclient.NewClient("", "", ContractAddress{
DrsAddress: "",
HeartAddress: "",
})
if err != nil {
log.Println(err)
return
}
defer func() {
_ = client.Close()
}()
// ...
}
```
# Setup stable credit
Inception of price stable credit
## Parameters
{% hint style="info" %}
In Testnet, we only support USD,SGD and THB
{% endhint %}
| Name | Description | Required? | Validation |
| ----------------------- | ------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------- |
| �`CollateralAssetCode`� | The collateral asset code | Yes | collateral asset code must be in collateralAssets |
| `assetCode` | The name of your custom asset. | Yes | - Unique for trusted partner.
- Correct format (1-7 alphanumeric characters).
|
| `peggedCurrency` | The currency you want to pegged this asset to. | Yes | - Must be in \[SGD, THB, USD].
|
| `peggedValue` | The ratio of currency value vs 1 unit of custom asset. | Yes | - Must be a positive number greater than 0 and has less than or equal to 7 decimal places.
|
{% tabs %}
{% tab title="GO SDK" %}
```go
package main
import (
"context"
"github.com/velo-protocol/DRSv1/libs/vclient"
"log"
)
func main() {
client, err := vclient.NewClient("", "", ContractAddress{
DrsAddress: "",
HeartAddress: "",
})
if err != nil {
panic(err)
}
output, err := client.SetupCredit(context.Background(), &SetupCreditInput{
CollateralAssetCode: "VELO",
PeggedCurrency: "USD",
AssetCode: "vUSD",
PeggedValue: "1.0",
})
if err != nil {
panic(err)
}
log.Println("Transaction Hash: ", output.Tx.Hash().String())
log.Println("Block Number: ", output.Receipt.BlockNumber.String())
log.Println("Event.PeggedCurrency: ", output.Event.PeggedCurrency)
log.Println("Event.PeggedValue: ", output.Event.PeggedValue)
log.Println("Event.AssetCode: ", output.Event.AssetCode)
log.Println("Event.CollateralAssetCode: ", output.Event.CollateralAssetCode)
log.Println("Event.AssetAddress: ", output.Event.AssetAddress)
}
```
{% endtab %}
{% endtabs %}
## What's next?
Now that you have set up your stable credit, go to Mint price-stable credit to mint it into existence!
# Mint stable credit
Mint the stable credit you set up
## Parameters
| Name | Description | Required? | Validation |
| ------------------ | --------------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------- |
| `AssetCode` | The name of your custom asset. | Yes | - Unique for trusted partner.
- Correct format (1-7 alphanumeric characters).
|
| `collateralAmount` | The amount of collateral that you which to exchange into the stable credit. | Yes | - Must be a positive number greater than 0 and has less than or equal to 7 decimal places
|
{% tabs %}
{% tab title="GO SDK" %}
```go
package main
import (
"context"
"github.com/velo-protocol/DRSv2_Evrynet/libs/vclient"
"log"
)
func main() {
client, err := vclient.NewClient("", "", ContractAddress{
DrsAddress: "",
HeartAddress: "",
})
if err != nil {
panic(err)
}
result, err := client.MintFromCollateralAmount(context.Background(), &MintFromCollateralAmountInput{
AssetCode: "vUSD",
CollateralAmount: "100",
})
if err != nil {
panic(err)
}
log.Println("Mint From Collateral Amount Transaction Hash: ", result.Tx.Hash().String())
log.Println("Asset Address: ", result.Event.AssetAddress)
log.Println("Asset Code: ", result.Event.AssetCode)
log.Println("Collateral Amount: ", result.Event.CollateralAmount)
log.Println("Collateral Asset Code: ", result.Event.CollateralAssetCode)
log.Println("Stable Credit Amount: ", result.Event.StableCreditAmount)
}
```
{% endtab %}
{% endtabs %}
## What's next?
You now have stable credit. Play around with it! When you are ready, you can redeem the collateral back.
# Redeeming stable credit
## Parameters
| Name | Description | Required? | Validation |
| -------------- | ------------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------- |
| `assetCode` | The asset code of price-stable credit that you want to redeem. | Yes | - Already been setup
- Correct format (1-7 alphanumeric characters)
|
| `RedeemAmount` | The amount of stable credit you which to exchange into VELO token. | Yes | - Must be a positive number greater than 0 and has less than or equal to 7 decimal places
|
{% tabs %}
{% tab title="GO SDK" %}
```go
package main
import (
"context"
"github.com/velo-protocol/DRSv2_Evrynet/libs/vclient"
"log"
)
func main() {
client, err := vclient.NewClient("", "", ContractAddress{
DrsAddress: "",
HeartAddress: "",
})
if err != nil {
panic(err)
}
result, err := client.RedeemStableCredit(context.Background(), &RedeemStableCreditInput{
RedeemAmount: "1000",
AssetCode: "vUSD",
})
if err != nil {
panic(err)
}
log.Println("Redeem Stable Credit Transaction Hash: ", result.Tx.Hash().String())
log.Println("Asset Code: ", result.Event.AssetCode)
log.Println("Stable Credit Amount: ", result.Event.StableCreditAmount)
log.Println("Collateral Asset Address: ", result.Event.CollateralAssetAddress)
log.Println("Collateral Asset Code: ", result.Event.CollateralAssetCode)
log.Println("Collateral Amount: ", result.Event.CollateralAmount)
}
```
{% endtab %}
{% endtabs %}
## What's next?
You have now completed the flow of stable credit. Let's take a look at the price stablisation mechanism.
# Rebalancing the Reserve and Collateral Pool
{% tabs %}
{% tab title="GO SDK" %}
```go
package main
import (
"context"
"github.com/velo-protocol/DRSv2_Evrynet/libs/vclient"
"log"
)
func main() {
client, err := vclient.NewClient("", "", ContractAddress{
DrsAddress: "",
HeartAddress: "",
})
if err != nil {
panic(err)
}
output, err := client.Rebalance(context.Background(), &RebalanceInput{})
if err != nil {
panic(err)
}
for index, rebalanceTransaction := range output.RebalanceTransactions {
fmt.Printf("Event %d Transaction Hashes: %s", index, rebalanceTransaction.Tx.Hash().String())
fmt.Printf("Event %d Transaction Receipt: %d", index, rebalanceTransaction.Receipt.Status)
fmt.Printf("Events %d AssetCode: %s", index, rebalanceTransaction.AssetCode)
fmt.Printf("Events %d CollateralAssetCode: %s", index, rebalanceTransaction.CollateralAssetCode)
fmt.Printf("Events %d PresentAmount: %s", index, rebalanceTransaction.PresentAmount)
fmt.Printf("Events %d RequiredAmount: %s", index, rebalanceTransaction.RequiredAmount)
}
}
```
{% endtab %}
{% endtabs %}
## What's next?
That's it! If you have gone through this document step-by-step from setup through to rebalance, you have mastered Velo.