// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)
pragma solidity ^0.8.0;
import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.sol";
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* The default value of {decimals} is 18. To change this, you should override
* this function so it returns a different value.
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC20
* applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the default value returned by this function, unless
* it's overridden.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
* - the caller must have allowance for ``from``'s tokens of at least
* `amount`.
*/
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
/**
* @dev Moves `amount` of tokens from `from` to `to`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
*/
function _transfer(address from, address to, uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
// Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
// decrementing then incrementing.
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
// Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
// Overflow not possible: amount <= accountBalance <= totalSupply.
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/**
* @dev Updates `owner` s allowance for `spender` based on spent `amount`.
*
* Does not update the allowance amount in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Might emit an {Approval} event.
*/
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
/**
* @dev Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* has been transferred to `to`.
* - when `from` is zero, `amount` tokens have been minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens have been burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
pragma solidity ^0.8.0;
import "../IERC20.sol";
/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*
* _Available since v4.1._
*/
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
// SPDX-License-Identifier: BUSL-1.1
pragma solidity >=0.5.0;
interface ILayerZeroReceiver {
// @notice LayerZero endpoint will invoke this function to deliver the message on the destination
// @param _srcChainId - the source endpoint identifier
// @param _srcAddress - the source sending contract address from the source chain
// @param _nonce - the ordered message nonce
// @param _payload - the signed payload is the UA bytes has encoded to be sent
function lzReceive(uint16 _srcChainId, bytes calldata _srcAddress, uint64 _nonce, bytes calldata _payload) external;
}
// SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.18;
/*
* @title IWormholeReceiver Interface
*
* @notice Interface for a contract which can receive Wormhole messages.
*
* Co-Founders:
* - Simran Dhillon: simran@xenify.io
* - Hardev Dhillon: hardev@xenify.io
* - Dayana Plaz: dayana@xenify.io
*
* Official Links:
* - Twitter: https://twitter.com/xenify_io
* - Telegram: https://t.me/xenify_io
* - Website: https://xenify.io
*
* Disclaimer:
* This contract aligns with the principles of the Fair Crypto Foundation, promoting self-custody, transparency, consensus-based
* trust, and permissionless value exchange. There are no administrative access keys, underscoring our commitment to decentralization.
* Engaging with this contract involves technical and legal risks. Users must conduct their own due diligence and ensure compliance
* with local laws and regulations. The software is provided "AS-IS," without warranties, and the co-founders and developers disclaim
* all liability for any vulnerabilities, exploits, errors, or breaches that may occur. By using this contract, users accept all associated
* risks and this disclaimer. The co-founders, developers, or related parties will not bear liability for any consequences of non-compliance.
*
* Redistribution and Use:
* Redistribution, modification, or repurposing of this contract, in whole or in part, is strictly prohibited without express written
* approval from all co-founders. Approval requests must be sent to the official email addresses of the co-founders, ensuring responses
* are received directly from these addresses. Proposals for redistribution, modification, or repurposing must include a detailed explanation
* of the intended changes or uses and the reasons behind them. The co-founders reserve the right to request additional information or
* clarification as necessary. Approval is at the sole discretion of the co-founders and may be subject to conditions to uphold the
* project’s integrity and the values of the Fair Crypto Foundation. Failure to obtain express written approval prior to any redistribution,
* modification, or repurposing will result in a breach of these terms and immediate legal action.
*
* Copyright and License:
* Copyright © 2023 Xenify (Simran Dhillon, Hardev Dhillon, Dayana Plaz). All rights reserved.
* This software is provided 'as is' and may be used by the recipient. No permission is granted for redistribution,
* modification, or repurposing of this contract. Any use beyond the scope defined herein may be subject to legal action.
*/
interface IWormholeReceiver {
/// --------------------------------- EXTERNAL FUNCTION --------------------------------- \\\
/**
* @notice Called by the WormholeRelayer contract to deliver a Wormhole message to this contract.
*
* @dev This function should be implemented to include access controls to ensure that only
* the Wormhole Relayer contract can invoke it.
*
* Implementations should:
* - Maintain a mapping of received `deliveryHash`s to prevent duplicate message delivery.
* - Verify the authenticity of `sourceChain` and `sourceAddress` to prevent unauthorized or malicious calls.
*
* @param payload The arbitrary data included in the message by the sender.
* @param additionalVaas Additional VAAs that were requested to be included in this delivery.
* Guaranteed to be in the same order as specified by the sender.
* @param sourceAddress The Wormhole-formatted address of the message sender on the originating chain.
* @param sourceChain The Wormhole Chain ID of the originating blockchain.
* @param deliveryHash The VAA hash of the deliveryVAA, used to prevent duplicate delivery.
*
* Warning: The provided VAAs are NOT verified by the Wormhole core contract prior to this call.
* Always invoke `parseAndVerify()` on the Wormhole core contract to validate the VAAs before trusting them.
*/
function receiveWormholeMessages(
bytes memory payload,
bytes[] memory additionalVaas,
bytes32 sourceAddress,
uint16 sourceChain,
bytes32 deliveryHash
) external payable;
/// ------------------------------------------------------------------------------------- \\\
}// SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.18;
/**
* @title IWormholeRelayer Interface
*
* @notice This project allows developers to build cross-chain applications powered by Wormhole without needing to
* write and run their own relaying infrastructure. We implement the IWormholeRelayer interface that allows users to
* request a delivery provider to relay a payload (and/or additional VAAs) to a chain and address of their choice.
*
* Co-Founders:
* - Simran Dhillon: simran@xenify.io
* - Hardev Dhillon: hardev@xenify.io
* - Dayana Plaz: dayana@xenify.io
*
* Official Links:
* - Twitter: https://twitter.com/xenify_io
* - Telegram: https://t.me/xenify_io
* - Website: https://xenify.io
*
* Disclaimer:
* This contract aligns with the principles of the Fair Crypto Foundation, promoting self-custody, transparency, consensus-based
* trust, and permissionless value exchange. There are no administrative access keys, underscoring our commitment to decentralization.
* Engaging with this contract involves technical and legal risks. Users must conduct their own due diligence and ensure compliance
* with local laws and regulations. The software is provided "AS-IS," without warranties, and the co-founders and developers disclaim
* all liability for any vulnerabilities, exploits, errors, or breaches that may occur. By using this contract, users accept all associated
* risks and this disclaimer. The co-founders, developers, or related parties will not bear liability for any consequences of non-compliance.
*
* Redistribution and Use:
* Redistribution, modification, or repurposing of this contract, in whole or in part, is strictly prohibited without express written
* approval from all co-founders. Approval requests must be sent to the official email addresses of the co-founders, ensuring responses
* are received directly from these addresses. Proposals for redistribution, modification, or repurposing must include a detailed explanation
* of the intended changes or uses and the reasons behind them. The co-founders reserve the right to request additional information or
* clarification as necessary. Approval is at the sole discretion of the co-founders and may be subject to conditions to uphold the
* project’s integrity and the values of the Fair Crypto Foundation. Failure to obtain express written approval prior to any redistribution,
* modification, or repurposing will result in a breach of these terms and immediate legal action.
*
* Copyright and License:
* Copyright © 2023 Xenify (Simran Dhillon, Hardev Dhillon, Dayana Plaz). All rights reserved.
* This software is provided 'as is' and may be used by the recipient. No permission is granted for redistribution,
* modification, or repurposing of this contract. Any use beyond the scope defined herein may be subject to legal action.
*/
/// ------------------------------------- STRUCTURE ------------------------------------- \\\
/**
* @notice VaaKey identifies a wormhole message.
* @custom:member chainId Wormhole chain ID of the chain where this VAA was emitted from.
* @custom:member emitterAddress Address of the emitter of the VAA, in Wormhole bytes32 format.
* @custom:member sequence Sequence number of the VAA.
*/
struct VaaKey {
uint16 chainId;
bytes32 emitterAddress;
uint64 sequence;
}
/// ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| \\\
/**
* @title IWormholeRelayerBase
* @notice Interface for basic Wormhole Relayer operations.
*/
interface IWormholeRelayerBase {
/// -------------------------------------- EVENT ---------------------------------------- \\\
/**
* @notice Emitted when a Send operation is executed.
* @param sequence The sequence of the send event.
* @param deliveryQuote The delivery quote for the send operation.
* @param paymentForExtraReceiverValue The payment value for the additional receiver.
*/
event SendEvent(
uint64 indexed sequence,
uint256 deliveryQuote,
uint256 paymentForExtraReceiverValue
);
/// --------------------------------- EXTERNAL FUNCTION --------------------------------- \\\
/**
* @notice Fetches the registered Wormhole Relayer contract for a given chain ID.
* @param chainId The chain ID to fetch the relayer contract for.
* @return The address of the registered Wormhole Relayer contract for the given chain ID.
*/
function getRegisteredWormholeRelayerContract(uint16 chainId)
external
view returns (bytes32);
}
/// ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| \\\
/**
* @title IWormholeRelayerSend
* @notice The interface to request deliveries.
*/
interface IWormholeRelayerSend is IWormholeRelayerBase {
/// --------------------------------- EXTERNAL FUNCTIONS -------------------------------- \\\
/**
* @notice Publishes an instruction for the default delivery provider
* to relay a payload to the address `targetAddress` on chain `targetChain`
* with gas limit `gasLimit` and `msg.value` equal to `receiverValue`
*
* `targetAddress` must implement the IWormholeReceiver interface.
*
* This function must be called with `msg.value` equal to `quoteEVMDeliveryPrice(targetChain, receiverValue, gasLimit)`.
*
* Any refunds (from leftover gas) will be paid to the delivery provider. In order to receive the refunds, use the `sendPayloadToEvm` function
* with `refundChain` and `refundAddress` as parameters.
*
* @param targetChain in Wormhole Chain ID format.
* @param targetAddress address to call on targetChain (that implements IWormholeReceiver).
* @param payload arbitrary bytes to pass in as parameter in call to `targetAddress`.
* @param receiverValue msg.value that delivery provider should pass in for call to `targetAddress` (in targetChain currency units).
* @param gasLimit gas limit with which to call `targetAddress`.
* @return sequence sequence number of published VAA containing delivery instructions.
*/
function sendPayloadToEvm(
uint16 targetChain,
address targetAddress,
bytes memory payload,
uint256 receiverValue,
uint256 gasLimit
) external payable returns (uint64 sequence);
/// ------------------------------------------------------------------------------------- \\\
/**
* @notice Publishes an instruction for the default delivery provider.
* to relay a payload to the address `targetAddress` on chain `targetChain`
* with gas limit `gasLimit` and `msg.value` equal to `receiverValue`.
*
* Any refunds (from leftover gas) will be sent to `refundAddress` on chain `refundChain`
* `targetAddress` must implement the IWormholeReceiver interface.
*
* This function must be called with `msg.value` equal to `quoteEVMDeliveryPrice(targetChain, receiverValue, gasLimit)`.
*
* @param targetChain in Wormhole Chain ID format.
* @param targetAddress address to call on targetChain (that implements IWormholeReceiver).
* @param payload arbitrary bytes to pass in as parameter in call to `targetAddress`.
* @param receiverValue msg.value that delivery provider should pass in for call to `targetAddress` (in targetChain currency units).
* @param gasLimit gas limit with which to call `targetAddress`. Any units of gas unused will be refunded according to the
* `targetChainRefundPerGasUnused` rate quoted by the delivery provider.
* @param refundChain The chain to deliver any refund to, in Wormhole Chain ID format.
* @param refundAddress The address on `refundChain` to deliver any refund to.
* @return sequence sequence number of published VAA containing delivery instructions.
*/
function sendPayloadToEvm(
uint16 targetChain,
address targetAddress,
bytes memory payload,
uint256 receiverValue,
uint256 gasLimit,
uint16 refundChain,
address refundAddress
) external payable returns (uint64 sequence);
/// ------------------------------------------------------------------------------------- \\\
/**
* @notice Publishes an instruction for the default delivery provider
* to relay a payload and VAAs specified by `vaaKeys` to the address `targetAddress` on chain `targetChain`
* with gas limit `gasLimit` and `msg.value` equal to `receiverValue`
*
* `targetAddress` must implement the IWormholeReceiver interface
*
* This function must be called with `msg.value` equal to `quoteEVMDeliveryPrice(targetChain, receiverValue, gasLimit)`
*
* Any refunds (from leftover gas) will be paid to the delivery provider. In order to receive the refunds, use the `sendVaasToEvm` function
* with `refundChain` and `refundAddress` as parameters
*
* @param targetChain in Wormhole Chain ID format
* @param targetAddress address to call on targetChain (that implements IWormholeReceiver)
* @param payload arbitrary bytes to pass in as parameter in call to `targetAddress`
* @param receiverValue msg.value that delivery provider should pass in for call to `targetAddress` (in targetChain currency units)
* @param gasLimit gas limit with which to call `targetAddress`.
* @param vaaKeys Additional VAAs to pass in as parameter in call to `targetAddress`
* @return sequence sequence number of published VAA containing delivery instructions
*/
function sendVaasToEvm(
uint16 targetChain,
address targetAddress,
bytes memory payload,
uint256 receiverValue,
uint256 gasLimit,
VaaKey[] memory vaaKeys
) external payable returns (uint64 sequence);
/// ------------------------------------------------------------------------------------- \\\
/**
* @notice Publishes an instruction for the default delivery provider
* to relay a payload and VAAs specified by `vaaKeys` to the address `targetAddress` on chain `targetChain`
* with gas limit `gasLimit` and `msg.value` equal to `receiverValue`
*
* Any refunds (from leftover gas) will be sent to `refundAddress` on chain `refundChain`
* `targetAddress` must implement the IWormholeReceiver interface
*
* This function must be called with `msg.value` equal to `quoteEVMDeliveryPrice(targetChain, receiverValue, gasLimit)`
*
* @param targetChain in Wormhole Chain ID format
* @param targetAddress address to call on targetChain (that implements IWormholeReceiver)
* @param payload arbitrary bytes to pass in as parameter in call to `targetAddress`
* @param receiverValue msg.value that delivery provider should pass in for call to `targetAddress` (in targetChain currency units)
* @param gasLimit gas limit with which to call `targetAddress`. Any units of gas unused will be refunded according to the
* `targetChainRefundPerGasUnused` rate quoted by the delivery provider
* @param vaaKeys Additional VAAs to pass in as parameter in call to `targetAddress`
* @param refundChain The chain to deliver any refund to, in Wormhole Chain ID format
* @param refundAddress The address on `refundChain` to deliver any refund to
* @return sequence sequence number of published VAA containing delivery instructions
*/
function sendVaasToEvm(
uint16 targetChain,
address targetAddress,
bytes memory payload,
uint256 receiverValue,
uint256 gasLimit,
VaaKey[] memory vaaKeys,
uint16 refundChain,
address refundAddress
) external payable returns (uint64 sequence);
/// ------------------------------------------------------------------------------------- \\\
/**
* @notice Publishes an instruction for the delivery provider at `deliveryProviderAddress`
* to relay a payload and VAAs specified by `vaaKeys` to the address `targetAddress` on chain `targetChain`
* with gas limit `gasLimit` and `msg.value` equal to
* receiverValue + (arbitrary amount that is paid for by paymentForExtraReceiverValue of this chain's wei) in targetChain wei.
*
* Any refunds (from leftover gas) will be sent to `refundAddress` on chain `refundChain`
* `targetAddress` must implement the IWormholeReceiver interface
*
* This function must be called with `msg.value` equal to
* quoteEVMDeliveryPrice(targetChain, receiverValue, gasLimit, deliveryProviderAddress) + paymentForExtraReceiverValue
*
* @param targetChain in Wormhole Chain ID format
* @param targetAddress address to call on targetChain (that implements IWormholeReceiver)
* @param payload arbitrary bytes to pass in as parameter in call to `targetAddress`
* @param receiverValue msg.value that delivery provider should pass in for call to `targetAddress` (in targetChain currency units)
* @param paymentForExtraReceiverValue amount (in current chain currency units) to spend on extra receiverValue
* (in addition to the `receiverValue` specified)
* @param gasLimit gas limit with which to call `targetAddress`. Any units of gas unused will be refunded according to the
* `targetChainRefundPerGasUnused` rate quoted by the delivery provider
* @param refundChain The chain to deliver any refund to, in Wormhole Chain ID format
* @param refundAddress The address on `refundChain` to deliver any refund to
* @param deliveryProviderAddress The address of the desired delivery provider's implementation of IDeliveryProvider
* @param vaaKeys Additional VAAs to pass in as parameter in call to `targetAddress`
* @param consistencyLevel Consistency level with which to publish the delivery instructions - see
* https://book.wormhole.com/wormhole/3_coreLayerContracts.html?highlight=consistency#consistency-levels
* @return sequence sequence number of published VAA containing delivery instructions
*/
function sendToEvm(
uint16 targetChain,
address targetAddress,
bytes memory payload,
uint256 receiverValue,
uint256 paymentForExtraReceiverValue,
uint256 gasLimit,
uint16 refundChain,
address refundAddress,
address deliveryProviderAddress,
VaaKey[] memory vaaKeys,
uint8 consistencyLevel
) external payable returns (uint64 sequence);
/// ------------------------------------------------------------------------------------- \\\
/**
* @notice Publishes an instruction for the delivery provider at `deliveryProviderAddress`
* to relay a payload and VAAs specified by `vaaKeys` to the address `targetAddress` on chain `targetChain`
* with `msg.value` equal to
* receiverValue + (arbitrary amount that is paid for by paymentForExtraReceiverValue of this chain's wei) in targetChain wei.
*
* Any refunds (from leftover gas) will be sent to `refundAddress` on chain `refundChain`
* `targetAddress` must implement the IWormholeReceiver interface
*
* This function must be called with `msg.value` equal to
* quoteDeliveryPrice(targetChain, receiverValue, encodedExecutionParameters, deliveryProviderAddress) + paymentForExtraReceiverValue
*
* @param targetChain in Wormhole Chain ID format
* @param targetAddress address to call on targetChain (that implements IWormholeReceiver), in Wormhole bytes32 format
* @param payload arbitrary bytes to pass in as parameter in call to `targetAddress`
* @param receiverValue msg.value that delivery provider should pass in for call to `targetAddress` (in targetChain currency units)
* @param paymentForExtraReceiverValue amount (in current chain currency units) to spend on extra receiverValue
* (in addition to the `receiverValue` specified)
* @param encodedExecutionParameters encoded information on how to execute delivery that may impact pricing
* e.g. for version EVM_V1, this is a struct that encodes the `gasLimit` with which to call `targetAddress`
* @param refundChain The chain to deliver any refund to, in Wormhole Chain ID format
* @param refundAddress The address on `refundChain` to deliver any refund to, in Wormhole bytes32 format
* @param deliveryProviderAddress The address of the desired delivery provider's implementation of IDeliveryProvider
* @param vaaKeys Additional VAAs to pass in as parameter in call to `targetAddress`
* @param consistencyLevel Consistency level with which to publish the delivery instructions - see
* https://book.wormhole.com/wormhole/3_coreLayerContracts.html?highlight=consistency#consistency-levels
* @return sequence sequence number of published VAA containing delivery instructions
*/
function send(
uint16 targetChain,
bytes32 targetAddress,
bytes memory payload,
uint256 receiverValue,
uint256 paymentForExtraReceiverValue,
bytes memory encodedExecutionParameters,
uint16 refundChain,
bytes32 refundAddress,
address deliveryProviderAddress,
VaaKey[] memory vaaKeys,
uint8 consistencyLevel
) external payable returns (uint64 sequence);
/// ------------------------------------------------------------------------------------- \\\
/**
* @notice Performs the same function as a `send`, except:
* 1) Can only be used during a delivery (i.e. in execution of `receiveWormholeMessages`)
* 2) Is paid for (along with any other calls to forward) by (any msg.value passed in) + (refund leftover from current delivery)
* 3) Only executes after `receiveWormholeMessages` is completed (and thus does not return a sequence number)
*
* The refund from the delivery currently in progress will not be sent to the user; it will instead
* be paid to the delivery provider to perform the instruction specified here
*
* Publishes an instruction for the same delivery provider (or default, if the same one doesn't support the new target chain)
* to relay a payload to the address `targetAddress` on chain `targetChain`
* with gas limit `gasLimit` and with `msg.value` equal to `receiverValue`
*
* The following equation must be satisfied (sum_f indicates summing over all forwards requested in `receiveWormholeMessages`):
* (refund amount from current execution of receiveWormholeMessages) + sum_f [msg.value_f]
* >= sum_f [quoteEVMDeliveryPrice(targetChain_f, receiverValue_f, gasLimit_f)]
*
* The difference between the two sides of the above inequality will be added to `paymentForExtraReceiverValue` of the first forward requested
*
* Any refunds (from leftover gas) from this forward will be paid to the same refundChain and refundAddress specified for the current delivery.
*
* @param targetChain in Wormhole Chain ID format
* @param targetAddress address to call on targetChain (that implements IWormholeReceiver), in Wormhole bytes32 format
* @param payload arbitrary bytes to pass in as parameter in call to `targetAddress`
* @param receiverValue msg.value that delivery provider should pass in for call to `targetAddress` (in targetChain currency units)
* @param gasLimit gas limit with which to call `targetAddress`.
*/
function forwardPayloadToEvm(
uint16 targetChain,
address targetAddress,
bytes memory payload,
uint256 receiverValue,
uint256 gasLimit
) external payable;
/// ------------------------------------------------------------------------------------- \\\
/**
* @notice Performs the same function as a `send`, except:
* 1) Can only be used during a delivery (i.e. in execution of `receiveWormholeMessages`)
* 2) Is paid for (along with any other calls to forward) by (any msg.value passed in) + (refund leftover from current delivery)
* 3) Only executes after `receiveWormholeMessages` is completed (and thus does not return a sequence number)
*
* The refund from the delivery currently in progress will not be sent to the user; it will instead
* be paid to the delivery provider to perform the instruction specified here
*
* Publishes an instruction for the same delivery provider (or default, if the same one doesn't support the new target chain)
* to relay a payload and VAAs specified by `vaaKeys` to the address `targetAddress` on chain `targetChain`
* with gas limit `gasLimit` and with `msg.value` equal to `receiverValue`
*
* The following equation must be satisfied (sum_f indicates summing over all forwards requested in `receiveWormholeMessages`):
* (refund amount from current execution of receiveWormholeMessages) + sum_f [msg.value_f]
* >= sum_f [quoteEVMDeliveryPrice(targetChain_f, receiverValue_f, gasLimit_f)]
*
* The difference between the two sides of the above inequality will be added to `paymentForExtraReceiverValue` of the first forward requested
*
* Any refunds (from leftover gas) from this forward will be paid to the same refundChain and refundAddress specified for the current delivery.
*
* @param targetChain in Wormhole Chain ID format
* @param targetAddress address to call on targetChain (that implements IWormholeReceiver), in Wormhole bytes32 format
* @param payload arbitrary bytes to pass in as parameter in call to `targetAddress`
* @param receiverValue msg.value that delivery provider should pass in for call to `targetAddress` (in targetChain currency units)
* @param gasLimit gas limit with which to call `targetAddress`.
* @param vaaKeys Additional VAAs to pass in as parameter in call to `targetAddress`
*/
function forwardVaasToEvm(
uint16 targetChain,
address targetAddress,
bytes memory payload,
uint256 receiverValue,
uint256 gasLimit,
VaaKey[] memory vaaKeys
) external payable;
/// ------------------------------------------------------------------------------------- \\\
/**
* @notice Performs the same function as a `send`, except:
* 1) Can only be used during a delivery (i.e. in execution of `receiveWormholeMessages`)
* 2) Is paid for (along with any other calls to forward) by (any msg.value passed in) + (refund leftover from current delivery)
* 3) Only executes after `receiveWormholeMessages` is completed (and thus does not return a sequence number)
*
* The refund from the delivery currently in progress will not be sent to the user; it will instead
* be paid to the delivery provider to perform the instruction specified here
*
* Publishes an instruction for the delivery provider at `deliveryProviderAddress`
* to relay a payload and VAAs specified by `vaaKeys` to the address `targetAddress` on chain `targetChain`
* with gas limit `gasLimit` and with `msg.value` equal to
* receiverValue + (arbitrary amount that is paid for by paymentForExtraReceiverValue of this chain's wei) in targetChain wei.
*
* Any refunds (from leftover gas) will be sent to `refundAddress` on chain `refundChain`
* `targetAddress` must implement the IWormholeReceiver interface
*
* The following equation must be satisfied (sum_f indicates summing over all forwards requested in `receiveWormholeMessages`):
* (refund amount from current execution of receiveWormholeMessages) + sum_f [msg.value_f]
* >= sum_f [quoteEVMDeliveryPrice(targetChain_f, receiverValue_f, gasLimit_f, deliveryProviderAddress_f) + paymentForExtraReceiverValue_f]
*
* The difference between the two sides of the above inequality will be added to `paymentForExtraReceiverValue` of the first forward requested
*
* @param targetChain in Wormhole Chain ID format
* @param targetAddress address to call on targetChain (that implements IWormholeReceiver), in Wormhole bytes32 format
* @param payload arbitrary bytes to pass in as parameter in call to `targetAddress`
* @param receiverValue msg.value that delivery provider should pass in for call to `targetAddress` (in targetChain currency units)
* @param paymentForExtraReceiverValue amount (in current chain currency units) to spend on extra receiverValue
* (in addition to the `receiverValue` specified)
* @param gasLimit gas limit with which to call `targetAddress`. Any units of gas unused will be refunded according to the
* `targetChainRefundPerGasUnused` rate quoted by the delivery provider
* @param refundChain The chain to deliver any refund to, in Wormhole Chain ID format
* @param refundAddress The address on `refundChain` to deliver any refund to, in Wormhole bytes32 format
* @param deliveryProviderAddress The address of the desired delivery provider's implementation of IDeliveryProvider
* @param vaaKeys Additional VAAs to pass in as parameter in call to `targetAddress`
* @param consistencyLevel Consistency level with which to publish the delivery instructions - see
* https://book.wormhole.com/wormhole/3_coreLayerContracts.html?highlight=consistency#consistency-levels
*/
function forwardToEvm(
uint16 targetChain,
address targetAddress,
bytes memory payload,
uint256 receiverValue,
uint256 paymentForExtraReceiverValue,
uint256 gasLimit,
uint16 refundChain,
address refundAddress,
address deliveryProviderAddress,
VaaKey[] memory vaaKeys,
uint8 consistencyLevel
) external payable;
/// ------------------------------------------------------------------------------------- \\\
/**
* @notice Performs the same function as a `send`, except:
* 1) Can only be used during a delivery (i.e. in execution of `receiveWormholeMessages`)
* 2) Is paid for (along with any other calls to forward) by (any msg.value passed in) + (refund leftover from current delivery)
* 3) Only executes after `receiveWormholeMessages` is completed (and thus does not return a sequence number)
*
* The refund from the delivery currently in progress will not be sent to the user; it will instead
* be paid to the delivery provider to perform the instruction specified here
*
* Publishes an instruction for the delivery provider at `deliveryProviderAddress`
* to relay a payload and VAAs specified by `vaaKeys` to the address `targetAddress` on chain `targetChain`
* with `msg.value` equal to
* receiverValue + (arbitrary amount that is paid for by paymentForExtraReceiverValue of this chain's wei) in targetChain wei.
*
* Any refunds (from leftover gas) will be sent to `refundAddress` on chain `refundChain`
* `targetAddress` must implement the IWormholeReceiver interface
*
* The following equation must be satisfied (sum_f indicates summing over all forwards requested in `receiveWormholeMessages`):
* (refund amount from current execution of receiveWormholeMessages) + sum_f [msg.value_f]
* >= sum_f [quoteDeliveryPrice(targetChain_f, receiverValue_f, encodedExecutionParameters_f, deliveryProviderAddress_f) + paymentForExtraReceiverValue_f]
*
* The difference between the two sides of the above inequality will be added to `paymentForExtraReceiverValue` of the first forward requested
*
* @param targetChain in Wormhole Chain ID format
* @param targetAddress address to call on targetChain (that implements IWormholeReceiver), in Wormhole bytes32 format
* @param payload arbitrary bytes to pass in as parameter in call to `targetAddress`
* @param receiverValue msg.value that delivery provider should pass in for call to `targetAddress` (in targetChain currency units)
* @param paymentForExtraReceiverValue amount (in current chain currency units) to spend on extra receiverValue
* (in addition to the `receiverValue` specified)
* @param encodedExecutionParameters encoded information on how to execute delivery that may impact pricing
* e.g. for version EVM_V1, this is a struct that encodes the `gasLimit` with which to call `targetAddress`
* @param refundChain The chain to deliver any refund to, in Wormhole Chain ID format
* @param refundAddress The address on `refundChain` to deliver any refund to, in Wormhole bytes32 format
* @param deliveryProviderAddress The address of the desired delivery provider's implementation of IDeliveryProvider
* @param vaaKeys Additional VAAs to pass in as parameter in call to `targetAddress`
* @param consistencyLevel Consistency level with which to publish the delivery instructions - see
* https://book.wormhole.com/wormhole/3_coreLayerContracts.html?highlight=consistency#consistency-levels
*/
function forward(
uint16 targetChain,
bytes32 targetAddress,
bytes memory payload,
uint256 receiverValue,
uint256 paymentForExtraReceiverValue,
bytes memory encodedExecutionParameters,
uint16 refundChain,
bytes32 refundAddress,
address deliveryProviderAddress,
VaaKey[] memory vaaKeys,
uint8 consistencyLevel
) external payable;
/// ------------------------------------------------------------------------------------- \\\
/**
* @notice Requests a previously published delivery instruction to be redelivered
* (e.g. with a different delivery provider)
*
* This function must be called with `msg.value` equal to
* quoteEVMDeliveryPrice(targetChain, newReceiverValue, newGasLimit, newDeliveryProviderAddress)
*
* @notice *** This will only be able to succeed if the following is true **
* - newGasLimit >= gas limit of the old instruction
* - newReceiverValue >= receiver value of the old instruction
* - newDeliveryProvider's `targetChainRefundPerGasUnused` >= old relay provider's `targetChainRefundPerGasUnused`
*
* @param deliveryVaaKey VaaKey identifying the wormhole message containing the
* previously published delivery instructions
* @param targetChain The target chain that the original delivery targeted. Must match targetChain from original delivery instructions
* @param newReceiverValue new msg.value that delivery provider should pass in for call to `targetAddress` (in targetChain currency units)
* @param newGasLimit gas limit with which to call `targetAddress`. Any units of gas unused will be refunded according to the
* `targetChainRefundPerGasUnused` rate quoted by the delivery provider, to the refund chain and address specified in the original request
* @param newDeliveryProviderAddress The address of the desired delivery provider's implementation of IDeliveryProvider
* @return sequence sequence number of published VAA containing redelivery instructions
*
* @notice *** This will only be able to succeed if the following is true **
* - newGasLimit >= gas limit of the old instruction
* - newReceiverValue >= receiver value of the old instruction
* - newDeliveryProvider's `targetChainRefundPerGasUnused` >= old relay provider's `targetChainRefundPerGasUnused`
*/
function resendToEvm(
VaaKey memory deliveryVaaKey,
uint16 targetChain,
uint256 newReceiverValue,
uint256 newGasLimit,
address newDeliveryProviderAddress
)
external
payable
returns (uint64 sequence);
/// ------------------------------------------------------------------------------------- \\\
/**
* @notice Requests a previously published delivery instruction to be redelivered
*
*
* This function must be called with `msg.value` equal to
* quoteDeliveryPrice(targetChain, newReceiverValue, newEncodedExecutionParameters, newDeliveryProviderAddress)
*
* @param deliveryVaaKey VaaKey identifying the wormhole message containing the
* previously published delivery instructions
* @param targetChain The target chain that the original delivery targeted. Must match targetChain from original delivery instructions
* @param newReceiverValue new msg.value that delivery provider should pass in for call to `targetAddress` (in targetChain currency units)
* @param newEncodedExecutionParameters new encoded information on how to execute delivery that may impact pricing
* e.g. for version EVM_V1, this is a struct that encodes the `gasLimit` with which to call `targetAddress`
* @param newDeliveryProviderAddress The address of the desired delivery provider's implementation of IDeliveryProvider
* @return sequence sequence number of published VAA containing redelivery instructions
*
* @notice *** This will only be able to succeed if the following is true **
* - (For EVM_V1) newGasLimit >= gas limit of the old instruction
* - newReceiverValue >= receiver value of the old instruction
* - (For EVM_V1) newDeliveryProvider's `targetChainRefundPerGasUnused` >= old relay provider's `targetChainRefundPerGasUnused`
*/
function resend(
VaaKey memory deliveryVaaKey,
uint16 targetChain,
uint256 newReceiverValue,
bytes memory newEncodedExecutionParameters,
address newDeliveryProviderAddress
)
external
payable
returns (uint64 sequence);
/// ------------------------------------------------------------------------------------- \\\
/**
* @notice Returns the price to request a relay to chain `targetChain`, using the default delivery provider
*
* @param targetChain in Wormhole Chain ID format
* @param receiverValue msg.value that delivery provider should pass in for call to `targetAddress` (in targetChain currency units)
* @param gasLimit gas limit with which to call `targetAddress`.
* @return nativePriceQuote Price, in units of current chain currency, that the delivery provider charges to perform the relay
* @return targetChainRefundPerGasUnused amount of target chain currency that will be refunded per unit of gas unused,
* if a refundAddress is specified
*/
function quoteEVMDeliveryPrice(
uint16 targetChain,
uint256 receiverValue,
uint256 gasLimit
)
external
view
returns (uint256 nativePriceQuote, uint256 targetChainRefundPerGasUnused);
/// ------------------------------------------------------------------------------------- \\\
/**
* @notice Returns the price to request a relay to chain `targetChain`, using delivery provider `deliveryProviderAddress`
*
* @param targetChain in Wormhole Chain ID format
* @param receiverValue msg.value that delivery provider should pass in for call to `targetAddress` (in targetChain currency units)
* @param gasLimit gas limit with which to call `targetAddress`.
* @param deliveryProviderAddress The address of the desired delivery provider's implementation of IDeliveryProvider
* @return nativePriceQuote Price, in units of current chain currency, that the delivery provider charges to perform the relay
* @return targetChainRefundPerGasUnused amount of target chain currency that will be refunded per unit of gas unused,
* if a refundAddress is specified
*/
function quoteEVMDeliveryPrice(
uint16 targetChain,
uint256 receiverValue,
uint256 gasLimit,
address deliveryProviderAddress
)
external
view
returns (
uint256 nativePriceQuote,
uint256 targetChainRefundPerGasUnused
);
/// ------------------------------------------------------------------------------------- \\\
/**
* @notice Returns the price to request a relay to chain `targetChain`, using delivery provider `deliveryProviderAddress`
*
* @param targetChain in Wormhole Chain ID format
* @param receiverValue msg.value that delivery provider should pass in for call to `targetAddress` (in targetChain currency units)
* @param encodedExecutionParameters encoded information on how to execute delivery that may impact pricing
* e.g. for version EVM_V1, this is a struct that encodes the `gasLimit` with which to call `targetAddress`
* @param deliveryProviderAddress The address of the desired delivery provider's implementation of IDeliveryProvider
* @return nativePriceQuote Price, in units of current chain currency, that the delivery provider charges to perform the relay
* @return encodedExecutionInfo encoded information on how the delivery will be executed
* e.g. for version EVM_V1, this is a struct that encodes the `gasLimit` and `targetChainRefundPerGasUnused`
* (which is the amount of target chain currency that will be refunded per unit of gas unused,
* if a refundAddress is specified)
*/
function quoteDeliveryPrice(
uint16 targetChain,
uint256 receiverValue,
bytes memory encodedExecutionParameters,
address deliveryProviderAddress
)
external
view
returns (
uint256 nativePriceQuote,
bytes memory encodedExecutionInfo
);
/// ------------------------------------------------------------------------------------- \\\
/**
* @notice Returns the (extra) amount of target chain currency that `targetAddress`
* will be called with, if the `paymentForExtraReceiverValue` field is set to `currentChainAmount`
*
* @param targetChain in Wormhole Chain ID format
* @param currentChainAmount The value that `paymentForExtraReceiverValue` will be set to
* @param deliveryProviderAddress The address of the desired delivery provider's implementation of IDeliveryProvider
* @return targetChainAmount The amount such that if `targetAddress` will be called with `msg.value` equal to
* receiverValue + targetChainAmount
*/
function quoteNativeForChain(
uint16 targetChain,
uint256 currentChainAmount,
address deliveryProviderAddress
)
external
view
returns (uint256 targetChainAmount);
/// ------------------------------------------------------------------------------------- \\\
/**
* @notice Returns the address of the current default delivery provider
* @return deliveryProvider The address of (the default delivery provider)'s contract on this source
* chain. This must be a contract that implements IDeliveryProvider.
*/
function getDefaultDeliveryProvider()
external
view
returns (address deliveryProvider);
}
/// ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| \\\
/**
* @title IWormholeRelayerDelivery
* @notice The interface to execute deliveries. Only relevant for Delivery Providers
*/
interface IWormholeRelayerDelivery is IWormholeRelayerBase {
/// -------------------------------------- ENUMS ---------------------------------------- \\\
/**
* @notice Represents the possible statuses of a delivery.
*/
enum DeliveryStatus {
SUCCESS,
RECEIVER_FAILURE,
FORWARD_REQUEST_FAILURE,
FORWARD_REQUEST_SUCCESS
}
/// ------------------------------------------------------------------------------------- \\\
/**
* @notice Represents the possible statuses of a refund after a delivery attempt.
*/
enum RefundStatus {
REFUND_SENT,
REFUND_FAIL,
CROSS_CHAIN_REFUND_SENT,
CROSS_CHAIN_REFUND_FAIL_PROVIDER_NOT_SUPPORTED,
CROSS_CHAIN_REFUND_FAIL_NOT_ENOUGH
}
/// -------------------------------------- EVENT ---------------------------------------- \\\
/**
* @custom:member recipientContract - The target contract address
* @custom:member sourceChain - The chain which this delivery was requested from (in wormhole
* ChainID format)
* @custom:member sequence - The wormhole sequence number of the delivery VAA on the source chain
* corresponding to this delivery request
* @custom:member deliveryVaaHash - The hash of the delivery VAA corresponding to this delivery
* request
* @custom:member gasUsed - The amount of gas that was used to call your target contract
* @custom:member status:
* - RECEIVER_FAILURE, if the target contract reverts
* - SUCCESS, if the target contract doesn't revert and no forwards were requested
* - FORWARD_REQUEST_FAILURE, if the target contract doesn't revert, forwards were requested,
* but provided/leftover funds were not sufficient to cover them all
* - FORWARD_REQUEST_SUCCESS, if the target contract doesn't revert and all forwards are covered
* @custom:member additionalStatusInfo:
* - If status is SUCCESS or FORWARD_REQUEST_SUCCESS, then this is empty.
* - If status is RECEIVER_FAILURE, this is `RETURNDATA_TRUNCATION_THRESHOLD` bytes of the
* return data (i.e. potentially truncated revert reason information).
* - If status is FORWARD_REQUEST_FAILURE, this is also the revert data - the reason the forward failed.
* This will be either an encoded Cancelled, DeliveryProviderReverted, or DeliveryProviderPaymentFailed error
* @custom:member refundStatus - Result of the refund. REFUND_SUCCESS or REFUND_FAIL are for
* refunds where targetChain=refundChain; the others are for targetChain!=refundChain,
* where a cross chain refund is necessary
* @custom:member overridesInfo:
* - If not an override: empty bytes array
* - Otherwise: An encoded `DeliveryOverride`
*/
event Delivery(
address indexed recipientContract,
uint16 indexed sourceChain,
uint64 indexed sequence,
bytes32 deliveryVaaHash,
DeliveryStatus status,
uint256 gasUsed,
RefundStatus refundStatus,
bytes additionalStatusInfo,
bytes overridesInfo
);
/// --------------------------------- EXTERNAL FUNCTION --------------------------------- \\\
/**
* @notice The delivery provider calls `deliver` to relay messages as described by one delivery instruction
*
* The delivery provider must pass in the specified (by VaaKeys[]) signed wormhole messages (VAAs) from the source chain
* as well as the signed wormhole message with the delivery instructions (the delivery VAA)
*
* The messages will be relayed to the target address (with the specified gas limit and receiver value) iff the following checks are met:
* - the delivery VAA has a valid signature
* - the delivery VAA's emitter is one of these WormholeRelayer contracts
* - the delivery provider passed in at least enough of this chain's currency as msg.value (enough meaning the maximum possible refund)
* - the instruction's target chain is this chain
* - the relayed signed VAAs match the descriptions in container.messages (the VAA hashes match, or the emitter address, sequence number pair matches, depending on the description given)
*
* @param encodedVMs - An array of signed wormhole messages (all from the same source chain
* transaction)
* @param encodedDeliveryVAA - Signed wormhole message from the source chain's WormholeRelayer
* contract with payload being the encoded delivery instruction container
* @param relayerRefundAddress - The address to which any refunds to the delivery provider
* should be sent
* @param deliveryOverrides - Optional overrides field which must be either an empty bytes array or
* an encoded DeliveryOverride struct
*/
function deliver(
bytes[] memory encodedVMs,
bytes memory encodedDeliveryVAA,
address payable relayerRefundAddress,
bytes memory deliveryOverrides
) external payable;
}
/// ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| \\\
/**
* @title IWormholeRelayer
* @notice Interface for the primary Wormhole Relayer which aggregates the functionalities of the Delivery and Send interfaces.
*/
interface IWormholeRelayer is
IWormholeRelayerDelivery,
IWormholeRelayerSend {}
// Bound chosen by the following formula: `memoryWord * 4 + selectorSize`.
// This means that an error identifier plus four fixed size arguments should be available to developers.
// In the case of a `require` revert with error message, this should provide 2 memory word's worth of data.
uint256 constant RETURNDATA_TRUNCATION_THRESHOLD = 132;
/// ------------------------------------------------------------------------------------- \\\
/**
* Errors related to conversion and validation of EVM addresses.
*/
error NotAnEvmAddress(bytes32);
/// ------------------------------------------------------------------------------------- \\\
/**
* Errors related to unauthorized access or usage.
*/
error RequesterNotWormholeRelayer();
/// ------------------------------------------------------------------------------------- \\\
/**
* Errors for when there are issues with the overrides provided.
*/
error InvalidOverrideGasLimit();
error InvalidOverrideReceiverValue();
error InvalidOverrideRefundPerGasUnused();
/// ------------------------------------------------------------------------------------- \\\
/**
* Errors related to the state and progress of the WormholeRelayer's operations.
*/
error NoDeliveryInProgress();
error ReentrantDelivery(address msgSender, address lockedBy);
/// ------------------------------------------------------------------------------------- \\\
/**
* Errors related to funding and refunds.
*/
error InsufficientRelayerFunds(uint256 msgValue, uint256 minimum);
/// ------------------------------------------------------------------------------------- \\\
/**
* Errors related to the VAA (signed wormhole message) validation.
*/
error VaaKeysDoNotMatchVaas(uint8 index);
error VaaKeysLengthDoesNotMatchVaasLength(uint256 keys, uint256 vaas);
error InvalidEmitter(bytes32 emitter, bytes32 registered, uint16 chainId);
/// ------------------------------------------------------------------------------------- \\\
/**
* Errors related to payment values and delivery prices.
*/
error RequestedGasLimitTooLow();
error DeliveryProviderCannotReceivePayment();
error InvalidMsgValue(uint256 msgValue, uint256 totalFee);
error DeliveryProviderDoesNotSupportTargetChain(address relayer, uint16 chainId);
/// ------------------------------------------------------------------------------------- \\\
/**
* Errors for when there are issues with forwarding or delivery.
*/
error InvalidVaaKeyType(uint8 parsed);
error InvalidDeliveryVaa(string reason);
error InvalidPayloadId(uint8 parsed, uint8 expected);
error InvalidPayloadLength(uint256 received, uint256 expected);
error ForwardRequestFromWrongAddress(address msgSender, address deliveryTarget);
/// ------------------------------------------------------------------------------------- \\\
/**
* Errors related to relaying instructions and target chains.
*/
error TargetChainIsNotThisChain(uint16 targetChain);
error ForwardNotSufficientlyFunded(uint256 amountOfFunds, uint256 amountOfFundsNeeded);
/// ------------------------------------------------------------------------------------- \\\// SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.18;
import {ILayerZeroReceiver} from "@layerzerolabs/lz-evm-sdk-v1-0.7/contracts/interfaces/ILayerZeroReceiver.sol";
import {IWormholeReceiver} from "./IWormholeReceiver.sol";
import {IWormholeRelayer} from "./IWormholeRelayer.sol";
/*
* @title YSL interface
*
* @notice This interface outlines functions for the YSL token, which is an ERC20 token with additional
* functionality for bridging and burning.
*
* Co-Founders:
* - Simran Dhillon: simran@xenify.io
* - Hardev Dhillon: hardev@xenify.io
* - Dayana Plaz: dayana@xenify.io
*
* Official Links:
* - Twitter: https://twitter.com/xenify_io
* - Telegram: https://t.me/xenify_io
* - Website: https://xenify.io
*
* Disclaimer:
* This contract aligns with the principles of the Fair Crypto Foundation, promoting self-custody, transparency, consensus-based
* trust, and permissionless value exchange. There are no administrative access keys, underscoring our commitment to decentralization.
* Engaging with this contract involves technical and legal risks. Users must conduct their own due diligence and ensure compliance
* with local laws and regulations. The software is provided "AS-IS," without warranties, and the co-founders and developers disclaim
* all liability for any vulnerabilities, exploits, errors, or breaches that may occur. By using this contract, users accept all associated
* risks and this disclaimer. The co-founders, developers, or related parties will not bear liability for any consequences of non-compliance.
*
* Redistribution and Use:
* Redistribution, modification, or repurposing of this contract, in whole or in part, is strictly prohibited without express written
* approval from all co-founders. Approval requests must be sent to the official email addresses of the co-founders, ensuring responses
* are received directly from these addresses. Proposals for redistribution, modification, or repurposing must include a detailed explanation
* of the intended changes or uses and the reasons behind them. The co-founders reserve the right to request additional information or
* clarification as necessary. Approval is at the sole discretion of the co-founders and may be subject to conditions to uphold the
* project’s integrity and the values of the Fair Crypto Foundation. Failure to obtain express written approval prior to any redistribution,
* modification, or repurposing will result in a breach of these terms and immediate legal action.
*
* Copyright and License:
* Copyright © 2023 Xenify (Simran Dhillon, Hardev Dhillon, Dayana Plaz). All rights reserved.
* This software is provided 'as is' and may be used by the recipient. No permission is granted for redistribution,
* modification, or repurposing of this contract. Any use beyond the scope defined herein may be subject to legal action.
*/
interface IYSL
{
/// -------------------------------------- ERRORS --------------------------------------- \\\
/**
* @notice This error is thrown when an invalid claim proof is provided.
*/
error InvalidClaimProof();
/**
* @notice This error is thrown when the claim period has expired.
*/
error ClaimPeriodExpired();
/**
* @notice This error is thrown when an airdrop has already been claimed.
*/
error AirdropAlreadyClaimed();
/// -------------------------------------- EVENTS --------------------------------------- \\\
/**
* @notice Emitted when a user successfully claims their airdrop.
* @param user Address of the user claiming the airdrop.
* @param amount Amount of YSL claimed.
*/
event Airdropped(
address indexed user,
uint256 amount
);
/// --------------------------------- EXTERNAL FUNCTIONS -------------------------------- \\\
/**
* @notice Burns a specified amount of tokens from a user's address.
* @dev Only addresses with the required allowance can burn tokens on behalf of a user.
* @param _user Address from which tokens will be burned.
* @param _amount Amount of tokens to burn.
*/
function burn(
address _user,
uint256 _amount
) external;
/// ------------------------------------------------------------------------------------- \\\
/**
* @notice Allows users to claim their airdropped tokens using a Merkle proof.
* @dev Verifies the Merkle proof against the stored Merkle root and mints the claimed amount to the user.
* @param proof Array of bytes32 values representing the Merkle proof.
* @param account Address of the user claiming the airdrop.
* @param amount Amount of tokens being claimed.
*/
function claim(
bytes32[] calldata proof,
address account,
uint256 amount
) external;
/// ------------------------------------------------------------------------------------- \\\
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.2) (utils/cryptography/MerkleProof.sol)
pragma solidity ^0.8.0;
/**
* @dev These functions deal with verification of Merkle Tree proofs.
*
* The tree and the proofs can be generated using our
* https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
* You will find a quickstart guide in the readme.
*
* WARNING: You should avoid using leaf values that are 64 bytes long prior to
* hashing, or use a hash function other than keccak256 for hashing leaves.
* This is because the concatenation of a sorted pair of internal nodes in
* the merkle tree could be reinterpreted as a leaf value.
* OpenZeppelin's JavaScript library generates merkle trees that are safe
* against this attack out of the box.
*/
library MerkleProof {
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*/
function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
return processProof(proof, leaf) == root;
}
/**
* @dev Calldata version of {verify}
*
* _Available since v4.7._
*/
function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
return processProofCalldata(proof, leaf) == root;
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
* hash matches the root of the tree. When processing the proof, the pairs
* of leafs & pre-images are assumed to be sorted.
*
* _Available since v4.4._
*/
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = _hashPair(computedHash, proof[i]);
}
return computedHash;
}
/**
* @dev Calldata version of {processProof}
*
* _Available since v4.7._
*/
function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = _hashPair(computedHash, proof[i]);
}
return computedHash;
}
/**
* @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by
* `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
*
* CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
*
* _Available since v4.7._
*/
function multiProofVerify(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProof(proof, proofFlags, leaves) == root;
}
/**
* @dev Calldata version of {multiProofVerify}
*
* CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
*
* _Available since v4.7._
*/
function multiProofVerifyCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProofCalldata(proof, proofFlags, leaves) == root;
}
/**
* @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
* proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
* leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
* respectively.
*
* CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
* is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
* tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
*
* _Available since v4.7._
*/
function processMultiProof(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
// This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
// consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
// `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
// the merkle tree.
uint256 leavesLen = leaves.length;
uint256 proofLen = proof.length;
uint256 totalHashes = proofFlags.length;
// Check proof validity.
require(leavesLen + proofLen - 1 == totalHashes, "MerkleProof: invalid multiproof");
// The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
// `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
bytes32[] memory hashes = new bytes32[](totalHashes);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
// At each step, we compute the next hash using two values:
// - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
// get the next hash.
// - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
// `proof` array.
for (uint256 i = 0; i < totalHashes; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i]
? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
: proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
require(proofPos == proofLen, "MerkleProof: invalid multiproof");
unchecked {
return hashes[totalHashes - 1];
}
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
/**
* @dev Calldata version of {processMultiProof}.
*
* CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
*
* _Available since v4.7._
*/
function processMultiProofCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
// This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
// consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
// `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
// the merkle tree.
uint256 leavesLen = leaves.length;
uint256 proofLen = proof.length;
uint256 totalHashes = proofFlags.length;
// Check proof validity.
require(leavesLen + proofLen - 1 == totalHashes, "MerkleProof: invalid multiproof");
// The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
// `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
bytes32[] memory hashes = new bytes32[](totalHashes);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
// At each step, we compute the next hash using two values:
// - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
// get the next hash.
// - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
// `proof` array.
for (uint256 i = 0; i < totalHashes; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i]
? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
: proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
require(proofPos == proofLen, "MerkleProof: invalid multiproof");
unchecked {
return hashes[totalHashes - 1];
}
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
/// @solidity memory-safe-assembly
assembly {
mstore(0x00, a)
mstore(0x20, b)
value := keccak256(0x00, 0x40)
}
}
}
// SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.18;
import {MerkleProof} from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IYSL} from "./interfaces/IYSL.sol";
/*
* @title YSL Contract
*
* @notice This contract implements the YSL token, which is an ERC20 token with additional
* functionality for bridging and burning.
*
* Co-Founders:
* - Simran Dhillon: simran@xenify.io
* - Hardev Dhillon: hardev@xenify.io
* - Dayana Plaz: dayana@xenify.io
*
* Official Links:
* - Twitter: https://twitter.com/xenify_io
* - Telegram: https://t.me/xenify_io
* - Website: https://xenify.io
*
* Disclaimer:
* This contract aligns with the principles of the Fair Crypto Foundation, promoting self-custody, transparency, consensus-based
* trust, and permissionless value exchange. There are no administrative access keys, underscoring our commitment to decentralization.
* Engaging with this contract involves technical and legal risks. Users must conduct their own due diligence and ensure compliance
* with local laws and regulations. The software is provided "AS-IS," without warranties, and the co-founders and developers disclaim
* all liability for any vulnerabilities, exploits, errors, or breaches that may occur. By using this contract, users accept all associated
* risks and this disclaimer. The co-founders, developers, or related parties will not bear liability for any consequences of non-compliance.
*
* Redistribution and Use:
* Redistribution, modification, or repurposing of this contract, in whole or in part, is strictly prohibited without express written
* approval from all co-founders. Approval requests must be sent to the official email addresses of the co-founders, ensuring responses
* are received directly from these addresses. Proposals for redistribution, modification, or repurposing must include a detailed explanation
* of the intended changes or uses and the reasons behind them. The co-founders reserve the right to request additional information or
* clarification as necessary. Approval is at the sole discretion of the co-founders and may be subject to conditions to uphold the
* project’s integrity and the values of the Fair Crypto Foundation. Failure to obtain express written approval prior to any redistribution,
* modification, or repurposing will result in a breach of these terms and immediate legal action.
*
* Copyright and License:
* Copyright © 2023 Xenify (Simran Dhillon, Hardev Dhillon, Dayana Plaz). All rights reserved.
* This software is provided 'as is' and may be used by the recipient. No permission is granted for redistribution,
* modification, or repurposing of this contract. Any use beyond the scope defined herein may be subject to legal action.
*/
contract YSL is
IYSL,
ERC20
{
/// ------------------------------------ VARIABLES ------------------------------------- \\\
/**
* @notice Root of the Merkle tree used for airdrop claims.
*/
bytes32 public merkleRoot;
/**
* @notice Deadline for claiming airdrops.
*/
uint256 public immutable CLAIM_DEADLINE;
/// ------------------------------------ MAPPINGS --------------------------------------- \\\
/**
* @notice Mapping to track if a user has claimed their airdrop.
*/
mapping (bytes32 => bool) public airdropClaimed;
/// ------------------------------------ CONSTRUCTOR ------------------------------------ \\\
/**
* @notice Constructor for the YSL token, setting up necessary dependencies and initial state.
* @dev Initialises the token with a given Merkle root for airdrop claims, sets up interfaces for
* various services (like Axelar and LayerZero), and computes the string representation of the contract's address.
* @param _merkleRoot Root of the Merkle tree for airdrop claims.
*/
constructor(
bytes32 _merkleRoot
) ERC20("YSL", "YSL") {
merkleRoot = _merkleRoot;
CLAIM_DEADLINE = block.timestamp + 90 days;
}
/// --------------------------------- EXTERNAL FUNCTIONS -------------------------------- \\\
/**
* @notice Burns a specified amount of tokens from a user's address.
* @dev Only addresses with the required allowance can burn tokens on behalf of a user.
* @param _user Address from which tokens will be burned.
* @param _amount Amount of tokens to burn.
*/
function burn(
address _user,
uint256 _amount
)
external
override
{
if (_user != msg.sender)
_spendAllowance(_user, msg.sender, _amount);
_burn(_user, _amount);
}
/// ------------------------------------------------------------------------------------- \\\
/**
* @notice Allows users to claim their airdropped tokens using a Merkle proof.
* @dev Verifies the Merkle proof against the stored Merkle root and mints the claimed amount to the user.
* @param proof Array of bytes32 values representing the Merkle proof.
* @param account Address of the user claiming the airdrop.
* @param amount Amount of tokens being claimed.
*/
function claim(
bytes32[] calldata proof,
address account,
uint256 amount
)
external
override
{
if (block.timestamp > CLAIM_DEADLINE) {
revert ClaimPeriodExpired();
}
bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(account, amount))));
if (!MerkleProof.verify(proof, merkleRoot, leaf)) {
revert InvalidClaimProof();
}
if (airdropClaimed[leaf]) {
revert AirdropAlreadyClaimed();
}
airdropClaimed[leaf] = true;
_mint(account, amount);
emit Airdropped(account, amount);
}
/// ------------------------------------------------------------------------------------- \\\
}{
"compilationTarget": {
"contracts/YSL.sol": "YSL"
},
"evmVersion": "paris",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs",
"useLiteralContent": true
},
"optimizer": {
"enabled": true,
"runs": 2
},
"remappings": []
}[{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AirdropAlreadyClaimed","type":"error"},{"inputs":[],"name":"ClaimPeriodExpired","type":"error"},{"inputs":[],"name":"InvalidClaimProof","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Airdropped","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"CLAIM_DEADLINE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"airdropClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"},{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]