Nft bridge

src/bridges/nft-basic/NftVault.sol

@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2022 Aztec.
+pragma solidity >=0.8.4;
+
+import {IERC721} from "../../../lib/openzeppelin-contracts/contracts/interfaces/IERC721.sol";
+import {AztecTypes} from "../../../lib/rollup-encoder/src/libraries/AztecTypes.sol";
+import {ErrorLib} from "../base/ErrorLib.sol";
+import {BridgeBase} from "../base/BridgeBase.sol";
+import {AddressRegistry} from "../registry/AddressRegistry.sol";
+
+/**
+ * @title Basic NFT Vault for Aztec.
+ * @author Josh Crites, (@critesjosh on Github),  Aztec Team
+ * @notice You can use this contract to hold your NFTs on Aztec. Whoever holds the corresponding virutal asset note can withdraw the NFT.
+ * @dev This bridge demonstrates basic functionality for an NFT bridge. This may be extended to support more features.
+ */
+contract NftVault is BridgeBase {
+    struct NftAsset {
+        address collection;
+        uint256 tokenId;
+    }
+
+    AddressRegistry public immutable REGISTRY;
+
+    mapping(uint256 => NftAsset) public nftAssets;
+
+    error InvalidVirtualAssetId();
+
+    event NftDeposit(uint256 indexed virtualAssetId, address indexed collection, uint256 indexed tokenId);
+    event NftWithdraw(uint256 indexed virtualAssetId, address indexed collection, uint256 indexed tokenId);
+
+    /**
+     * @notice Set the addresses of RollupProcessor and AddressRegistry
+     * @param _rollupProcessor Address of the RollupProcessor
+     * @param _registry Address of the AddressRegistry
+     */
+    constructor(address _rollupProcessor, address _registry) BridgeBase(_rollupProcessor) {
+        REGISTRY = AddressRegistry(_registry);
+    }
+
+    /**
+     * @notice Function for the first step of a NFT deposit, or a NFT withdrawal.
+     * @dev This method can only be called from the RollupProcessor. The first step of the
+     * deposit flow returns a virutal asset note that will represent the NFT on Aztec. After the
+     * virutal asset note is received on Aztec, the user calls matchDeposit which deposits the NFT
+     * into Aztec and matches it with the virtual asset. When the virutal asset is sent to this function
+     * it is burned and the NFT is sent to the recipient passed in _auxData.
+     *
+     * @param _inputAssetA - ETH (Deposit) or VIRTUAL (Withdrawal)
+     * @param _outputAssetA - VIRTUAL (Deposit) or 0 ETH (Withdrawal)
+     * @param _totalInputValue - must be 1 wei (Deposit) or 1 VIRTUAL (Withdrawal)
+     * @param _auxData - corresponds to the Ethereum address id in the AddressRegistry.sol for withdrawals
+     * @return outputValueA - 1 VIRTUAL asset (Deposit) or 0 ETH (Withdrawal)
+     *
+     */
+
+    function convert(
+        AztecTypes.AztecAsset calldata _inputAssetA,
+        AztecTypes.AztecAsset calldata,
+        AztecTypes.AztecAsset calldata _outputAssetA,
+        AztecTypes.AztecAsset calldata,
+        uint256 _totalInputValue,
+        uint256,
+        uint64 _auxData,
+        address
+    )
+        external
+        payable
+        override (BridgeBase)
+        onlyRollup
+        returns (uint256 outputValueA, uint256 outputValueB, bool isAsync)
+    {
+        if (
+            _inputAssetA.assetType == AztecTypes.AztecAssetType.NOT_USED
+                || _inputAssetA.assetType == AztecTypes.AztecAssetType.ERC20
+        ) revert ErrorLib.InvalidInputA();
+        if (
+            _outputAssetA.assetType == AztecTypes.AztecAssetType.NOT_USED
+                || _outputAssetA.assetType == AztecTypes.AztecAssetType.ERC20
+        ) revert ErrorLib.InvalidOutputA();
+        if (_totalInputValue != 1) {
+            revert ErrorLib.InvalidInputAmount();
+        }
+        if (
+            _inputAssetA.assetType == AztecTypes.AztecAssetType.ETH
+                && _outputAssetA.assetType == AztecTypes.AztecAssetType.VIRTUAL
+        ) {
+            return (1, 0, false);
+        } else if (
+            _inputAssetA.assetType == AztecTypes.AztecAssetType.VIRTUAL
+                && _outputAssetA.assetType == AztecTypes.AztecAssetType.ETH
+        ) {
+            NftAsset memory token = nftAssets[_inputAssetA.id];
+            if (token.collection == address(0x0)) {
+                revert ErrorLib.InvalidInputA();
+            }
+
+            address to = REGISTRY.addresses(_auxData);
+            if (to == address(0x0)) {
+                revert ErrorLib.InvalidAuxData();
+            }
+            delete nftAssets[_inputAssetA.id];
+            IERC721(token.collection).transferFrom(address(this), to, token.tokenId);
+            emit NftWithdraw(_inputAssetA.id, token.collection, token.tokenId);
+            return (0, 0, false);
+        }
+    }
+
+    /**
+     * @notice Function for the second step of a NFT deposit.
+     * @dev This method is called by an Ethereum L1 account that owns the NFT to deposit.
+     * The user must approve this bridge contract to transfer the users NFT before this function
+     * is called. This function assumes the NFT contract complies with the ERC721 standard.
+     *
+     * @param _virtualAssetId - the virutal asset id of the note returned in the deposit step of the convert function
+     * @param _collection - collection address of the NFT
+     * @param _tokenId - the token id of the NFT
+     */
+
+    function matchDeposit(uint256 _virtualAssetId, address _collection, uint256 _tokenId) external {
+        if (nftAssets[_virtualAssetId].collection != address(0x0)) {
+            revert InvalidVirtualAssetId();
+        }
+        nftAssets[_virtualAssetId] = NftAsset({collection: _collection, tokenId: _tokenId});
+        IERC721(_collection).transferFrom(msg.sender, address(this), _tokenId);
+        emit NftDeposit(_virtualAssetId, _collection, _tokenId);
+    }
+}

