# LibCommand

```solidity
enum MathOperation {
    None,
    Add,
    Sub,
    Mul,
    Div,
    Pow,
    Abs128,
    Abs256,
    Shr,
    Shl
}


```

<table><thead><tr><th>Field</th><th>Description</th></tr></thead><tbody><tr><td><pre><code>None
</code></pre></td><td>A default operation indicating no mathematical operation is to be performed or possibly used as a placeholder.</td></tr><tr><td><pre><code>Add
</code></pre></td><td>Represents addition, the operation of adding two numbers together to find their sum.</td></tr><tr><td><pre><code>Sub
</code></pre></td><td>Represents subtraction, the operation of taking one number away from another to find the difference.</td></tr><tr><td><pre><code>Mul
</code></pre></td><td>Represents multiplication, the operation of scaling one number by another to find the product.</td></tr><tr><td><pre><code>Div
</code></pre></td><td>Represents division, the operation of determining how many times one number is contained within another to find the quotient.</td></tr><tr><td><pre><code>Pow
</code></pre></td><td>Stands for power, an operation that raises a number to the exponent of another number, essentially multiplying a number by itself a specified number of times.</td></tr><tr><td><pre><code>Abs128
</code></pre></td><td>Likely represents an operation to find the absolute value of a number within a 128-bit context, ensuring the result is positive or zero.</td></tr><tr><td><pre><code>Abs256
</code></pre></td><td>Similar to <code>Abs128</code>, this likely refers to finding the absolute value of a number within a 256-bit context, which allows for handling larger numbers.</td></tr><tr><td><pre><code>Shr
</code></pre></td><td>Stands for "shift right", a bitwise operation that shifts all bits in a binary representation of a number to the right by a specified number of positions, effectively dividing the number by a power of two.</td></tr><tr><td><pre><code>Shl
</code></pre></td><td>Stands for "shift left", a bitwise operation that shifts all bits in a binary representation of a number to the left by a specified number of positions, effectively multiplying the number by a power of two.</td></tr></tbody></table>

```solidity
enum CommandAction {
    Call,
    Approval,
    TransferFrom,
    Transfer,
    Wrap,
    Unwrap,
    Balance,
    UniswapV2,
    UniswapV3,
    TraderJoeV2_1,
    Solidly,
    KyberSwapClassic,
    Ambient
}
```

<table><thead><tr><th>Field</th><th>Description</th></tr></thead><tbody><tr><td><pre><code>Call
</code></pre></td><td>This action representa a generic call to a function within a contract.</td></tr><tr><td><pre><code>Approval
</code></pre></td><td>Represents an approval operation.</td></tr><tr><td><pre><code>TransferFrom
</code></pre></td><td>Indicates a transfer-from operation.</td></tr><tr><td><pre><code>Transfer
</code></pre></td><td>Represents a direct transfer operation.</td></tr><tr><td><pre><code>Wrap
</code></pre></td><td>This action is used for wrapping tokens, such as converting Ether to Wrapped Ether (WETH).</td></tr><tr><td><pre><code>Unwrap
</code></pre></td><td>The opposite of Wrap, this is used for unwrapping tokens, like converting WETH back to Ether.</td></tr><tr><td><pre><code>Balance
</code></pre></td><td>to check the balance of an account or contract for a specific asset.</td></tr><tr><td><pre><code>UniswapV2
</code></pre></td><td>Represents an swap operation related to the Uniswap V2 protocol.</td></tr><tr><td><pre><code>UniswapV3
</code></pre></td><td>For swap operation specific to Uniswap V3.</td></tr><tr><td><pre><code>TraderJoeV2_1
</code></pre></td><td>Indicates swap operation related to Trader Joe V2.1.</td></tr><tr><td><pre><code>Solidly
</code></pre></td><td>Represents swap operation related to the Solidly protocol.</td></tr><tr><td><pre><code>KyberSwapClassic
</code></pre></td><td>Indicates swap operation related to KyberSwap Classic</td></tr><tr><td><pre><code>Ambient
</code></pre></td><td>Indicates swap operation related to Ambient Protocol.</td></tr></tbody></table>

```solidity
enum SequenceType {
    NativeAmount,
    Selector,
    Address,
    Amount,
    Data,
    LastAmountOut,
    RouterAddress,
    SenderAddress
}
```

