Oyl AMM

https://docs.oyl.io/
Admin
Oyl AMM is a decentralized exchange protocol built on Bitcoin using the Alkanes metaprotocol,...
Tokens:38,391
Snippets:133
Trust Score:6.5
Update:1 year ago
Show doc for...
Tokens:
Raw
### Create New Oyl Wallet

Source: https://docs.oyl.io/getting-started/setup-your-wallet

Outlines the steps to create a new Oyl Wallet after installation. This involves launching the extension, initiating wallet creation, and setting a password.

```text
Step 1.1: Click the **Oyl Wallet** icon in your browser toolbar to launch the extension.
Step 1.2: Click **Create New Wallet**.
Step 1.3: Set a secure password when prompted.
```

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

### Example Flash Swap Contract

Source: https://docs.oyl.io/developer/guides/flash-swaps

This snippet links to an external GitHub repository containing an example contract for developing flash swaps with the Oyl AMM protocol. It serves as a practical reference for implementing flash swap strategies.

```link
https://github.com/hudeintres/alkanes-amm-flashswap-example
```

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

### Oyl Wallet Permissions

Source: https://docs.oyl.io/getting-started/setup-your-wallet

Explains the permissions required by the Oyl Wallet extension during installation. It assures users that the wallet is non-custodial and has been audited for security.

```text
When installing Oyl Wallet, Chrome will show a permissions warning. **You must accept these permissions to continue.**
  * This is standard for all wallet extensions and is required to connect to dapps.
  * **Oyl Wallet is 100% non-custodial** — only you control your keys. We cannot access your funds or personal data.
  * Oyl Wallet has been independently audited by **Halborn** for your safety and peace of mind.
```

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

### Download Oyl Wallet

Source: https://docs.oyl.io/getting-started/setup-your-wallet

Provides the link to download the Oyl Wallet browser extension from the Chrome Web Store. This wallet is required for the Oyl AMM on OylNet.

```html
<a href="https://chromewebstore.google.com/detail/oyl-wallet-bitcoin-ordina/ilolmnhjbbggkmopnemiphomhaojndmb">Click here to download Oyl Wallet for Chrome</a>
```

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

### Oyl.io Usage Examples

Source: https://docs.oyl.io/developer/reference/api

Demonstrates how to perform common operations like basic swaps and adding liquidity using Oyl.io's smart contracts, including slippage tolerance and deadline settings.

```APIDOC
Basic Swap:
  // Swap 100 Token A for Token B with 1% slippage tolerance
  let path = vec![token_a_id, token_b_id];
  let min_output = expected_output * 99 / 100; // 1% slippage

  let result = factory.call(AMMFactoryMessage::SwapExactTokensForTokens {
    path,
    amount_out_min: min_output,
    deadline: current_time + 300, // 5 minutes
  })?;

Add Liquidity:
  // Add liquidity with 0.5% slippage tolerance
  let min_a = amount_a_desired * 995 / 1000;
  let min_b = amount_b_desired * 995 / 1000;

  let result = factory.call(AMMFactoryMessage::AddLiquidity {
    token_a: token_a_id,
    token_b: token_b_id,
    amount_a_desired,
    amount_b_desired,
    amount_a_min: min_a,
    amount_b_min: min_b,
    deadline: current_time + 600, // 10 minutes
  })?;
```

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

### Backup Oyl Wallet Seed Phrase

Source: https://docs.oyl.io/getting-started/setup-your-wallet

Details the critical step of backing up the seed phrase for the Oyl Wallet. Users are instructed to write down the phrase and store it securely, never sharing it.

```text
Step 2.1: Write down your seed phrase and store it in a safe place.
Step 2.2: Never share your seed phrase with anyone.
```

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

### Create Pool with OYL SDK

Source: https://docs.oyl.io/developer/guides/examples

Creates a new liquidity pool on the OYL AMM. Requires factory proxy deployment ID, token pair details, input amounts, network, and fee rate.

```bash
oyl alkane create-pool -data 4,65522,1,2,201,2,200,1000,2000 -tokens "2:201:1000,2:200:2000" -p signet -feeRate 3  
```

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

### Simple Price Query Example

Source: https://docs.oyl.io/developer/core-concepts/oracles

An example of querying reserves from an AMM pool and calculating the price. This snippet illustrates a common integration pattern for price oracles.

```javascript
// Get current reserves and calculate price  
let(reserve_a, reserve_b)= pool.call(AMMPoolMessage::GetReserves)?;
let price = reserve_b *PRECISION/ reserve_a;
```

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

### Swap Exact Tokens for Tokens with OYL SDK

Source: https://docs.oyl.io/developer/guides/examples

Executes a token swap on the OYL AMM, exchanging an exact amount of input tokens for a minimum amount of output tokens. Includes transaction expiry.

