A persistent gas tank allows users to submit transactions to be executed at a later time by keepers, paying those keepers out of the user's balance.
\nA new GasTank contract will be deployed that does the following:
There are a number of proposed operations in the Synthetix ecosystem which require transactions to be executed after a\ndelay. Such operations include:
\nUsers cannot be expected to monitor prices for limit orders, or tediously execute the transaction sequences required\nby frontrunning protection.\nThis gas tank mechanism allows keepers to execute such deferred transactions and be reimbursed for the gas cost of\nexecuting them. It is intended that this will significantly reduce UX friction for users, as they will not have to\nexecute these advanced operations themselves.\nHaving a balance in the gas tank will not be required for standard exchange operations that do not need it.
\nAny operation that needs to be deferred and executed by a keeper must measure its own gas consumption, reporting this\nquantity to the gas tank contract at the end of its execution. The gas tank will then consult the latest fast gas price\nfrom Chainlink, ensure that this does not exceed the user's configured\nmaximum gas price, and reimburse the keeper from the user's balance, along with a fee to incentivise the execution.
\nThe gas tank addresses the question of incentivising keepers to perform actions for users that it would otherwise be too inconvenient for\nthem to perform for themelves. Several different incentive schemes were considered.
\nA gas tank could be avoided altogether by minting SNX to incentivise keepers, but this runs into several issues:
\nUsers could deposit synths in their gas tank instead, but this would add additional gas cost to transactions, and\nnecessitate keepers to exchange their earnings. If keeper incentives are paid in ether, then they need never\ntop up their own balances in order to continue operating.
\nOnly contracts that absolutely need it should have the ability to invoke this functionality, and therefore the gas tank\ncontract should verify that those attempting to spend user's ether are the correct contracts known to the AddressResolver.\nTherefore, this contract will need to inherit MixinResolver.
The gas tank contract should not operate if the system is suspended, and should itself be pausable for upgrades.\nFor the same reason, it should have a separated state contract that holds user balances and ether; the two contracts\nshould retrieve each other's address through the AddressResolver.
Each execution by a keeper will be incentivised by flat SCCP-configurable keeper fee, stored as a global system setting.\nThis should be retrievable from the by a new SystemSettings.keeperFee() function.\nThis will return the USD value of ether to be awarded to keepers, and should generally be kept as low as possible while\nstill being incentivising for keepers to operate.
In order to support delegation of gas tank management, the DelegateApprovals\ncontract will need to be updated with a new canManageGasTankFor function.
isApprovedContractSignature: function isApprovedContract(bytes32 contractName) returns (bool isApproved)
Returns true if and only if the provided contract is approved to spend gas for deferred transactions.
\napproveContractSignature: function approveContract(bytes32 contractName, bool approve) external
Allows a contract to be approved or disapproved to spend gas for deferred transactions.
\nThis function should revert if either:
\ncontractName is not an identifier recognised by the AddressResolver.msg.sender is not the contract owner.balanceOfSignature: function balanceOf(address account) external view returns (uint balance)
Returns the remaining deposited ether in a given account.
\ndepositEtherOnBehalfSignature: function depositEtherOnBehalf(address account, uint value) external payable
Increases an account's ether balance.\nThis function should revert if either:
\ntx.value != valueaccount != msg.sender && !DelegateApprovals.canManageGasTankFor(account, msg.sender)depositEtherSignature: function depositEther(uint value) external payable
Equivalent to depositEtherOnBehalf(msg.sender, value).
withdrawEtherOnBehalfSignature: function withdrawEtherOnBehalf(address account, address payable recipient, uint value) external
Reduces an account's ether balance, remitting the withdrawn ether to the recipient address.\nThis function should revert if:
balanceOf(msg.sender) < valueaccount != msg.sender && !DelegateApprovals.canManageGasTankFor(account, msg.sender)withdrawEtherSignature: function withdrawEther(address payable recipient, uint value) external
Equivalent to withdrawEtherOnBehalf(msg.sender, recipient, value).
maxGasPriceOfSignature: function maxGasPriceOf(address account) external view returns (uint maxGasPriceWei)
Returns the account's configured maximum gas price in wei.
\nsetMaxGasPriceOnBehalfSignature: function setMaxGasPriceOnBehalf(address account, uint maxGasPriceWei) external
Allows a user to set the maximum gas price that they are willing to pay for any deferred transaction.
\nThis should revert if:
\naccount != msg.sender && !DelegateApprovals.canManageGasTankFor(account, msg.sender)setMaxGasPriceSignature: function setMaxGasPrice(uint maxGasPriceWei) external
Equivalent to setMaxGasPriceOnBehalf(msg.sender, maxGasPriceWei)
currentGasPriceSignature: function currentGasPrice() external view returns (uint currentGasPriceWei)
Fetches the current fast gas price from Chainlink's Fast Gas / Gwei aggregation,\nreturning it as a quantity of wei.
\ncurrentEtherPriceSignature: function currentEtherPrice() external view returns (uint currentEtherPrice)
Fetches the current ether price from Chainlink's ETH / USD aggregation.
\nexecutionCostSignature: function executionCost(uint gas) external returns (uint etherCost)
Returns the cost in ether to spend a given quantity of gas at the current gas price, plus the keeper fee,\nplus the execution cost of an invocation of the spendGas function.\nThat is, this returns (gas + cost(spendGas)) * currentGasPrice() + SystemSettings.keeperFee() / currentEtherPrice().
payGasSignature: function payGas(address spender, address payable recipient, uint gas) external returns (uint etherSpent)
Allows privileged system smart contracts to reimburse an executing address for executions of a spender's\ndeferred transactions at the current fast gas price.
\nProvided there is sufficient balance in the spender's account, and the transaction was executed at a gas price in the\ncorrect range, executionCost(gas) of ether will be transferred to the recipient address, and deducted from the spender's\nbalance.
This function should revert if any of the following is satisfied:
\nmsg.sender is not an approved contractbalanceOf(spender) < executionCost(gas)tx.gasprice < currentGasPrice()maxGasPriceOf(spender) < tx.gaspriceContractApprovedSignature: event ContractApproved(bytes32 contractName, bool approved)
Records that a contract was approved or disapproved to spend gas.
\nEtherDepositedSignature: event EtherDeposited(address payable indexed spender, uint value)
Records that a user deposited ether in their gas tank.
\nEtherWithdrawnSignature: event EtherWithdrawn(address indexed spender, address payable indexed recipient, uint value)
Records that a user withdrew ether from their gas tank.
\nEtherSpentSignature: event EtherSpent(address indexed spender, address payable indexed recipient, uint value, uint gasPrice)
Records that an executor was transferred a value of ether by a spender to reimburse the\nthe execution of a deferred transaction at a certain gas price.
\nMaxGasPriceSetSignature: event MaxGasPriceSet(address indexed account, uint maxGasPriceWei)
Records that an account set its max acceptable gas price in wei.
\nSee implementation.
\n| Value | Type | Description |\n| keeperFee | uint | The usd value of ether to pay keepers when they execute a gas-reimbursed deferred transaction |
Copyright and related rights waived via CC0.
"}},"pageContext":{"id":"a606ac69-8212-5ff9-bfff-faa57f1dad10","frontmatter__sip":79,"__params":{"frontmatter__sip":"79"}}},"staticQueryHashes":[]}