src/bridges/registry/AddressRegistry.sol

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2022 Aztec.
+pragma solidity >=0.8.4;
+
+import {AztecTypes} from "../../../lib/rollup-encoder/src/libraries/AztecTypes.sol";
+import {ErrorLib} from "../base/ErrorLib.sol";
+import {BridgeBase} from "../base/BridgeBase.sol";
+
+/**
+ * @title Aztec Address Registry.
+ * @author Josh Crites (@critesjosh on Github), Aztec team
+ * @notice This contract can be used to anonymously register an ethereum address with an id.
+ *         This is useful for reducing the amount of data required to pass an ethereum address through auxData.
+ * @dev Use this contract to lookup ethereum addresses by id.
+ */
+contract AddressRegistry is BridgeBase {
+    uint256 public addressCount;
+    mapping(uint256 => address) public addresses;
+
+    event AddressRegistered(uint256 indexed index, address indexed entity);
+
+    /**
+     * @notice Set address of rollup processor
+     * @param _rollupProcessor Address of rollup processor
+     */
+    constructor(address _rollupProcessor) BridgeBase(_rollupProcessor) {}
+
+    /**
+     * @notice Function for getting VIRTUAL assets (step 1) to register an address and registering an address (step 2).
+     * @dev This method can only be called from the RollupProcessor. The first step to register an address is for a user to
+     * get the type(uint160).max value of VIRTUAL assets back from the bridge. The second step is for the user
+     * to send an amount of VIRTUAL assets back to the bridge. The amount that is sent back is equal to the number of the
+     * ethereum address that is being registered (e.g. uint160(0x2e782B05290A7fFfA137a81a2bad2446AD0DdFEB)).
+     *
+     * @param _inputAssetA - ETH (step 1) or VIRTUAL (step 2)
+     * @param _outputAssetA - VIRTUAL (steps 1 and 2)
+     * @param _totalInputValue - must be 1 wei (ETH) (step 1) or address value (step 2)
+     * @return outputValueA - type(uint160).max (step 1) or 0 VIRTUAL (step 2)
+     *
+     */
+
+    function convert(
+        AztecTypes.AztecAsset calldata _inputAssetA,
+        AztecTypes.AztecAsset calldata,
+        AztecTypes.AztecAsset calldata _outputAssetA,
+        AztecTypes.AztecAsset calldata,
+        uint256 _totalInputValue,
+        uint256,
+        uint64,
+        address
+    ) external payable override (BridgeBase) onlyRollup returns (uint256 outputValueA, uint256, bool) {
+        if (
+            _inputAssetA.assetType == AztecTypes.AztecAssetType.NOT_USED
+                || _inputAssetA.assetType == AztecTypes.AztecAssetType.ERC20
+        ) revert ErrorLib.InvalidInputA();
+        if (_outputAssetA.assetType != AztecTypes.AztecAssetType.VIRTUAL) {
+            revert ErrorLib.InvalidOutputA();
+        }
+        if (_inputAssetA.assetType == AztecTypes.AztecAssetType.ETH) {
+            if (_totalInputValue != 1) {
+                revert ErrorLib.InvalidInputAmount();
+            }
+            return (type(uint160).max, 0, false);
+        } else if (_inputAssetA.assetType == AztecTypes.AztecAssetType.VIRTUAL) {
+            address toRegister = address(uint160(_totalInputValue));
+            registerAddress(toRegister);
+            return (0, 0, false);
+        } else {
+            revert ErrorLib.InvalidInput();
+        }
+    }
+
+    /**
+     * @notice Register an address at the registry
+     * @dev This function can be called directly from another Ethereum account. This can be done in
+     * one step, in one transaction. Coming from Ethereum directly, this method is not as privacy
+     * preserving as registering an address through the bridge.
+     *
+     * @param _to - The address to register
+     * @return addressCount - the index of address that has been registered
+     */
+
+    function registerAddress(address _to) public returns (uint256) {
+        uint256 userIndex = addressCount++;
+        addresses[userIndex] = _to;
+        emit AddressRegistered(userIndex, _to);
+        return userIndex;
+    }
+}