```bash
oyl alkane swap -data 4,65522,13,2,2,201,2,200,500,450,950000 -tokens "2:201:500" -p signet -feeRate 3  
```

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

### Oyl AMM Oracle Integration and Usage

Source: https://docs.oyl.io/developer/core-concepts/oracles

Guides developers on how to integrate and utilize the Oyl AMM's price oracles, including examples for querying current prices and calculating TWAP.

```APIDOC
Using Oyl AMM Price Oracles:
  Reading Current Price:
    - Method: How to fetch the latest available price feed.
    - Example: Simple Price Query implementation details.
  Calculating TWAP:
    - Method: Steps and parameters required to compute TWAP.
    - Example: TWAP Calculation implementation details.
  Converting Price Formats:
    - Integer Conversion: Method for converting price data to integer format.
    - Decimal Conversion: Method for converting price data to decimal format, maintaining precision.
```

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

### Calculate Swap Output Example

Source: https://docs.oyl.io/developer/smart-contracts/library

Demonstrates how to calculate the expected output amount for a given input amount of token A in a liquidity pool, using Oyl's AMM functions.

```rust
// Calculate expected output for 100 token A
let (reserve_a, reserve_b) = get_reserves(token_a, token_b);
let output = get_amount_out(100_000_000, reserve_a, reserve_b);
println!("Expected output: {}", output);
```

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

### Oyl Wallet Receive Functionality

Source: https://docs.oyl.io/product/receive

This section details the user interface and steps for receiving funds using Oyl Wallet. It covers selecting between Segwit and Taproot addresses and sharing the address with the sender.

```APIDOC
Receive Tab:
  - Access: Click the "Receive" button in the Portfolio section.
  - Address Types:
    - Segwit Address:
      - Purpose: Receive Bitcoin (BTC).
      - Compatibility: Compatible with most Bitcoin wallets and exchanges.
    - Taproot Address:
      - Purpose: Receive Ordinals, BRC-20, Runes, and Alkanes tokens.
      - Requirement: Required for advanced Bitcoin assets and smart contracts.
  - Actions:
    - Switch Address Type: Easily toggle between Segwit and Taproot addresses.
    - Copy Address: Use the "Copy" button to copy the selected address.
    - Share Address: Provide the copied address to the sender.
  - Monitoring: Monitor your portfolio for incoming transactions.

Usage Tip:
  - Always double-check the asset type and use the corresponding address (Alkanes to Taproot, Bitcoin to Segwit).
```

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

### TWAP Calculation Example

Source: https://docs.oyl.io/developer/core-concepts/oracles

Provides a practical example of calculating a 1-hour TWAP by fetching historical cumulative price data. This demonstrates the application of TWAP calculation in a real-world scenario.

```javascript
// Calculate 1-hour TWAP  
let current_time =get_current_timestamp();
let hour_ago = current_time -3600;
  
let(cumulative_now, _)= pool.call(AMMPoolMessage::GetPriceCumulativeLast)?;
let(cumulative_hour_ago, _)=get_historical_cumulative(hour_ago);
  
let twap =(cumulative_now - cumulative_hour_ago)/3600;
```

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

### Swap Tokens for Exact Tokens CLI Command

Source: https://docs.oyl.io/developer/guides/examples

This command facilitates swapping a variable amount of input tokens for a precisely defined quantity of output tokens. It requires specifying the factory proxy ID, input and output token details, the desired output amount, and the transaction's expiry block height. The command assumes the factory proxy is deployed at a given ID and allows setting a fee rate.

```oyl
oyl alkane swap -data 4,65522,14,2,2,201,2,200,500,550,950000 -tokens "2:201:550" -p signet -feeRate 3
```

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

### GetPriceCumulativeLast Rust Example

Source: https://docs.oyl.io/developer/reference/api

Example of how to process the response from the GetPriceCumulativeLast RPC call in Rust. It demonstrates converting byte data to U256 and printing the integer and decimal portions of the prices.

