VELOCORE V2
V1 DocszkSyncEraLineaTelos
  • Introduction
  • Our Philosophy
    • Vision
    • Gas Optimization
    • General Bedrock for All Kinds of AMM
    • Epoch-less Predictability
    • Free Flowing Easy Vote System
  • DEX Innovation
    • Token Vault
      • Flashloan
    • Gas Saving Matters : Benchmark
    • AMM Flexibility
    • Multi In/Out Swap
    • Batch Swap
    • Adjustable Trading Fee Mechanics
    • Accumulating Swap Fees in LP Tokens
  • ve(3,3) Innovation
    • Removing 'Epoch' Systems
      • Bribe Optimization
    • Fungible Votes ($veVC)
      • No Decay & Easy Liquidation
    • Decentralized Gauge Deployment
    • Rebase Elimination
  • Security & Contract Address
    • zkSyncEra Contracts
    • Linea Contracts
    • Telos Contracts
    • V1 zkSyncEra (deprecated)
    • Three Rounds of Audits
  • Technical Docs
    • Concepts
    • Architecture Overview
      • Source Files Overview
    • How to interact with VELOCORE
      • Uniswap compatible interface
    • How to Read Data
    • Example Codes
      • Swap
      • Add liquidity
      • Stake
      • Voting
      • Multicall operations
      • cf) wrapper functions
    • Typescript Examples for Integration
    • Pool Specifics
      • Generalized CPMM
      • Wombat Stableswap
    • Events & Chart Integration
      • Getting a pair list
      • Interpreting Swap / LP events
    • Flashloan
  • zkSync Era
    • Migration Plan
      • $VC 1:1 Exchange
      • veNFT -> $veVC
      • One-Step LP Migration
      • Migration Schedule
      • Emission Migration
    • V2 Tokenomics
      • $VC Gauge
      • Bribe Mechanics
      • $veVC VOTING
    • Paymaster as a Service
  • Linea
    • Launch Details
      • Getting Ready
      • Bridging
      • V2 Launch Event
      • $LVC Presale
    • $LVC Tokenomics
      • $LVC Gauge
      • Bribe Mechanics
      • $veLVC VOTING
  • Telos
    • Launch Details
      • Getting Ready
      • Bridging
      • Launch Event
    • $TVC Tokenomics
      • $TVC Gauge
      • Bribe Mechanics
      • $veTVC VOTING
  • Free Loot Box for Future Airdrops
  • PASSPORT - F'air drops
  • Legal Disclaimer
  • Velocore Brand Assets
Powered by GitBook
On this page
  1. Technical Docs
  2. Example Codes

Swap

Let's Swap 0.1 USDC => ETH

Since this is the first section, I'm going to write it out in full, and from add liquidity on, I'm going to keep it simple and easy to understand.

**Always refer Example Codes to see what was the exact implementation of helper functions like toToken, toPoolId, toTokenInfo.


using TokenLib for Token;
/**
if you don't want to import Token lib, you could simply use this snippet instead for Token type conversion.

For ERC20, it's just a bytes32 left padded with 0.
For Eth(Native token), use 0xEEEE..E as token address.

type Token is bytes32;
function toToken(IERC20 tok) pure returns (Token) {
  return Token.wrap(bytes32(uint256(uint160(address(tok)))));
}
*/
IVault vault = IVault(0x1d0188c4B276A09366D05d6Be06aF61a73bC7535);

uint8 constant SWAP = 0;
uint8 constant GAUGE = 1;

uint8 constant EXACTLY = 0;
uint8 constant AT_MOST = 1;
uint8 constant ALL = 2;

function swapExample() external {
    address usdc = 0x176211869cA2b568f2A7D4EE941E073a821EE1ff;
    address vc = 0xcc22F6AA610D1b2a0e89EF228079cB3e1831b1D1;
    address eth = address(0);
    address usdc_eth_pool = vault.getPair(usdc, eth);
    address usdc_eth_lp = usdc_eth_pool;

    IERC20(usdc).approve(address(vault), type(uint256).max);
    // you can optimize gas by batching operations.
    // this example will execute them separately for clarity

    //swap usdc->eth
    /*
        Remember that Execute takes 3 params : Token[], deposit[], Op[].
        Let's construct them one by one. 
        First, deposit[] is rarely used, so you could just set it as a zero array with the same length as Token array.
    */

    //Step 1. Prepare Token array
    //2 tokens, USDC & ETH are involved in this swap.
    Token[] memory tokens = new Token[](2);

    //Token constant NATIVE_TOKEN = Token.wrap(0xEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE); //ref: lib/Token.sol
    tokens[0] = toToken(IERC20(usdc));
    tokens[1] = eth == address(0) ? NATIVE_TOKEN : toToken(IERC20(eth));// =NATIVE_TOKEN for eth

    //Step 2. Prepare Op array        
    /* struct VelocoreOperation {
        // 1byte optype(SWAP/STAKE/CONVERT/VOTE/handleUserBalance) + (11bytes 0 padding) + 20bytes related pool address
        bytes32 poolId;
        
        // 1byte index at Token[] above + 1 byte amount Type(exactly/at most/vitual balance)
        // + (14bytes padding)+ 16bytes int128 desiredAmount(=minimum Amt)
        bytes32[] tokenInformations;
        
        //usually empty. ""
        bytes data;
    } */
    
    // We are doing only one operation here. Swap. So op length is 1. 
    VelocoreOperation[] memory ops = new VelocoreOperation[](1);
    // optype==SWAP, pool=usdc_eth_pool
    ops[0].poolId = toPoolId(SWAP,usdc_eth_pool);

    ops[0].tokenInformations = new bytes32[](2);
    // Index for usdc is 0 at Token[], Exactly 0.1e6 USDC is used. pool receives USDC so amount is positive.
    ops[0].tokenInformations[0] = toTokenInfo(0x00,EXACTLY,0.1e6);
    // Index for eth is 1 at Token[]. We didn't set slippage here, but you could calculate the minimum amount and use the number instead of 0.
    // ETH is expected to flow out of the pool, so the sign of int128 should be negative. if the minimum amount you want is 0.1 eth, use int128(-0.1).
    // That's why it's called AT_MOST, not AT_LEAST.
    ops[0].tokenInformations[1] = toTokenInfo(0x01,AT_MOST,0);        
    ops[0].data = "";
    
    //Step 3. execute() !!
    return execute(tokens, new int128[](2), ops);
}

Last updated 1 year ago