src/deployment/nft-basic/NftVaultDeployment.s.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2022 Aztec.
+pragma solidity >=0.8.4;
+
+import {BaseDeployment} from "../base/BaseDeployment.s.sol";
+import {NftVault} from "../../bridges/nft-basic/NftVault.sol";
+import {AddressRegistry} from "../../bridges/registry/AddressRegistry.sol";
+
+contract NftVaultDeployment is BaseDeployment {
+    function deploy(address _addressRegistry) public returns (address) {
+        emit log("Deploying NftVault bridge");
+
+        vm.broadcast();
+        NftVault bridge = new NftVault(ROLLUP_PROCESSOR, _addressRegistry);
+
+        emit log_named_address("NftVault bridge deployed to", address(bridge));
+
+        return address(bridge);
+    }
+
+    function deployAndList(address _addressRegistry) public returns (address) {
+        address bridge = deploy(_addressRegistry);
+
+        uint256 addressId = listBridge(bridge, 400000);
+        emit log_named_uint("NftVault bridge address id", addressId);
+
+        return bridge;
+    }
+
+    function deployAndListAddressRegistry() public returns (address) {
+        emit log("Deploying AddressRegistry bridge");
+
+        vm.broadcast();
+        AddressRegistry bridge = new AddressRegistry(ROLLUP_PROCESSOR);
+
+        emit log_named_address("AddressRegistry bridge deployed to", address(bridge));
+        uint256 addressId = listBridge(address(bridge), 400000);
+        emit log_named_uint("AddressRegistry bridge address id", addressId);
+
+        return address(bridge);
+    }
+}

src/deployment/registry/AddressRegistryDeployment.s.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2022 Aztec.
+pragma solidity >=0.8.4;
+
+import {BaseDeployment} from "../base/BaseDeployment.s.sol";
+import {AddressRegistry} from "../../bridges/registry/AddressRegistry.sol";
+
+contract AddressRegistryDeployment is BaseDeployment {
+    function deploy() public returns (address) {
+        emit log("Deploying AddressRegistry bridge");
+
+        vm.broadcast();
+        AddressRegistry bridge = new AddressRegistry(ROLLUP_PROCESSOR);
+
+        emit log_named_address("AddressRegistry bridge deployed to", address(bridge));
+
+        return address(bridge);
+    }
+
+    function deployAndList() public returns (address) {
+        address bridge = deploy();
+
+        uint256 addressId = listBridge(bridge, 400000);
+        emit log_named_uint("AddressRegistry bridge address id", addressId);
+
+        return bridge;
+    }
+}