```rust
useruint::Uint;
pubtypeU256=Uint<256,4>;

// Create a storage wrapper for U256 to implement ByteView
#[derive(Clone, Copy, PartialEq, Eq)]
pubstructStorableU256(pubU256);

implByteViewforStorableU256{
fnfrom_bytes(v:Vec<u8>)->Self{
assert!(v.len()==32,"Expected a byte vector of length 32.");
// Convert bytes to U256 using from_le_bytes
letmut bytes_array =[0u8;32];
        bytes_array.copy_from_slice(&v);
StorableU256(U256::from_le_bytes(bytes_array))
}

fnto_bytes(&self)->Vec<u8>{
self.0.to_le_bytes::<32>().to_vec()
}

fnmaximum()->Self{
StorableU256(U256::MAX)
}

fnzero()->Self{
StorableU256(U256::ZERO)
}
}

implFrom<U256>forStorableU256{
fnfrom(value:U256)->Self{
StorableU256(value)
}
}

implFrom<StorableU256>forU256{
fnfrom(value:StorableU256)->Self{
        value.0
}
}

// assuming data is the response from the rpc from calling GetPriceCumulativeLast
let p0:U256=StorableU256::from_bytes(data[0..32].to_vec()).into();
let p1:U256=StorableU256::from_bytes(data[32..64].to_vec()).into();

println!(
"{:} {:?}",
    p0 >>U256::from(PRECISION),// integer portion
    p0 &U256::from(u128::MAX)// decimal portion
);
println!(
"{:} {:?}",
    p1 >>U256::from(PRECISION),// integer portion
    p1 &U256::from(u128::MAX)// decimal portion
);

```

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

### Add Liquidity with OYL SDK

Source: https://docs.oyl.io/developer/guides/examples

Adds liquidity to an existing OYL AMM pool. Specifies pool details, input token amounts, minimum output amounts, and transaction expiry block height.

```bash
oyl alkane add-liquidity -data 4,65522,11,2,201,2,200,1000,2000,100,200,950000 -tokens "2:201:1000,2:200:2000" -p signet -feeRate 3  
```

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

### Oyl Pool Liquidity Management Steps

Source: https://docs.oyl.io/product/pool

This section details the user workflow for adding liquidity to Oyl pools. It covers opening the pools tab, selecting a pool, creating a new position, confirming the transaction in the wallet, and the success message upon completion.

```text
1. Open the Pools Tab
   Navigate to the "Pool" section in the Oyl app. Use the "My Wallet" filter to see pools compatible with your current assets.

2. Drill Down Into a Pool
   Click on a pool to view its detailed statistics, including liquidity, composition, APY, and your existing positions and rewards.

3. Create a New Position
   Click "Create Position" to begin adding liquidity. Select your tokens and specify the amounts.

4. Confirm in Your Wallet
   After setting amounts and confirming, sign the transaction in your connected wallet.

5. Success!
   Upon transaction confirmation, a success message will appear, and your new position will be visible in the pool. You can monitor, withdraw, or claim rewards from the Pools tab.
```

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

### Oyl Platform Portfolio Features

Source: https://docs.oyl.io/portfolio

This section outlines the key functionalities and information presented within the Oyl platform's Portfolio feature. It details how users can view their total asset value, track performance metrics, manage individual tokens, and access essential functions like sending, receiving, and utilizing the Oylnet BTC Faucet.

```APIDOC
Portfolio Overview:
  - Total portfolio value in USD
  - Performance metrics (percentage change, amount gained/lost)
  - Quick Action Buttons: Send, Receive, Oylnet BTC Faucet

Token Management:
  - Displays token icon, name, current value (USD), balance, and price per token
  - Functionality to view detailed token information
  - Filtering and searching capabilities for tokens

Oylnet BTC Faucet:
  - Used for requesting test BTC in the Oylnet testing environment
  - Test BTC appears in the portfolio after request
  - Emphasizes that Oylnet uses test assets and no real money.
```

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

### Oyl AMM Integration Guide

Source: https://docs.oyl.io/developer/smart-contracts

This section outlines the primary methods for integrating with the Oyl AMM. It details the sequence of interactions, from discovering or creating pools via the Factory contract to executing swaps directly with Pool contracts and utilizing Library functions for calculations.

```APIDOC
Integration with Oyl AMM:

1. Factory Contract Interaction:
   - Purpose: Discover existing liquidity pools or create new ones.
   - Methods: `getPool(tokenA, tokenB)`, `createPool(tokenA, tokenB)`

2. Pool Contract Interaction:
   - Purpose: Execute token swaps within a specific liquidity pool.
   - Methods: `swap(recipient, amountIn, amountOutMin, path, fee, sqrtPriceLimitX96)`

3. Library Functions:
   - Purpose: Perform complex price calculations and utility functions.
   - Examples: `getQuote(amountIn, reserveIn, reserveOut)`, `getAmountOut(amountIn, reserveIn, reserveOut)`

4. Custom Routing:
   - Purpose: Develop logic for multi-pool trades to optimize execution.
```

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

### Multi-hop Swap Calculation Example

Source: https://docs.oyl.io/developer/smart-contracts/library

Illustrates how to calculate the output amount for a multi-hop swap involving a path of tokens (e.g., A -> B -> C). It uses the get_amounts_out function to determine the final output.

```rust
// Calculate output for A -> B -> C swap
let path = vec![token_a, token_b, token_c];
let amounts = get_amounts_out(100_000_000, path);
println!("Final output: {}", amounts[amounts.len() - 1]);
```

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