<table><thead><tr><th>Field</th><th>Description</th></tr></thead><tbody><tr><td><pre><code>NativeAmount
</code></pre></td><td>The amountIn in native tokens. </td></tr><tr><td><pre><code>Selector
</code></pre></td><td>The function selector for the command.</td></tr><tr><td><pre><code>Address
</code></pre></td><td>The recipient address.</td></tr><tr><td><pre><code>Amount
</code></pre></td><td>The amount in.</td></tr><tr><td><pre><code>Data
</code></pre></td><td>The data that contains information for the command to be performed.</td></tr><tr><td><pre><code>LastAmountOut
</code></pre></td><td>The amount received after the previous swap.</td></tr><tr><td><pre><code>RouterAddress
</code></pre></td><td>The address of the protocol router used for swapping.</td></tr><tr><td><pre><code>SenderAddress
</code></pre></td><td>The address who requested the command to be performed.</td></tr></tbody></table>

```solidity
struct CommandData {
    CommandAction commandAction;
    uint8 outputType;
    uint16 inputLength;
    uint16 sequencesPosition;
    uint16 sequencesPositionEnd;
    address targetAddress;
}
```

<table><thead><tr><th>Field</th><th>Type</th><th>Description</th></tr></thead><tbody><tr><td><pre><code>commandAction
</code></pre></td><td><pre><code>CommandAction
</code></pre></td><td>This field uses the previously defined CommandAction enum to specify the type of action this command represents.</td></tr><tr><td><pre><code>outputType
</code></pre></td><td><pre><code>uint8
</code></pre></td><td>The specific meaning of this value would depend on the context in which the CommandData struct is used.</td></tr><tr><td><pre><code>inputLength
</code></pre></td><td><pre><code>uint16
</code></pre></td><td>indicating the length of the input data for this command.</td></tr><tr><td><pre><code>sequencesPosition
</code></pre></td><td><pre><code>uint16
</code></pre></td><td>specifies the starting position of a sequence of data related to this command.</td></tr><tr><td><pre><code>sequencesPositionEnd
</code></pre></td><td><pre><code>uint16
</code></pre></td><td>marks the end position of the sequence of data.</td></tr><tr><td><pre><code>targetAddress
</code></pre></td><td><pre><code>address
</code></pre></td><td>the address of a contract or an account that is the target of this command.</td></tr></tbody></table>

### getData():

The `getData` function in Solidity is designed to extract and assemble a `CommandData` structure from transaction calldata using low-level assembly operations for efficiency. It takes a single `uint16` parameter `i`, which specifies the starting position in the calldata from where data extraction should begin.

**input**

| Field | Type   | Description                                                                    |
| ----- | ------ | ------------------------------------------------------------------------------ |
| i     | uint16 | the starting position in the calldata from where data extraction should begin. |

**output**

<table><thead><tr><th>Field</th><th>Type</th><th>Description</th></tr></thead><tbody><tr><td>commandData</td><td><pre><code>CommandData
</code></pre></td><td><pre><code>struct CommandData {
    CommandAction commandAction;
    uint8 outputType;
    uint16 inputLength;
    uint16 sequencesPosition;
    uint16 sequencesPositionEnd;
    address targetAddress;
}
</code></pre></td></tr></tbody></table>

### getInput():

The `getInput` function is a complex and versatile internal function designed for processing a sequence of commands encoded in a `CommandData` structure, typically used in a blockchain transaction context. It starts by initializing a dynamic `input` byte array and other local variables, including `nativeAmount`, `selector`, and various counters. The function iterates over a range of command sequences, each identified by a `SequenceType` (like `NativeAmount`, `Selector`, `Address`, etc.), and processes each sequence differently based on its type. For instance, it extracts and stores native token amounts, contract function selectors, addresses, and other data into the `input` array, adjusting the offset for each entry. The function also handles special cases, such as using the `lastAmountOut` as an input or rejecting certain types of transactions (like `transferFrom` calls in custom actions). It ensures that the length of the processed sequences matches the expected `inputLength` from `commandData`, and validates the selector for contract calls. Overall, `getInput` is a sophisticated function that dynamically constructs a transaction input from a series of encoded commands, ensuring flexibility and security in executing complex transaction sequences on the blockchain.

**Input**