src/gas/nft-basic/NftVaultGas.s.sol

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2022 Aztec.
+pragma solidity >=0.8.4;
+
+import {AddressRegistry} from "../../bridges/registry/AddressRegistry.sol";
+import {AddressRegistryDeployment} from "../../deployment/registry/AddressRegistryDeployment.s.sol";
+import {NftVault} from "../../bridges/nft-basic/NftVault.sol";
+import {AztecTypes} from "rollup-encoder/libraries/AztecTypes.sol";
+
+import {NftVaultDeployment} from "../../deployment/nft-basic/NftVaultDeployment.s.sol";
+import {GasBase} from "../base/GasBase.sol";
+
+import {ERC721PresetMinterPauserAutoId} from
+    "@openzeppelin/contracts/token/ERC721/presets/ERC721PresetMinterPauserAutoId.sol";
+
+interface IRead {
+    function defiBridgeProxy() external view returns (address);
+}
+
+contract NftVaultGas is NftVaultDeployment, AddressRegistryDeployment {
+    GasBase internal gasBase;
+    NftVault internal bridge;
+    ERC721PresetMinterPauserAutoId internal nftContract;
+    address internal registry;
+    uint256 internal registryAddressId;
+
+    function measure() public {
+        uint256 privKey1 = vm.envUint("PRIVATE_KEY");
+        address addr1 = vm.addr(privKey1);
+
+        address defiProxy = IRead(ROLLUP_PROCESSOR).defiBridgeProxy();
+        vm.label(defiProxy, "DefiProxy");
+
+        vm.startBroadcast();
+        gasBase = new GasBase(defiProxy);
+        nftContract = new ERC721PresetMinterPauserAutoId("test", "NFT", "");
+        nftContract.mint(addr1);
+        vm.stopBroadcast();
+
+        address temp = ROLLUP_PROCESSOR;
+        ROLLUP_PROCESSOR = address(gasBase);
+        registry = deployAndListAddressRegistry();
+        address bridge = deployAndList(registry);
+        ROLLUP_PROCESSOR = temp;
+
+        AztecTypes.AztecAsset memory empty;
+        AztecTypes.AztecAsset memory eth =
+            AztecTypes.AztecAsset({id: 0, erc20Address: address(0), assetType: AztecTypes.AztecAssetType.ETH});
+        AztecTypes.AztecAsset memory virtualAsset =
+            AztecTypes.AztecAsset({id: 100, erc20Address: address(0), assetType: AztecTypes.AztecAssetType.VIRTUAL});
+
+        vm.startBroadcast();
+        address(gasBase).call{value: 2 ether}("");
+
+        // get registry virtual asset
+        gasBase.convert(address(registry), eth, empty, virtualAsset, empty, 1, 0, 0, address(0), 400000);
+        // register address
+        gasBase.convert(
+            address(registry),
+            virtualAsset,
+            empty,
+            virtualAsset,
+            empty,
+            uint256(uint160(addr1)),
+            0,
+            0,
+            address(0),
+            400000
+        );
+        nftContract.approve(address(bridge), 0);
+        vm.stopBroadcast();
+
+        // Get virtual assets
+        {
+            vm.broadcast();
+            gasBase.convert(bridge, eth, empty, virtualAsset, empty, 1, 0, 0, address(0), 400000);
+        }
+        // deposit nft
+        {
+            vm.broadcast();
+            NftVault(bridge).matchDeposit(virtualAsset.id, address(nftContract), 0);
+        }
+        // withdraw nft
+        {
+            vm.broadcast();
+            gasBase.convert(bridge, virtualAsset, empty, eth, empty, 1, 0, 1, address(0), 400000);
+        }
+    }
+}