### Remove Liquidity with OYL SDK

Source: https://docs.oyl.io/developer/guides/examples

Removes liquidity from an OYL AMM pool. Requires pool deployment ID, LP token amount to liquidate, minimum received amounts for each token, and transaction expiry.

```bash
oyl alkane remove-liquidity -data 4,65522,11,2,201,2,200,1000,100,200,950000  -tokens "2:300:1000" -p signet -feeRate 3  
```

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

### Oyl Corp Projects Overview

Source: https://docs.oyl.io/getting-started/welcome

This section lists the key open-source projects developed by Oyl Corp, highlighting their role in building on the Bitcoin protocol.

```APIDOC
Projects:
  Sandshrew:
    Description: A unified RPC for building on Bitcoin.
  Metashrew:
    Description: A WASM indexing stack for building metaprotocols on Bitcoin.
  Protorunes:
    Description: A framework to build programmable subprotocols of Runes.
  Alkanes:
    Description: A smart contract metaprotocol for Bitcoin L1.
  Oyl Wallet:
    Description: A consumer interface for Bitcoin-native assets and DeFi.
  Oyl AMM:
    Description: The first trustless, on-chain automated market maker built for Bitcoin.
```

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

### Finding Pool Reserves in Rust

Source: https://docs.oyl.io/developer/core-concepts/pools

An example function in Rust demonstrating how to call the GetReserves operation and parse the response to retrieve token reserves from a pool.

```Rust
// Get current reserves for a pool
fn_get_reserves(&self, pool:AlkaneId)->Result<(u128,u128)>{
let cellpack =Cellpack{
        target: pool,
        inputs:vec![97],
};
let response =self.call(&cellpack,&AlkaneTransferParcel(vec![]),self.fuel())?;
letmut offset =0;

let reserve_a =u128::from_le_bytes(response.data[offset..offset +16].try_into()?);
    offset +=16;
let reserve_b =u128::from_le_bytes(response.data[offset..offset +16].try_into()?);

Ok((reserve_a, reserve_b))
}
```

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

### Connect Wallet Process

Source: https://docs.oyl.io/product/connect-wallet

This documentation outlines the user-facing steps required to connect a cryptocurrency wallet to the Oyl Dapp. It details the user interface interactions and expected wallet prompts.

```APIDOC
Connect Wallet Process:

1. Start the Connection:
   - Action: Click the 'Connect Wallet' button on the Oyl Dapp homepage.

2. Approve the Connection:
   - Action: A prompt will appear from the wallet extension.
   - User Task: Review connection details and click 'Sign' or 'Approve' in the wallet extension.
   - Security Note: Ensure you are connecting to the correct site.

3. Wallet Connected:
   - Outcome: Upon approval, the wallet connects to Oyl.
   - Display: User's wallet address and portfolio will be visible in the app.

Troubleshooting Tips:
  - Ensure the wallet extension is unlocked.
  - Use a supported browser (latest Chrome or Chromium-based).
```

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

### Oyl Protocol and AMM Interface

Source: https://docs.oyl.io/getting-started/welcome

Details on the Oyl Protocol, a set of smart contracts for a Bitcoin-native AMM, and its user interface for token swaps and liquidity management.

```APIDOC
Oyl Protocol:
  Description: A set of persistent, non-upgradable smart contracts forming a Bitcoin-native AMM.
  Functionality: Facilitates peer-to-peer market making, liquidity provisioning, and token swaps settled directly on Bitcoin.

Oyl AMM Interface:
  Description: A user-friendly web interface for interacting with the Oyl Protocol.
  Features: Swapping tokens, adding liquidity, tracking markets.
```

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

### Pool Contract Information Queries API

Source: https://docs.oyl.io/developer/reference/api

Retrieves the current reserves of tokens within the pool. The GetReserves function returns a tuple containing the reserves of token0 and token1. Usage examples demonstrate how to call this function.

```APIDOC
GetReserves:
  opcode: 97
  returns: (u128, u128) - (reserve0, reserve1)
  usage:
    let(reserve_a, reserve_b)= pool.call(AMMPoolMessage::GetReserves)?;
```

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

### Access Oyl Dapp

Source: https://docs.oyl.io/getting-started/access-the-dapp

Steps to access the Oyl decentralized application (Dapp). This includes visiting the Dapp URL, entering an access password (currently for Whale Pass holders and builders), and proceeding to the welcome screen. It also recommends using the latest version of Chrome for the best experience.

