77 lines
3.8 KiB
Solidity
77 lines
3.8 KiB
Solidity
// SPDX-License-Identifier: MIT
|
|
|
|
pragma solidity ^0.6.0;
|
|
|
|
/**
|
|
* @dev Base interface for a contract that will be called via the GSN from {IRelayHub}.
|
|
*
|
|
* TIP: You don't need to write an implementation yourself! Inherit from {GSNRecipient} instead.
|
|
*/
|
|
interface IRelayRecipient {
|
|
/**
|
|
* @dev Returns the address of the {IRelayHub} instance this recipient interacts with.
|
|
*/
|
|
function getHubAddr() external view returns (address);
|
|
|
|
/**
|
|
* @dev Called by {IRelayHub} to validate if this recipient accepts being charged for a relayed call. Note that the
|
|
* recipient will be charged regardless of the execution result of the relayed call (i.e. if it reverts or not).
|
|
*
|
|
* The relay request was originated by `from` and will be served by `relay`. `encodedFunction` is the relayed call
|
|
* calldata, so its first four bytes are the function selector. The relayed call will be forwarded `gasLimit` gas,
|
|
* and the transaction executed with a gas price of at least `gasPrice`. ``relay``'s fee is `transactionFee`, and the
|
|
* recipient will be charged at most `maxPossibleCharge` (in wei). `nonce` is the sender's (`from`) nonce for
|
|
* replay attack protection in {IRelayHub}, and `approvalData` is a optional parameter that can be used to hold a signature
|
|
* over all or some of the previous values.
|
|
*
|
|
* Returns a tuple, where the first value is used to indicate approval (0) or rejection (custom non-zero error code,
|
|
* values 1 to 10 are reserved) and the second one is data to be passed to the other {IRelayRecipient} functions.
|
|
*
|
|
* {acceptRelayedCall} is called with 50k gas: if it runs out during execution, the request will be considered
|
|
* rejected. A regular revert will also trigger a rejection.
|
|
*/
|
|
function acceptRelayedCall(
|
|
address relay,
|
|
address from,
|
|
bytes calldata encodedFunction,
|
|
uint256 transactionFee,
|
|
uint256 gasPrice,
|
|
uint256 gasLimit,
|
|
uint256 nonce,
|
|
bytes calldata approvalData,
|
|
uint256 maxPossibleCharge
|
|
)
|
|
external
|
|
view
|
|
returns (uint256, bytes memory);
|
|
|
|
/**
|
|
* @dev Called by {IRelayHub} on approved relay call requests, before the relayed call is executed. This allows to e.g.
|
|
* pre-charge the sender of the transaction.
|
|
*
|
|
* `context` is the second value returned in the tuple by {acceptRelayedCall}.
|
|
*
|
|
* Returns a value to be passed to {postRelayedCall}.
|
|
*
|
|
* {preRelayedCall} is called with 100k gas: if it runs out during execution or otherwise reverts, the relayed call
|
|
* will not be executed, but the recipient will still be charged for the transaction's cost.
|
|
*/
|
|
function preRelayedCall(bytes calldata context) external returns (bytes32);
|
|
|
|
/**
|
|
* @dev Called by {IRelayHub} on approved relay call requests, after the relayed call is executed. This allows to e.g.
|
|
* charge the user for the relayed call costs, return any overcharges from {preRelayedCall}, or perform
|
|
* contract-specific bookkeeping.
|
|
*
|
|
* `context` is the second value returned in the tuple by {acceptRelayedCall}. `success` is the execution status of
|
|
* the relayed call. `actualCharge` is an estimate of how much the recipient will be charged for the transaction,
|
|
* not including any gas used by {postRelayedCall} itself. `preRetVal` is {preRelayedCall}'s return value.
|
|
*
|
|
*
|
|
* {postRelayedCall} is called with 100k gas: if it runs out during execution or otherwise reverts, the relayed call
|
|
* and the call to {preRelayedCall} will be reverted retroactively, but the recipient will still be charged for the
|
|
* transaction's cost.
|
|
*/
|
|
function postRelayedCall(bytes calldata context, bool success, uint256 actualCharge, bytes32 preRetVal) external;
|
|
}
|