0x4be03f781c497a489e3cb0287833452ca9b9e80b
Solidity v0.7.1+commit.f4a555be
🤖
Query this contract from your AI
Reference:
0x4be03f781c497a489e3cb0287833452ca9b9e80b
Sample prompt:
"Tell me the current state of berachain/0x4be03f781c497a489e3cb0287833452ca9b9e80b"
No AI wired up yet? →
mcp.smarts.md
· Browse chains
Berachain is a docs-only chain on Smarts: source code and ABI are indexed, but live on-chain data (state, recent events, admin profile) is not currently available. AI agents can still query get_contract_info and get_contract_source via MCP.
Overview
Read Functions
12
Write Functions
14
Events
12
Read Functions
WETH()
view
Return the address of the WETH token used by the vault.✨ AI
dev: Returns the Vault's WETH instance.
Returns
| Name | Type | Description |
|---|---|---|
| — | address | The address of the wrapped Ether (WETH) token contract used by the vault.✨ AI |
getActionId(selector: bytes4)
view
Return the action ID associated with the given function selector.✨ AI
dev: Returns the action identifier associated with the external function described by `selector`.
Parameters
| Name | Type | Description |
|---|---|---|
| selector | bytes4 | The 4-byte function selector to query the action ID for.✨ AI |
Returns
| Name | Type | Description |
|---|---|---|
| — | bytes32 | The action ID (bytes32) corresponding to the provided selector.✨ AI |
getAuthorizer()
view
Returns the address of the contract's current authorizer.✨ AI
dev: Returns the Vault's Authorizer.
Returns
| Name | Type | Description |
|---|---|---|
| — | address | Address of the current authorizer (contract or account) that controls access rules.✨ AI |
getDomainSeparator()
view
Returns the EIP-712 domain separator used for signing and verifying typed data.✨ AI
dev: Returns the EIP712 domain separator.
Returns
| Name | Type | Description |
|---|---|---|
| — | bytes32 | The 32-byte EIP-712 domain separator (bytes32) for this contract instance.✨ AI |
getInternalBalance(user: address, tokens: address[])
view
Returns the user's internal token balances for the specified tokens.✨ AI
dev: Returns `user`'s Internal Balance for a set of tokens.
Parameters
| Name | Type | Description |
|---|---|---|
| user | address | Address whose internal balances to return.✨ AI |
| tokens | address[] | Array of token addresses to query; returned balances follow this order.✨ AI |
Returns
| Name | Type | Description |
|---|---|---|
| balances | uint256[] | Array of internal balances corresponding to each token in the input order, expressed in the token's smallest unit.✨ AI |
getNextNonce(user: address)
view
Return the next nonce the given user must use for on-chain operations.✨ AI
dev: Returns the next nonce used by an address to sign messages.
Parameters
| Name | Type | Description |
|---|---|---|
| user | address | The address of the user whose next nonce is returned.✨ AI |
Returns
| Name | Type | Description |
|---|---|---|
| — | uint256 | The next uint256 nonce that the user should use for their next transaction.✨ AI |
getPausedState()
view
Returns the vault's paused status and the end timestamps for the pause window and buffer period.✨ AI
dev: Returns the current contract pause status, as well as the end times of the Pause Window and Buffer Period.
Returns
| Name | Type | Description |
|---|---|---|
| paused | bool | paused: true if vault actions are currently paused, false otherwise.✨ AI |
| pauseWindowEndTime | uint256 | pauseWindowEndTime: unix timestamp when the pause window ends; 0 if not set.✨ AI |
| bufferPeriodEndTime | uint256 | bufferPeriodEndTime: unix timestamp when the buffer period ends; 0 if not set.✨ AI |
getPool(poolId: bytes32)
view
Return the pool contract address and its configuration index for the specified pool ID.✨ AI
dev: Returns a Pool's contract address and specialization setting.
Parameters
| Name | Type | Description |
|---|---|---|
| poolId | bytes32 | Keccak-256 identifier of the pool to query.✨ AI |
Returns
| Name | Type | Description |
|---|---|---|
| — | address | Address of the pool contract associated with the given poolId.✨ AI |
| — | uint8 | Pool configuration index as a uint8 (e.g., fee tier or pool type).✨ AI |
getPoolTokenInfo(poolId: bytes32, token: address)
view
Returns the cash, managed balance, last change block, and asset manager for a token in a pool.✨ AI
dev: Returns detailed information for a Pool's registered token. `cash` is the number of tokens the Vault currently holds for the Pool. `managed` is the number of tokens withdrawn and held outside the Vault by the Pool's token Asset Manager. The Pool's total balance for `token` equals the sum of `cash` and `managed`. Internally, `cash` and `managed` are stored using 112 bits. No action can ever cause a Pool's token `cash`, `managed` or `total` balance to be greater than 2^112 - 1. `lastChangeBlock` is the number of the block in which `token`'s total balance was last modified (via either a join, exit, swap, or Asset Manager update). This value is useful to avoid so-called 'sandwich attacks', for example when developing price oracles. A change of zero (e.g. caused by a swap with amount zero) is considered a change for this purpose, and will update `lastChangeBlock`. `assetManager` is the Pool's token Asset Manager.
Parameters
| Name | Type | Description |
|---|---|---|
| poolId | bytes32 | Identifier of the pool containing the token.✨ AI |
| token | address | Address of the token to query within the pool.✨ AI |
Returns
| Name | Type | Description |
|---|---|---|
| cash | uint256 | cash: Amount of tokens currently held in the pool (not managed by an external manager).✨ AI |
| managed | uint256 | managed: Amount of tokens currently managed by the pool's asset manager.✨ AI |
| lastChangeBlock | uint256 | lastChangeBlock: Block number when cash or managed balances were last updated.✨ AI |
| assetManager | address | assetManager: Address authorized to manage this token's assets for the pool.✨ AI |
getPoolTokens(poolId: bytes32)
view
Returns the current token list, their balances, and the block number of the last change for the specified pool.✨ AI
dev: Returns a Pool's registered tokens, the total balance for each, and the latest block when *any* of the tokens' `balances` changed. The order of the `tokens` array is the same order that will be used in `joinPool`, `exitPool`, as well as in all Pool hooks (where applicable). Calls to `registerTokens` and `deregisterTokens` may change this order. If a Pool only registers tokens once, and these are sorted in ascending order, they will be stored in the same order as passed to `registerTokens`. Total balances include both tokens held by the Vault and those withdrawn by the Pool's Asset Managers. These are the amounts used by joins, exits and swaps. For a detailed breakdown of token balances, use `getPoolTokenInfo` instead.
Parameters
| Name | Type | Description |
|---|---|---|
| poolId | bytes32 | Pool identifier (bytes32) to query.✨ AI |
Returns
| Name | Type | Description |
|---|---|---|
| tokens | address[] | Array of token addresses registered in the pool.✨ AI |
| balances | uint256[] | Array of token balances matching the tokens array; values are in each token's smallest unit.✨ AI |
| lastChangeBlock | uint256 | Block number when the pool's token list or balances were last modified.✨ AI |
getProtocolFeesCollector()
view
Returns the address that collects the protocol fees.✨ AI
dev: Returns the current protocol fee module.
Returns
| Name | Type | Description |
|---|---|---|
| — | address | The address of the protocol fees collector contract or account.✨ AI |
hasApprovedRelayer(user: address, relayer: address)
view
Checks whether a user has approved a relayer to act on their behalf.✨ AI
dev: Returns true if `user` has approved `relayer` to act as a relayer for them.
Parameters
| Name | Type | Description |
|---|---|---|
| user | address | Address of the user who may have given approval.✨ AI |
| relayer | address | Address of the relayer to check for approval.✨ AI |
Returns
| Name | Type | Description |
|---|---|---|
| — | bool | True if the relayer is approved by the user; otherwise false.✨ AI |
Write Functions
batchSwap(kind: uint8, swaps: tuple[], assets: address[], funds: tuple, limits: int256[], deadline: uint256)
payable
Perform multiple swaps across pools in a single transaction and settle net asset changes.✨ AI
dev: Performs a series of swaps with one or multiple Pools. In each individual swap, the caller determines either the amount of tokens sent to or received from the Pool, depending on the `kind` value. Returns an array with the net Vault asset balance deltas. Positive amounts represent tokens (or ETH) sent to the Vault, and negative amounts represent tokens (or ETH) sent by the Vault. Each delta corresponds to the asset at the same index in the `assets` array. Swaps are executed sequentially, in the order specified by the `swaps` array. Each array element describes a Pool, the token to be sent to this Pool, the token to receive from it, and an amount that is either `amountIn` or `amountOut` depending on the swap kind. Multihop swaps can be executed by passing an `amount` value of zero for a swap. This will cause the amount in/out of the previous swap to be used as the amount in for the current one. In a 'given in' swap, 'tokenIn' must equal the previous swap's `tokenOut`. For a 'given out' swap, `tokenOut` must equal the previous swap's `tokenIn`. The `assets` array contains the addresses of all assets involved in the swaps. These are either token addresses, or the IAsset sentinel value for ETH (the zero address). Each entry in the `swaps` array specifies tokens in and out by referencing an index in `assets`. Note that Pools never interact with ETH directly: it will be wrapped to or unwrapped from WETH by the Vault. Internal Balance usage, sender, and recipient are determined by the `funds` struct. The `limits` array specifies the minimum or maximum amount of each token the vault is allowed to transfer. `batchSwap` can be used to make a single swap, like `swap` does, but doing so requires more gas than the equivalent `swap` call. Emits `Swap` events.
Parameters
| Name | Type | Description |
|---|---|---|
| kind | uint8 | Swap kind flag (uint8): 0 = GIVEN_IN, 1 = GIVEN_OUT; determines whether amounts are inputs or outputs.✨ AI |
| swaps | tuple[] | Array of swap instructions; each includes pool id, input/output asset indexes, amount, and optional userData.✨ AI |
| assets | address[] | Ordered list of asset addresses referenced by swaps; swap tuples use indexes into this array.✨ AI |
| funds | tuple | Fund management settings (sender, recipient and internal-balance flags) that control sources and recipients of assets.✨ AI |
| limits | int256[] | Signed per-asset limits corresponding to assets array; positive = max to receive, negative = max to send.✨ AI |
| deadline | uint256 | Unix timestamp by which the swap must complete or the call will revert.✨ AI |
Returns
| Name | Type | Description |
|---|---|---|
| assetDeltas | int256[] | Array of signed net asset deltas per asset in the same order as assets; positive = Vault sends to caller, negative = Vault receives.✨ AI |
deregisterTokens(poolId: bytes32, tokens: address[])
nonpayable
Deregister one or more token addresses from the specified liquidity pool.✨ AI
dev: Deregisters `tokens` for the `poolId` Pool. Must be called by the Pool's contract. Only registered tokens (via `registerTokens`) can be deregistered. Additionally, they must have zero total balance. For Pools with the Two Token specialization, `tokens` must have a length of two, that is, both tokens must be deregistered in the same `deregisterTokens` call. A deregistered token can be re-registered later on, possibly with a different Asset Manager. Emits a `TokensDeregistered` event.
Parameters
| Name | Type | Description |
|---|---|---|
| poolId | bytes32 | Identifier of the pool from which tokens will be removed.✨ AI |
| tokens | address[] | Array of token contract addresses to deregister from the pool.✨ AI |
exitPool(poolId: bytes32, sender: address, recipient: address, request: tuple)
nonpayable
Exit a pool to withdraw tokens for the recipient according to the provided exit request.✨ AI
dev: Called by users to exit a Pool, which transfers tokens from the Pool's balance to `recipient`. This will trigger custom Pool behavior, which will typically ask for something in return from `sender` - often tokenized Pool shares. The amount of tokens that can be withdrawn is limited by the Pool's `cash` balance (see `getPoolTokenInfo`). If the caller is not `sender`, it must be an authorized relayer for them. The `tokens` and `minAmountsOut` arrays must have the same length, and each entry in these indicates the minimum token amount to receive for each token contract. The amounts to send are decided by the Pool and not the Vault: it just enforces these minimums. If exiting a Pool that holds WETH, it is possible to receive ETH directly: the Vault will do the unwrapping. To enable this mechanism, the IAsset sentinel value (the zero address) must be passed in the `assets` array instead of the WETH address. Note that it is not possible to combine ETH and WETH in the same exit. `assets` must have the same length and order as the array returned by `getPoolTokens`. This prevents issues when interacting with Pools that register and deregister tokens frequently. If receiving ETH however, the array must be sorted *before* replacing the WETH address with the ETH sentinel value (the zero address), which means the final `assets` array might not be sorted. Pools with no registered tokens cannot be exited. If `toInternalBalance` is true, the tokens will be deposited to `recipient`'s Internal Balance. Otherwise, an ERC20 transfer will be performed. Note that ETH cannot be deposited to Internal Balance: attempting to do so will trigger a revert. `minAmountsOut` is the minimum amount of tokens the user expects to get out of the Pool, for each token in the `tokens` array. This array must match the Pool's registered tokens. This causes the Vault to call the `IBasePool.onExitPool` hook on the Pool's contract, where Pools implement their own custom logic. This typically requires additional information from the user (such as the expected number of Pool shares to return). This can be encoded in the `userData` argument, which is ignored by the Vault and passed directly to the Pool's contract. Emits a `PoolBalanceChanged` event.
Parameters
| Name | Type | Description |
|---|---|---|
| poolId | bytes32 | Identifier of the pool to exit.✨ AI |
| sender | address | Address that initiated the exit and provided pool tokens.✨ AI |
| recipient | address | Address that will receive the withdrawn tokens.✨ AI |
| request | tuple | Exit request struct: assets, minAmountsOut, userData, and toInternalBalance flag.✨ AI |
flashLoan(recipient: address, tokens: address[], amounts: uint256[], userData: bytes)
nonpayable
Send specified token amounts as a flash loan to recipient; funds must be returned within the same transaction.✨ AI
dev: Performs a 'flash loan', sending tokens to `recipient`, executing the `receiveFlashLoan` hook on it, and then reverting unless the tokens plus a proportional protocol fee have been returned. The `tokens` and `amounts` arrays must have the same length, and each entry in these indicates the loan amount for each token contract. `tokens` must be sorted in ascending order. The 'userData' field is ignored by the Vault, and forwarded as-is to `recipient` as part of the `receiveFlashLoan` call. Emits `FlashLoan` events.
Parameters
| Name | Type | Description |
|---|---|---|
| recipient | address | Address receiving the borrowed tokens and executing the flash loan callback.✨ AI |
| tokens | address[] | Array of token contract addresses to borrow (ERC-20).✨ AI |
| amounts | uint256[] | Array of amounts to borrow for each token; indices correspond to tokens.✨ AI |
| userData | bytes | Arbitrary data forwarded to the recipient's callback for custom logic.✨ AI |
joinPool(poolId: bytes32, sender: address, recipient: address, request: tuple)
payable
Join a liquidity pool by depositing the specified tokens using a JoinPoolRequest.✨ AI
dev: Called by users to join a Pool, which transfers tokens from `sender` into the Pool's balance. This will trigger custom Pool behavior, which will typically grant something in return to `recipient` - often tokenized Pool shares. If the caller is not `sender`, it must be an authorized relayer for them. The `assets` and `maxAmountsIn` arrays must have the same length, and each entry indicates the maximum amount to send for each asset. The amounts to send are decided by the Pool and not the Vault: it just enforces these maximums. If joining a Pool that holds WETH, it is possible to send ETH directly: the Vault will do the wrapping. To enable this mechanism, the IAsset sentinel value (the zero address) must be passed in the `assets` array instead of the WETH address. Note that it is not possible to combine ETH and WETH in the same join. Any excess ETH will be sent back to the caller (not the sender, which is important for relayers). `assets` must have the same length and order as the array returned by `getPoolTokens`. This prevents issues when interacting with Pools that register and deregister tokens frequently. If sending ETH however, the array must be sorted *before* replacing the WETH address with the ETH sentinel value (the zero address), which means the final `assets` array might not be sorted. Pools with no registered tokens cannot be joined. If `fromInternalBalance` is true, the caller's Internal Balance will be preferred: ERC20 transfers will only be made for the difference between the requested amount and Internal Balance (if any). Note that ETH cannot be withdrawn from Internal Balance: attempting to do so will trigger a revert. This causes the Vault to call the `IBasePool.onJoinPool` hook on the Pool's contract, where Pools implement their own custom logic. This typically requires additional information from the user (such as the expected number of Pool shares). This can be encoded in the `userData` argument, which is ignored by the Vault and passed directly to the Pool's contract, as is `recipient`. Emits a `PoolBalanceChanged` event.
Parameters
| Name | Type | Description |
|---|---|---|
| poolId | bytes32 | ID of the pool to join.✨ AI |
| sender | address | Address supplying tokens or whose internal balance funds the join.✨ AI |
| recipient | address | Address that will receive the pool tokens (BPT).✨ AI |
| request | tuple | JoinPoolRequest tuple: assets, maxAmountsIn, userData, fromInternalBalance.✨ AI |
managePoolBalance(ops: tuple[])
nonpayable
Update multiple pool balances and perform asset transfers according to a list of operations.✨ AI
dev: Performs a set of Pool balance operations, which may be either withdrawals, deposits or updates. Pool Balance management features batching, which means a single contract call can be used to perform multiple operations of different kinds, with different Pools and tokens, at once. For each operation, the caller must be registered as the Asset Manager for `token` in `poolId`.
Parameters
| Name | Type | Description |
|---|---|---|
| ops | tuple[] | Array of operations; each tuple encodes poolId, token, amount delta, recipient, and flags controlling execution.✨ AI |
manageUserBalance(ops: tuple[])
payable
Execute a batch of balance operations to update user balances, transfers, or deposits in the Vault.✨ AI
dev: Performs a set of user balance operations, which involve Internal Balance (deposit, withdraw or transfer) and plain ERC20 transfers using the Vault's allowance. This last feature is particularly useful for relayers, as it lets integrators reuse a user's Vault allowance. For each operation, if the caller is not `sender`, it must be an authorized relayer for them.
Parameters
| Name | Type | Description |
|---|---|---|
| ops | tuple[] | Array of operation tuples specifying action type, user, token, amount, and optional metadata.✨ AI |
queryBatchSwap(kind: uint8, swaps: tuple[], assets: address[], funds: tuple)
nonpayable
Estimate net token flows for a batch swap without executing it.✨ AI
dev: Simulates a call to `batchSwap`, returning an array of Vault asset deltas. Calls to `swap` cannot be simulated directly, but an equivalent `batchSwap` call can and will yield the exact same result. Each element in the array corresponds to the asset at the same index, and indicates the number of tokens (or ETH) the Vault would take from the sender (if positive) or send to the recipient (if negative). The arguments it receives are the same that an equivalent `batchSwap` call would receive. Unlike `batchSwap`, this function performs no checks on the sender or recipient field in the `funds` struct. This makes it suitable to be called by off-chain applications via eth_call without needing to hold tokens, approve them for the Vault, or even know a user's address. Note that this function is not 'view' (due to implementation details): the client code must explicitly execute eth_call instead of eth_sendTransaction.
Parameters
| Name | Type | Description |
|---|---|---|
| kind | uint8 | Swap kind enum: 0 = GIVEN_IN, 1 = GIVEN_OUT.✨ AI |
| swaps | tuple[] | Array of swap steps (poolId, assetInIndex, assetOutIndex, amount, userData).✨ AI |
| assets | address[] | Ordered list of token addresses referenced by the swap steps.✨ AI |
| funds | tuple | Fund management tuple (sender, recipient, fromInternalBalance, toInternalBalance).✨ AI |
Returns
| Name | Type | Description |
|---|---|---|
| — | int256[] | Array of net asset deltas for each asset in assets; positive = Vault receives, negative = Vault sends.✨ AI |
registerPool(specialization: uint8)
nonpayable
Registers a new pool with the specified specialization and returns the pool's identifier.✨ AI
dev: Registers the caller account as a Pool with a given specialization setting. Returns the Pool's ID, which is used in all Pool-related functions. Pools cannot be deregistered, nor can the Pool's specialization be changed. The caller is expected to be a smart contract that implements either `IGeneralPool` or `IMinimalSwapInfoPool`, depending on the chosen specialization setting. This contract is known as the Pool's contract. Note that the same contract may register itself as multiple Pools with unique Pool IDs, or in other words, multiple Pools may share the same contract. Emits a `PoolRegistered` event.
Parameters
| Name | Type | Description |
|---|---|---|
| specialization | uint8 | Numeric code selecting the pool specialization which configures pool behavior and hooks.✨ AI |
Returns
| Name | Type | Description |
|---|---|---|
| — | bytes32 | A bytes32 value that uniquely identifies the newly registered pool (the Pool ID).✨ AI |
registerTokens(poolId: bytes32, tokens: address[], assetManagers: address[])
nonpayable
Register a set of tokens and their asset managers for the specified pool.✨ AI
dev: Registers `tokens` for the `poolId` Pool. Must be called by the Pool's contract. Pools can only interact with tokens they have registered. Users join a Pool by transferring registered tokens, exit by receiving registered tokens, and can only swap registered tokens. Each token can only be registered once. For Pools with the Two Token specialization, `tokens` must have a length of two, that is, both tokens must be registered in the same `registerTokens` call, and they must be sorted in ascending order. The `tokens` and `assetManagers` arrays must have the same length, and each entry in these indicates the Asset Manager for the corresponding token. Asset Managers can manage a Pool's tokens via `managePoolBalance`, depositing and withdrawing them directly, and can even set their balance to arbitrary amounts. They are therefore expected to be highly secured smart contracts with sound design principles, and the decision to register an Asset Manager should not be made lightly. Pools can choose not to assign an Asset Manager to a given token by passing in the zero address. Once an Asset Manager is set, it cannot be changed except by deregistering the associated token and registering again with a different Asset Manager. Emits a `TokensRegistered` event.
Parameters
| Name | Type | Description |
|---|---|---|
| poolId | bytes32 | Identifier of the liquidity pool to register tokens for.✨ AI |
| tokens | address[] | Addresses of tokens to register for the pool.✨ AI |
| assetManagers | address[] | Addresses of asset managers corresponding to each token.✨ AI |
setAuthorizer(newAuthorizer: address)
nonpayable
Set the Vault's authorizer to a new address, updating which contract controls access permissions.✨ AI
dev: Sets a new Authorizer for the Vault. The caller must be allowed by the current Authorizer to do this. Emits an `AuthorizerChanged` event.
Parameters
| Name | Type | Description |
|---|---|---|
| newAuthorizer | address | Address of the new authorizer contract.✨ AI |
setPaused(paused: bool)
nonpayable
Set the contract's paused state to the provided boolean.✨ AI
dev: Safety mechanism to pause most Vault operations in the event of an emergency - typically detection of an error in some part of the system. The Vault can only be paused during an initial time period, after which pausing is forever disabled. While the contract is paused, the following features are disabled: - depositing and transferring internal balance - transferring external balance (using the Vault's allowance) - swaps - joining Pools - Asset Manager interactions Internal Balance can still be withdrawn, and Pools exited.
Parameters
| Name | Type | Description |
|---|---|---|
| paused | bool | When true, disable paused actions; when false, enable them.✨ AI |
setRelayerApproval(sender: address, relayer: address, approved: bool)
nonpayable
Set approval for a relayer to act on behalf of a sender in the Vault.✨ AI
dev: Allows `relayer` to act as a relayer for `sender` if `approved` is true, and disallows it otherwise. Emits a `RelayerApprovalChanged` event.
Parameters
| Name | Type | Description |
|---|---|---|
| sender | address | Address of the account granting or revoking relayer permission.✨ AI |
| relayer | address | Address being approved or revoked to act for the sender.✨ AI |
| approved | bool | True to approve the relayer, false to revoke approval.✨ AI |
swap(singleSwap: tuple, funds: tuple, limit: uint256, deadline: uint256)
payable
Execute a single token swap using provided swap details and fund permissions, returning the calculated amount.✨ AI
dev: Performs a swap with a single Pool. If the swap is 'given in' (the number of tokens to send to the Pool is known), it returns the amount of tokens taken from the Pool, which must be greater than or equal to `limit`. If the swap is 'given out' (the number of tokens to take from the Pool is known), it returns the amount of tokens sent to the Pool, which must be less than or equal to `limit`. Internal Balance usage and the recipient are determined by the `funds` struct. Emits a `Swap` event.
Parameters
| Name | Type | Description |
|---|---|---|
| singleSwap | tuple | Struct describing the swap specifics: pool, assetIn, assetOut, amount, and any user data.✨ AI |
| funds | tuple | Struct specifying sender, recipient, and flags for internal balance usage and approvals.✨ AI |
| limit | uint256 | Slippage guard specifying the minimum (for exactIn) or maximum (for exactOut) acceptable amount.✨ AI |
| deadline | uint256 | Unix timestamp after which the call will revert if the swap has not been executed.✨ AI |
Returns
| Name | Type | Description |
|---|---|---|
| amountCalculated | uint256 | amountCalculated: The final amount computed by the swap (output or input based on swap kind), in token base units.✨ AI |
Events
AuthorizerChanged(newAuthorizer: address)
| Name | Type | Indexed | Description |
|---|---|---|---|
| newAuthorizer | address | ✓ |
ExternalBalanceTransfer(token: address, sender: address, recipient: address, amount: uint256)
| Name | Type | Indexed | Description |
|---|---|---|---|
| token | address | ✓ | |
| sender | address | ✓ | |
| recipient | address | ||
| amount | uint256 |
FlashLoan(recipient: address, token: address, amount: uint256, feeAmount: uint256)
| Name | Type | Indexed | Description |
|---|---|---|---|
| recipient | address | ✓ | |
| token | address | ✓ | |
| amount | uint256 | ||
| feeAmount | uint256 |
InternalBalanceChanged(user: address, token: address, delta: int256)
| Name | Type | Indexed | Description |
|---|---|---|---|
| user | address | ✓ | |
| token | address | ✓ | |
| delta | int256 |
PausedStateChanged(paused: bool)
| Name | Type | Indexed | Description |
|---|---|---|---|
| paused | bool |
PoolBalanceChanged(poolId: bytes32, liquidityProvider: address, tokens: address[], deltas: int256[], protocolFeeAmounts: uint256[])
| Name | Type | Indexed | Description |
|---|---|---|---|
| poolId | bytes32 | ✓ | |
| liquidityProvider | address | ✓ | |
| tokens | address[] | ||
| deltas | int256[] | ||
| protocolFeeAmounts | uint256[] |
PoolBalanceManaged(poolId: bytes32, assetManager: address, token: address, cashDelta: int256, managedDelta: int256)
| Name | Type | Indexed | Description |
|---|---|---|---|
| poolId | bytes32 | ✓ | |
| assetManager | address | ✓ | |
| token | address | ✓ | |
| cashDelta | int256 | ||
| managedDelta | int256 |
PoolRegistered(poolId: bytes32, poolAddress: address, specialization: uint8)
| Name | Type | Indexed | Description |
|---|---|---|---|
| poolId | bytes32 | ✓ | |
| poolAddress | address | ✓ | |
| specialization | uint8 |
RelayerApprovalChanged(relayer: address, sender: address, approved: bool)
| Name | Type | Indexed | Description |
|---|---|---|---|
| relayer | address | ✓ | |
| sender | address | ✓ | |
| approved | bool |
Swap(poolId: bytes32, tokenIn: address, tokenOut: address, amountIn: uint256, amountOut: uint256)
| Name | Type | Indexed | Description |
|---|---|---|---|
| poolId | bytes32 | ✓ | |
| tokenIn | address | ✓ | |
| tokenOut | address | ✓ | |
| amountIn | uint256 | ||
| amountOut | uint256 |
TokensDeregistered(poolId: bytes32, tokens: address[])
| Name | Type | Indexed | Description |
|---|---|---|---|
| poolId | bytes32 | ✓ | |
| tokens | address[] |
TokensRegistered(poolId: bytes32, tokens: address[], assetManagers: address[])
| Name | Type | Indexed | Description |
|---|---|---|---|
| poolId | bytes32 | ✓ | |
| tokens | address[] | ||
| assetManagers | address[] |