```html
<h1>Access the Oyl Dapp</h1>
<p>With your wallet set up, you’re ready to access the Oyl decentralized application (Dapp):</p>
<h2>1. Open the Oyl Dapp</h2>
<p><strong>Step 1.1:</strong> Visit <a href="https://app.oyl.io">app.oyl.io</a> in your browser.</p>
<h2>2. Enter Your Access Password</h2>
<p><strong>Step 2.1:</strong> You will see a password screen.
<strong>Password access is currently available to Whale Pass holders and builders in the Alkanes ecosystem first.</strong> Wider access will be rolled out in future phases.</p>
<p><strong>Step 2.2:</strong> Enter your password to continue and proceed.</p>
<h2>3. Welcome to Oyl</h2>
<p><strong>Step 3.1:</strong> After logging in, you'll be welcomed to the app.
<strong>Welcome to Oyl!</strong>
You’re now ready to explore all the features of Oyl, including swapping, liquidity pools, and more!
<strong>Tip:</strong> For the best experience, use the latest version of Chrome.</p>
<p>Return to <a href="https://docs.oyl.io/getting-started/welcome">Welcome to Oyl</a></p>
<p>Previous <a href="https://docs.oyl.io/getting-started/setup-your-wallet">Setup Your Wallet</a> | Next <a href="https://docs.oyl.io/product/connect-wallet">Connect Wallet</a></p>
```

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

### Swap Functionality Overview

Source: https://docs.oyl.io/product/swap

This section describes the user interface and workflow for swapping tokens on the Oyl platform. It covers preloaded assets, token selection, inputting amounts, and understanding transaction details like exchange rates, slippage, and fees.

```text
1. Default Swap Screen:
When you open the Swap page, the swap block is preloaded with `frBTC` as the asset to sell. The assets you can buy are already listed and open below—simply tap on any asset to select it, or use the search bar to quickly find the token you want to receive.

2. Select a Token to Buy:
Click the Buy block to choose which token you want to receive in the swap.

3. Input Amount and Get a Quote:
After selecting a token, you’ll see the amount input screen:
Enter how much you want to **sell** or **buy** —you can input in either token.
The block will automatically calculate the corresponding amount and generate a real-time quote for your swap.

Understanding the Swap Receipt:
The receipt section will display:
  * **Exchange Rate:** The current rate between the two tokens.
  * **Slippage:** The maximum price movement you’re willing to accept (protects you from large price swings).
  * **Fees:** Any fees associated with the swap.
  * **Estimated Received:** The amount you’ll get after all calculations.

4. Sign the Transaction:
After reviewing your swap details, proceed to sign the transaction in your wallet.

5. Swap Success:
Once the transaction is confirmed, you’ll see a success message and your new tokens will appear in your portfolio.
```

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

### Calculate TWAP

Source: https://docs.oyl.io/developer/core-concepts/oracles

Calculates the Time-Weighted Average Price (TWAP) over a specified period using cumulative price data. Requires fetching cumulative price information at the start and end times of the period.

```javascript
// Get price cumulatives at two different times  
let(cumulative_start, timestamp_start)=get_price_cumulative_at(start_time);
let(cumulative_end, timestamp_end)=get_price_cumulative_at(end_time);
  
// Calculate TWAP  
let time_elapsed = timestamp_end - timestamp_start;
let twap =(cumulative_end - cumulative_start)/ time_elapsed;
```

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

### Oyl AMM Smart Contracts Overview

Source: https://docs.oyl.io/index

Provides an overview of the smart contracts that constitute the Oyl AMM system, including the Factory Contract for managing trading pairs and the Pool Contracts for handling individual pairs and liquidity.

```APIDOC
Oyl AMM Smart Contracts:

Factory Contract:
  - Creates and manages trading pairs.

Pool Contracts:
  - Handle individual trading pairs and liquidity.

Library Functions:
  - Provide mathematical calculations for trading.
```

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

### Time-Weighted Average Price (TWAP) Calculation

Source: https://docs.oyl.io/developer/core-concepts/oracles

Illustrates the formula for calculating the Time-Weighted Average Price (TWAP) over a specific time period. It involves using cumulative prices recorded at the start and end of the period, divided by the elapsed time.

```Solidity
let twap =(price_cumulative_end - price_cumulative_start)/ time_elapsed;  
```

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

### Mint Tokens Process

Source: https://docs.oyl.io/product/mint-tokens

This section outlines the user-facing steps required to mint tokens within the Oyl application. It covers navigating the interface, interacting with the wallet for transaction signing, and verifying the outcome.