<table><thead><tr><th>Field</th><th>Type</th><th>Description</th></tr></thead><tbody><tr><td>lastAmountOut</td><td>uint256</td><td>The amount received after the previous swap.</td></tr><tr><td>commandData</td><td>CommandData</td><td><pre><code>struct CommandData {
    CommandAction commandAction;
    uint8 outputType;
    uint16 inputLength;
    uint16 sequencesPosition;
    uint16 sequencesPositionEnd;
    address targetAddress;
}
</code></pre></td></tr></tbody></table>

**Output**

| Field        | Type    | Description                                                         |
| ------------ | ------- | ------------------------------------------------------------------- |
| nativeAmount | uint256 | The amountIn in native tokens.                                      |
| selector     | bytes4  | The function selector for the command.                              |
| input        | bytes   | The data that contains information for the command to be performed. |

### approve():

the approve function is a utility function within a smart contract to perform an ERC-20 token approval operation. It extracts the token address, spender address, and amount from a byte array and then calls the approve function on the specified ERC-20 token contract.

**input**

| Field | Type         | Description                                           |
| ----- | ------------ | ----------------------------------------------------- |
| input | bytes memory | A byte array containing necessary approve parameters. |

### transferFrom():

the transferFrom function is a utility function within a smart contract to perform an ERC-20 token transfer from one address to another. It extracts the token address, sender address, recipient address, and amount from a byte array and then calls the transferFrom function on the specified ERC-20 token contract.

**input**

| Field | Type         | Description                                                |
| ----- | ------------ | ---------------------------------------------------------- |
| input | bytes memory | A byte array containing necessary transferFrom parameters. |

### transfer():

the transfer function is a utility function within a smart contract to perform an ERC-20 token transfer to a specified address. It extracts the token address, recipient address, and amount from a byte array and then calls the transfer function on the specified ERC-20 token contract.

**input**

| Field | Type         | Description                                            |
| ----- | ------------ | ------------------------------------------------------ |
| input | bytes memory | A byte array containing necessary transfer parameters. |

### wrap():

the wrap function is a utility function within a smart contract to convert Ether into Wrapped Ether (WETH). It extracts the WETH contract address and the amount of Ether to be wrapped from a byte array and then calls the deposit function on the WETH contract, sending the specified amount of Ether.

**input**

| Field | Type         | Description                                        |
| ----- | ------------ | -------------------------------------------------- |
| input | bytes memory | A byte array containing necessary wrap parameters. |

### unwrap():

the unwrap function is a utility function within a smart contract to convert Wrapped Ether (WETH) back into Ether. It extracts the WETH contract address and the amount of WETH to be unwrapped from a byte array and then calls the withdraw function on the WETH contract.

**Input**

| Field | Type         | Description                                          |
| ----- | ------------ | ---------------------------------------------------- |
| input | bytes memory | A byte array containing necessary unwrap parameters. |

### balance():

the balance function is a utility function within a smart contract to query the balance of a specific asset (like an ERC-20 token) held by the contract. It extracts the asset's address from a byte array and then queries the balance of that asset for the contract's address.

**Input**

| Field | Type         | Description                                           |
| ----- | ------------ | ----------------------------------------------------- |
| input | bytes memory | A byte array containing necessary balance parameters. |

### execute():

the execute function is a central part of a smart contract that needs to perform a variety of operations based on dynamic inputs. It can handle standard ERC-20 operations like approvals and transfers, wrap and unwrap Ether, interact with various DeFi protocols, and make generic contract calls.

**Input**

<table><thead><tr><th>Field</th><th>Type</th><th>Description</th></tr></thead><tbody><tr><td>commandData</td><td>CommandData</td><td><pre><code>struct CommandData {
    CommandAction commandAction;
    uint8 outputType;
    uint16 inputLength;
    uint16 sequencesPosition;
    uint16 sequencesPositionEnd;
    address targetAddress;
}
</code></pre></td></tr><tr><td>nativeAmount</td><td>uint256</td><td>The amountIn in native tokens. </td></tr><tr><td>selector</td><td>bytes4</td><td>The function selector for the command.</td></tr><tr><td>input</td><td>bytes</td><td>The data that contains information for the command to be performed.</td></tr></tbody></table>

**Output**

| Field     | Type    | Description                         |
| --------- | ------- | ----------------------------------- |
| amountOut | uint256 | The amount received after the swap. |


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.fly.trade/flycn/developers/deprecated-magpie-contracts/magpierouterv2/router/libcommand.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.