refactor(bridge): use ArbRetryableTx#getSubmissionPrice

Author: shalzz

CHANGELOG.md

@@ -1,11 +1,9 @@
-## 0.1.0 (2021-12-04)
+## 0.1.0 (2021-12-10)
 
-- feat: add arbitrum L1 bridge and dependencies ([283e748](https://github.com/kleros/kleros-v2/commit/283e748))
-- fix(Arbitrator): memory to calldata ([4770b1f](https://github.com/kleros/kleros-v2/commit/4770b1f))
-- fix(IArbitrator): appeals removed from the standard ([02c20ce](https://github.com/kleros/kleros-v2/commit/02c20ce))
-- fix(IArbitrator): change name to arbitration cost ([0ba4f29](https://github.com/kleros/kleros-v2/commit/0ba4f29))
-- fix(IArbitrator): interface simplification ([e81fb8b](https://github.com/kleros/kleros-v2/commit/e81fb8b))
-- fix(IArbitrator): replaced appealCost with fundingStatus ([f189dd9](https://github.com/kleros/kleros-v2/commit/f189dd9))
+- refactor(bridge): use ArbRetryableTx#getSubmissionPrice ([0de6272](https://github.com/kleros/kleros-v2/commit/0de6272))
+- refactor(sdk): rename ([3241d10](https://github.com/kleros/kleros-v2/commit/3241d10))
+- feat: add arbitrum L1 bridge and dependencies ([b412772](https://github.com/kleros/kleros-v2/commit/b412772))
+- feat: add arbitrum L2 bridge ([457b060](https://github.com/kleros/kleros-v2/commit/457b060))
 - feat: modern toolchain setup and simple RNG smart contracts ([17f6a76](https://github.com/kleros/kleros-v2/commit/17f6a76))
 - feat(Arbitration): standard update ([ed930de](https://github.com/kleros/kleros-v2/commit/ed930de))
 - fix(Arbitrator): memory to calldata ([4770b1f](https://github.com/kleros/kleros-v2/commit/4770b1f))

contracts/src/bridge/arbitrum/L1Bridge.sol

@@ -1,15 +1,18 @@
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
 pragma solidity ^0.8.0;
 
 import "./interfaces/IInbox.sol";
+import "./interfaces/IArbRetryableTx.sol";
 
 contract L1Bridge {
  address public l2Target;
  IInbox public inbox;
+ IArbRetryableTx constant arbRetryableTx = IArbRetryableTx(address(110));
 
  event RetryableTicketCreated(uint256 indexed ticketId);
 
- constructor(address _l2Target, address _inbox) public {
+ constructor(address _l2Target, address _inbox) {
  l2Target = _l2Target;
  inbox = IInbox(_inbox);
  }
@@ -27,24 +30,21 @@ contract L1Bridge {
  * of at least CallValue + MaxSubmissionCost + (GasPrice x MaxGas).
  *
  * @param _calldata The L2 encoded message data.
- * @param _maxSubmissionCost Amount of ETH allocated to pay for the base submission fee.
- * The base submission fee to cover the storage costs of keeping
- * their ticket’s calldata in the retry buffer.
  * @param _maxGas Gas limit for immediate L2 execution attempt.
  * @param _gasPriceBid L2 Gas price bid for immediate L2 execution attempt.
  * @return Unique id to track the message request/transaction.
  */
  function sendCrossDomainMessage(
  bytes memory _calldata,
- uint256 _maxSubmissionCost,
  uint256 _maxGas,
  uint256 _gasPriceBid
  ) external payable returns (uint256) {
- // Perhaps Inbox#sendContractTransaction can be used here instead.
+ (uint256 baseSubmissionCost, ) = arbRetryableTx.getSubmissionPrice(_calldata.length);
+
  uint256 ticketID = inbox.createRetryableTicket{value: msg.value}(
  l2Target,
  0,
- _maxSubmissionCost,
+ baseSubmissionCost,
  msg.sender,
  msg.sender,
  _maxGas,

contracts/src/bridge/arbitrum/L2Bridge.sol

@@ -1,4 +1,5 @@
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
 pragma solidity ^0.8.0;
 
 import "./interfaces/IArbSys.sol";
@@ -9,7 +10,7 @@ contract L2Bridge {
 
  event L2ToL1TxCreated(uint256 indexed withdrawalId);
 
- constructor(address _l1Target) public {
+ constructor(address _l1Target) {
  l1Target = _l1Target;
  }
 

contracts/src/bridge/arbitrum/interfaces/IArbRetryableTx.sol

@@ -0,0 +1,72 @@
+pragma solidity >=0.7.0;
+
+/**
+ * @title precompiled contract in every Arbitrum chain for retryable transaction related data retrieval and interactions. Exists at 0x000000000000000000000000000000000000006E
+ */
+interface IArbRetryableTx {
+ /**
+ * @notice Redeem a redeemable tx.
+ * Revert if called by an L2 contract, or if txId does not exist, or if txId reverts.
+ * If this returns, txId has been completed and is no longer available for redemption.
+ * If this reverts, txId is still available for redemption (until it times out or is canceled).
+ @param txId unique identifier of retryable message: keccak256(keccak256(ArbchainId, inbox-sequence-number), uint(0) )
+ */
+ function redeem(bytes32 txId) external;
+
+ /**
+ * @notice Return the minimum lifetime of redeemable txn.
+ * @return lifetime in seconds
+ */
+ function getLifetime() external view returns (uint256);
+
+ /**
+ * @notice Return the timestamp when ticketId will age out, or zero if ticketId does not exist.
+ * The timestamp could be in the past, because aged-out tickets might not be discarded immediately.
+ * @param ticketId unique ticket identifier
+ * @return timestamp for ticket's deadline
+ */
+ function getTimeout(bytes32 ticketId) external view returns (uint256);
+
+ /**
+ * @notice Return the price, in wei, of submitting a new retryable tx with a given calldata size.
+ * @param calldataSize call data size to get price of (in wei)
+ * @return (price, nextUpdateTimestamp). Price is guaranteed not to change until nextUpdateTimestamp.
+ */
+ function getSubmissionPrice(uint256 calldataSize) external view returns (uint256, uint256);
+
+ /**
+ * @notice Return the price, in wei, of extending the lifetime of ticketId by an additional lifetime period. Revert if ticketId doesn't exist.
+ * @param ticketId unique ticket identifier
+ * @return (price, nextUpdateTimestamp). Price is guaranteed not to change until nextUpdateTimestamp.
+ */
+ function getKeepalivePrice(bytes32 ticketId) external view returns (uint256, uint256);
+
+ /**
+ @notice Deposits callvalue into the sender's L2 account, then adds one lifetime period to the life of ticketId.
+ * If successful, emits LifetimeExtended event.
+ * Revert if ticketId does not exist, or if the timeout of ticketId is already at least one lifetime period in the future, or if the sender has insufficient funds (after the deposit).
+ * @param ticketId unique ticket identifier
+ * @return New timeout of ticketId.
+ */
+ function keepalive(bytes32 ticketId) external payable returns (uint256);
+
+ /**
+ * @notice Return the beneficiary of ticketId.
+ * Revert if ticketId doesn't exist.
+ * @param ticketId unique ticket identifier
+ * @return address of beneficiary for ticket
+ */
+ function getBeneficiary(bytes32 ticketId) external view returns (address);
+
+ /**
+ * @notice Cancel ticketId and refund its callvalue to its beneficiary.
+ * Revert if ticketId doesn't exist, or if called by anyone other than ticketId's beneficiary.
+ * @param ticketId unique ticket identifier
+ */
+ function cancel(bytes32 ticketId) external;
+
+ event TicketCreated(bytes32 indexed ticketId);
+ event LifetimeExtended(bytes32 indexed ticketId, uint256 newTimeout);
+ event Redeemed(bytes32 indexed ticketId);
+ event Canceled(bytes32 indexed ticketId);
+}