```text
1. Go to the Tokens Tab
Navigate to the **Tokens** tab within the Oyl app to view available assets.

2. Select an Asset and Click Mint
Find the asset you want to mint from the list.
Click the **Mint** button next to the asset.

3. Sign the Mint Message
A prompt will appear asking you to sign a message with your wallet to confirm the minting action.
Review the message and details.
Click **Sign** or **Approve** in your wallet extension.

4. Confirm Success
After signing, you’ll see a confirmation that your tokens have been minted.
Your new tokens will appear in your portfolio and be available for use in swaps, pools, and more.

Tip: If you don’t see your tokens right away, try refreshing the page or checking your wallet’s activity tab.
```

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

### Exact Output Swap Parameters

Source: https://docs.oyl.io/developer/core-concepts/swaps

Defines the parameters for executing a swap with a specified output token amount. It includes the token path, exact desired output amount, maximum allowed input amount, and a transaction deadline.

```APIDOC
SwapTokensForExactTokens{
    path:Vec<AlkaneId>,// Token path for the swap
    amount_out:u128,// Exact output amount desired
    amount_in_max:u128,// Maximum input amount
    deadline:u128,// Transaction deadline in block height
}
```

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

### Get Last Cumulative Price (Rust)

Source: https://docs.oyl.io/developer/core-concepts/oracles

Retrieves the last recorded cumulative price for a token pair. This function is part of the Oyl AMM's price accumulation logic, essential for TWAP calculations. It returns two u128 values representing the cumulative prices.

```Rust
#[opcode(98)]  
#[returns(u128, u128)]  
GetPriceCumulativeLast  
```

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

### Oyl AMM Core Components

Source: https://docs.oyl.io/index

Details the main components of the Oyl AMM protocol: Factory, Pools, and Library. The Factory manages pool creation and global settings, Pools handle individual trading pairs and reserves, and the Library provides mathematical functions for price calculations.

```APIDOC
Oyl AMM Architecture:

1. Factory:
   - Manages pool creation.
   - Manages global settings.

2. Pools:
   - Individual trading pairs.
   - Hold their own reserves.

3. Library:
   - Provides mathematical functions.
   - Used for price calculations.
```

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

### Exact Input Swap Parameters

Source: https://docs.oyl.io/developer/core-concepts/swaps

Defines the parameters for executing a swap with a specified input token amount. It includes the token path, minimum expected output amount, and a transaction deadline.

```APIDOC
SwapExactTokensForTokens{
    path:Vec<AlkaneId>,// Token path for the swap
    amount_out_min:u128,// Minimum output amount
    deadline:u128,// Transaction deadline in block height
}
```

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

### Wrap Bitcoin Process

Source: https://docs.oyl.io/product/wrap-bitcoin

Details the step-by-step process for wrapping Bitcoin on the Oylnet test network. This includes opening the relevant tab, noting the locked input amount, signing the transaction, and confirming the successful reception of frBTC alkane tokens.

```text
Step 1: Open the Wrap BTC Tab
Navigate to the Wrap BTC section in the Oyl app.

Step 2: Input Amount is Locked
The input amount for wrapping is locked to 0.1 BTC. There’s no need to enter a number—just proceed with the default value.

Step 3: Sign the Transaction
After confirming, you will be prompted to sign the transaction in your wallet.

Step 4: Success!
Once the transaction is confirmed, you’ll receive frBTC alkane in your portfolio and can use it for swaps or liquidity.
```

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

### Explore and Mint Alkanes

Source: https://docs.oyl.io/tokens

Browse the list of available Alkanes and other tokens. On Oylnet, use the "Mint" feature to create test Alkanes instantly for your wallet.

```text
Default view of the Tokens page, showing available assets and minting options for Oylnet.
```

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

### Oyl AMM Architecture

Source: https://docs.oyl.io/developer/overview

Details the three main components of the Oyl AMM protocol: Factory, Pools, and Library, and their roles in managing trading pairs, reserves, and calculations on the Alkanes runtime.

```APIDOC
Oyl AMM Architecture:
  1. Factory: Manages pool creation and global settings.
  2. Pools: Individual trading pairs with their own reserves.
  3. Library: Mathematical functions for price calculations.
```

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

### Oyl.io Swap Calculation Functions

Source: https://docs.oyl.io/developer/reference/api

Provides functions to calculate the output amount for a given input amount or the required input amount for a desired output amount in token swaps. It also includes functions to calculate output/input amounts for multi-hop swap paths.

```APIDOC
get_amount_out(amount_in: u128, reserve_in: u128, reserve_out: u128) -> u128
  Calculates output amount for a given input.
  Parameters:
    amount_in: Input token amount
    reserve_in: Reserve of input token
    reserve_out: Reserve of output token
  Returns: Output amount after fees

get_amount_in(amount_out: u128, reserve_in: u128, reserve_out: u128) -> u128
  Calculates required input for a desired output.
  Parameters:
    amount_out: Desired output amount
    reserve_in: Reserve of input token
    reserve_out: Reserve of output token
  Returns: Required input amount

get_amounts_out(amount_in: u128, path: Vec<AlkaneId>) -> Vec<u128>
  Calculates outputs for a multi-hop swap path.
  Parameters:
    amount_in: Initial input amount
    path: Array of token IDs for the swap path
  Returns: Array of amounts for each step in the path

get_amounts_in(amount_out: u128, path: Vec<AlkaneId>) -> Vec<u128>
  Calculates inputs for a multi-hop swap path.
  Parameters:
    amount_out: Final desired output amount
    path: Array of token IDs for the swap path
  Returns: Array of amounts for each step in the path
```

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

### Query Pool Information

Source: https://docs.oyl.io/developer/reference/api

Demonstrates how to query essential information from a pool, including reserves and details. It utilizes the `pool.call` method with specific AMMPoolMessage types.

```rust
let(reserve_a, reserve_b)= pool.call(AMMPoolMessage::GetReserves)?;
let price = reserve_b *PRECISION/ reserve_a;
let details = pool.call(AMMPoolMessage::PoolDetails)?
```

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

### Trading Operations API: SwapExactTokensForTokens

Source: https://docs.oyl.io/developer/reference/api

Executes a token swap where a specific amount of input tokens is exchanged for output tokens. The swap path and minimum output amount are defined to manage slippage.

```APIDOC
SwapExactTokensForTokens
  #[opcode(13)]
  SwapExactTokensForTokens {
    path: Vec<AlkaneId>, // Token path for the swap
    amount_in: u128, // The amount of input tokens to send
    amount_out_min: u128, // Minimum output amount
    deadline: u128, // Transaction deadline in block height
  }
  Description: Swaps an exact amount of input tokens for output tokens.
  Parameters:
    path: Array of token IDs defining the swap path
    amount_in: The amount of input tokens to send
    amount_out_min: Minimum output amount (slippage protection)
    deadline: Transaction deadline in block height
  Returns: Array of amounts for each step in the path
```

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

### Pool Contract Initialization

Source: https://docs.oyl.io/developer/smart-contracts/pool

Initializes a new pool with the trading pair, linking to the factory contract and setting initial reserves to zero.

```Rust
#[opcode(0)]  
InitPool{
    alkane_a:AlkaneId,// First token in the pair  
    alkane_b:AlkaneId,// Second token in the pair  
    factory:AlkaneId,// Factory contract address  
}  

This function:
  * Sets up the token pair
  * Links to the factory contract
  * Initializes reserves to zero
  * Prepares the pool for liquidity provision
```

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

### Oyl AMM Swap Concepts

Source: https://docs.oyl.io/developer/core-concepts/swaps

This section outlines the fundamental concepts of swaps within the Oyl AMM protocol. It covers route selection, the constant product formula, price impact, different swap types (exact input/output), multi-hop swaps with path routing, calculation methods for input and output amounts, and slippage protection mechanisms like minimum output, maximum input, and deadline protection.

```APIDOC
Route Selection:
  - Checks multiple paths for best rates.
  - Considers fuel costs for multi-hop swaps.
  - Monitors pool liquidity.

Constant Product Formula:
  - Describes the invariant relationship between token reserves in a pool.
  - Formula: x * y = k, where x and y are token reserves and k is a constant.

Price Impact:
  - Measures the difference between the market price and the price impact of a trade.
  - Calculated based on the size of the swap relative to the pool's liquidity.

Swap Types:
  - Exact Input Swaps: User specifies the amount of input token, and the protocol calculates the output token amount.
  - Exact Output Swaps: User specifies the desired amount of output token, and the protocol calculates the required input token amount.

Multi-hop Swaps:
  - Path Routing: Enables swaps between tokens not directly paired in a pool by routing through intermediate tokens.

Swap Calculations:
  - Output Amount Calculation: Determines the amount of output token received for a given input amount.
  - Input Amount Calculation: Determines the amount of input token required to receive a specified output amount.

Slippage Protection:
  - Minimum Output: Sets a minimum amount of output tokens the user is willing to receive.
  - Maximum Input: Sets a maximum amount of input tokens the user is willing to spend.
  - Deadline Protection: Specifies a maximum time within which the transaction must be executed to avoid price changes.
```

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

### Oyl AMM Smart Contracts Overview

Source: https://docs.oyl.io/developer/overview

Provides an overview of the smart contracts that constitute the Oyl AMM protocol, including the Factory Contract, Pool Contract, and Library Functions.

```APIDOC
Oyl AMM Smart Contracts:
  - Factory Contract: Creates and manages trading pairs.
  - Pool Contracts: Handle individual trading pairs and liquidity.
  - Library Functions: Provide mathematical calculations for trading.
```

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

### InitFactory Function Signature

Source: https://docs.oyl.io/developer/reference/api

Initializes the factory contract with required parameters, including the pool factory ID and beacon ID.

```Rust
#[opcode(0)]
InitFactory{
    pool_factory_id:u128,
    beacon_id:AlkaneId,
}
```

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

### Oyl AMM Key Features

Source: https://docs.oyl.io/developer/overview

Highlights the core functionalities of the Oyl AMM, including automated market making using a constant product formula, permissionless token listing, and decentralized trading.

```APIDOC
Oyl AMM Key Features:
  - Automated Market Making:
    - Constant product formula (x * y = k) for price discovery.
    - No order books - trades execute against liquidity pools.
    - Permissionless token listing.
  - Liquidity Provision:
    - Anyone can provide liquidity to earn fees.
    - LP tokens represent proportional ownership of pool reserves.
    - Fees are automatically reinvested into the pool.
  - Decentralized Trading:
    - No intermediaries or centralized control.
    - Trades settle on Bitcoin blockchain.
    - Transparent and auditable smart contracts.
```

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

### CreateNewPool Function Signature

Source: https://docs.oyl.io/developer/reference/api

Creates a new trading pair pool with specified tokens and initial liquidity amounts.

```Rust
#[opcode(1)]
CreateNewPool{
    token_a:AlkaneId,
    token_b:AlkaneId,
    amount_a:u128,
    amount_b:u128,
}
```

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

### Oyl AMM Contract Deployment and Proxies

Source: https://docs.oyl.io/developer/smart-contracts

Explains the deployment strategy for Oyl AMM contracts on the Alkanes metaprotocol, emphasizing the use of proxy patterns for upgradeability. It details the Factory Proxy and Pool Beacon Proxy mechanisms.

```APIDOC
Contract Addresses & Proxies:
  - Contracts deployed on Alkanes metaprotocol.
  - Addresses determined by Alkanes runtime based on deployment parameters.
  - Proxy pattern used for future upgrades; interact with proxy addresses.

Factory Proxy:
  - Factory contract deployed behind a standard upgradeable proxy.
  - Allows logic upgrades without changing the contract address.

Pool Beacon Proxy:
  - Pool contracts deployed using a beacon proxy pattern for gas efficiency.
  - A 'beacon' contract holds the address of the current pool logic contract.
  - Pool proxy contracts delegate calls to the logic contract via the beacon.
  - Allows simultaneous upgrade of all pools by updating the beacon.
```

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

### Oyl AMM Smart Contracts Overview

Source: https://docs.oyl.io/developer/smart-contracts

Provides an overview of the Oyl AMM protocol's smart contracts built on the Alkanes runtime for Bitcoin. It outlines the roles of the Factory and Pool contracts in facilitating automated market making.

```APIDOC
Factory Contract:
  - Creates new pool contracts for token pairs.
  - Maintains a registry of all existing pools.
  - Handles protocol-wide settings and fees.
  - Provides routing functionality for multi-hop swaps.

Pool Contracts:
  - Holds reserves of both tokens in a trading pair.
  - Executes swaps using the constant product formula.
  - Mints and burns liquidity provider (LP) tokens.
  - Collects and distributes trading fees.
```

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

### Send Tokens Workflow

Source: https://docs.oyl.io/product/send

This snippet outlines the user workflow for sending tokens on the Oyl platform. It details the sequence of actions a user needs to perform, from initiating the send action to confirming the transaction in their wallet.

```APIDOC
Send Tokens Workflow:

1. Initiate Send: Click the "Send" button in the Portfolio section.
2. Select Token: Choose the token to send from your portfolio.
3. Enter Amount: Specify the quantity of the token to send.
4. Enter Recipient Address: Provide the recipient's Segwit or Taproot address.
5. Review Transaction: Verify all transaction details.
6. Confirm Transaction: Click "Send" and confirm the transaction in your wallet.
```

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

### Oyl AMM Oracle Security and Best Practices

Source: https://docs.oyl.io/developer/core-concepts/oracles

Outlines crucial security considerations and best practices for using Oyl AMM oracles, focusing on manipulation resistance, update frequency, and TWAP period selection.

```APIDOC
Oracle Best Practices & Security:
  Manipulation Resistance:
    - Strategies: Techniques employed to prevent malicious actors from influencing price feeds.
    - Importance: Critical for maintaining the integrity of DeFi applications.
  Update Frequency:
    - Recommendation: Optimal intervals for updating oracle data to balance responsiveness and cost.
    - Considerations: Impact of update frequency on data accuracy and system load.
  TWAP Period Selection:
    - Guidance: Factors to consider when choosing the lookback period for TWAP calculations.
    - Impact: How period selection affects price smoothing and sensitivity to market events.
```
Tokens:
Raw