test(integration): cover staging, quorum and foreclosure

Author: vfusco

.gitignore

@@ -15,6 +15,7 @@ machine-snapshot/**
 /cartesi-rollups-claimer
 /cartesi-rollups-jsonrpc-api
 /cartesi-rollups-prt
+/cartesi-rollups-machine-tool
 /rollups-contracts
 /rollups-prt-contracts
 /applications

Makefile

@@ -59,7 +59,7 @@ DOCKER_PLATFORM=--platform $(BUILD_PLATFORM)
 endif
 
 # Go artifacts
-GO_ARTIFACTS := $(addprefix cartesi-rollups-,node cli evm-reader advancer validator claimer jsonrpc-api prt)
+GO_ARTIFACTS := $(addprefix cartesi-rollups-,node cli evm-reader advancer validator claimer jsonrpc-api prt machine-tool)
 
 # fixme(vfusco): path on all oses
 CGO_CFLAGS:= -I$(PREFIX)/include
@@ -129,6 +129,8 @@ env:
 	@echo export CARTESI_CONTRACTS_APPLICATION_FACTORY_ADDRESS="0xC549F89cF1ca43eDDECC64Ac2208F4b283B1c483"
 	@echo export CARTESI_CONTRACTS_SELF_HOSTED_APPLICATION_FACTORY_ADDRESS="0x6145C5996a71a379E030aEb0440df79D60833418"
 	@echo export CARTESI_CONTRACTS_DAVE_APP_FACTORY_ADDRESS="0x33FFf0b681c90664dD048a60400AE2D827a4c5bb"
+	@echo export CARTESI_DEVNET_ERC20_PORTAL_ADDRESS="0x22E57511C30CcE6CDaa742E13CE3b774fDC663b1"
+	@echo export CARTESI_DEVNET_TEST_ERC20_ADDRESS="0x88A2120B7068E78692C8fd12E751d610B6377E4d"
 	@echo export CARTESI_DEVNET_WITHDRAWAL_OUTPUT_BUILDER_ADDRESS="0x0745787835A019cd4dae8EDB541Fbc0647793d63"
 	@echo export CARTESI_AUTH_MNEMONIC=\"test test test test test test test test test test test junk\"
 	@echo export CARTESI_DATABASE_CONNECTION="postgres://postgres:password@localhost:5432/rollupsdb?sslmode=disable"
@@ -295,6 +297,8 @@ reject-loop-dapp: applications/reject-loop-dapp ## Reject loop dapp
 
 exception-loop-dapp: applications/exception-loop-dapp ## Exception loop dapp
 
+erc20-withdrawal-dapp: applications/erc20-withdrawal-dapp ## ERC-20 withdrawal test dapp
+
 applications/reject-loop-dapp: ## Create reject-loop-dapp test application
 	@echo "Creating reject-loop-dapp test application"
 	@mkdir -p applications
@@ -305,6 +309,18 @@ applications/exception-loop-dapp: ## Create exception-loop-dapp test application
 	@mkdir -p applications
 	@cartesi-machine --ram-length=128Mi --store=applications/exception-loop-dapp --final-hash -- ioctl-echo-loop --vouchers=1 --notices=1 --reports=1 --exception=1 --verbose=1
 
+applications/erc20-withdrawal-dapp: test/dapps/erc20-withdrawal/install.sh ## Create ERC-20 withdrawal test application
+	@echo "Creating ERC-20 withdrawal test application"
+	@mkdir -p applications
+	@PORTAL=$${CARTESI_DEVNET_ERC20_PORTAL_ADDRESS:-0x22E57511C30CcE6CDaa742E13CE3b774fDC663b1}; \
+	TOKEN=$${CARTESI_DEVNET_TEST_ERC20_ADDRESS:-0x88A2120B7068E78692C8fd12E751d610B6377E4d}; \
+	cartesi-machine --ram-length=128Mi \
+		--flash-drive=label:accounts,length:4Mi,mke2fs:false,mount:false,user:dapp \
+		--env=TRUSTED_ERC20_PORTAL=$$PORTAL \
+		--env=TRUSTED_ERC20_TOKEN=$$TOKEN \
+		--append-init-file=test/dapps/erc20-withdrawal/install.sh \
+		--store=applications/erc20-withdrawal-dapp --final-hash -- /usr/local/bin/erc20-withdrawal-dapp
+
 deploy-echo-dapp: applications/echo-dapp ## Deploy echo-dapp test application
 	@echo "Deploying echo-dapp test application"
 	@./cartesi-rollups-cli deploy application echo-dapp applications/echo-dapp/
@@ -321,6 +337,46 @@ deploy-prt-echo-dapp: applications/echo-dapp ## Deploy echo-dapp test applicatio
 	@echo "Deploying echo-dapp test application"
 	@./cartesi-rollups-cli deploy application prt-echo-dapp applications/echo-dapp/ --prt
 
+deploy-erc20-withdrawal-dapp: applications/erc20-withdrawal-dapp ## Deploy ERC-20 withdrawal test application
+	@set -e; \
+	APP=$${APP:-erc20-withdrawal-dapp}; \
+	GUARDIAN=$${GUARDIAN:-0x70997970C51812dc3A010C7d01b50e0d17dc79C8}; \
+	BUILDER=$${CARTESI_DEVNET_WITHDRAWAL_OUTPUT_BUILDER_ADDRESS:-0x0745787835A019cd4dae8EDB541Fbc0647793d63}; \
+	DRIVE_START_INDEX=$$(jq -r '.config.flash_drive[] | select(.length == 4194304) | (.start / 4194304 | floor)' \
+		applications/erc20-withdrawal-dapp/config.json); \
+	WITHDRAWAL_CONFIG=$$(jq -cn \
+		--arg guardian "$$GUARDIAN" \
+		--arg builder "$$BUILDER" \
+		--argjson drive "$$DRIVE_START_INDEX" \
+		'{guardian:$$guardian,log2_leaves_per_account:0,log2_max_num_of_accounts:17,accounts_drive_start_index:$$drive,withdrawal_output_builder:$$builder}'); \
+	echo "Deploying $$APP with accounts-drive start index $$DRIVE_START_INDEX"; \
+	./cartesi-rollups-cli deploy application "$$APP" applications/erc20-withdrawal-dapp \
+		--salt "$$(openssl rand -hex 32)" \
+		--withdrawal-config "$$WITHDRAWAL_CONFIG" \
+		--enable=false; \
+	./cartesi-rollups-cli app execution-parameters set "$$APP" snapshot_policy EVERY_EPOCH; \
+	./cartesi-rollups-cli app status "$$APP" enabled --yes
+
+fund-wallet: ## Fund the default Anvil wallet with ETH and test ERC-20
+	@set -e; \
+	RPC_URL=$${CARTESI_BLOCKCHAIN_HTTP_ENDPOINT:-http://localhost:8545}; \
+	TOKEN=$${CARTESI_DEVNET_TEST_ERC20_ADDRESS:-0x88A2120B7068E78692C8fd12E751d610B6377E4d}; \
+	WALLET=$${WALLET:-$$(cast rpc --rpc-url "$$RPC_URL" eth_accounts | jq -r '.[0]')}; \
+	ETH_WEI=$${ETH_WEI:-0x8ac7230489e80000}; \
+	TOKEN_AMOUNT=$${TOKEN_AMOUNT:-1000000}; \
+	echo "Funding $$WALLET with $$ETH_WEI wei"; \
+	cast rpc --rpc-url "$$RPC_URL" anvil_setBalance "$$WALLET" "$$ETH_WEI" >/dev/null; \
+	echo "Minting $$TOKEN_AMOUNT test ERC-20 units to $$WALLET"; \
+	cast send --rpc-url "$$RPC_URL" --from "$$WALLET" --unlocked "$$TOKEN" "mint(uint256)" "$$TOKEN_AMOUNT" >/dev/null
+
+withdraw-wallet: cartesi-rollups-cli ## Send a test withdrawal request from the current signer
+	@set -e; \
+	APP=$${APP:-erc20-withdrawal-dapp}; \
+	AMOUNT=$${AMOUNT:-25}; \
+	PAYLOAD=$$(printf '0x01%016x' "$$AMOUNT"); \
+	echo "Sending withdrawal request to $$APP: amount=$$AMOUNT payload=$$PAYLOAD"; \
+	./cartesi-rollups-cli send "$$APP" "$$PAYLOAD" --hex --yes --json
+
 # Temporary test dependencies target while we are not using distribution packages
 DOWNLOADS_DIR = test/downloads
 CARTESI_TEST_MACHINE_IMAGES = $(DOWNLOADS_DIR)/linux.bin
@@ -449,7 +505,7 @@ test-with-compose: ## Run all tests using docker compose with auto-shutdown
 	@$(MAKE) unit-test-with-compose
 	@$(MAKE) integration-test-with-compose
 
-integration-test-local: build echo-dapp reject-loop-dapp exception-loop-dapp ## Run integration tests locally (requires: make start && eval $$(make env))
+integration-test-local: build cartesi-rollups-machine-tool echo-dapp reject-loop-dapp exception-loop-dapp erc20-withdrawal-dapp ## Run integration tests locally (requires: make start && eval $$(make env))
 	@cartesi-rollups-cli db init
 	@if lsof -ti:10000 >/dev/null 2>&1; then \
 		echo "Killing stale node on port 10000..."; \
@@ -459,6 +515,7 @@ integration-test-local: build echo-dapp reject-loop-dapp exception-loop-dapp ##
 	@export CARTESI_TEST_DAPP_PATH=$(CURDIR)/applications/echo-dapp; \
 	export CARTESI_TEST_REJECT_DAPP_PATH=$(CURDIR)/applications/reject-loop-dapp; \
 	export CARTESI_TEST_EXCEPTION_DAPP_PATH=$(CURDIR)/applications/exception-loop-dapp; \
+	export CARTESI_TEST_ERC20_WITHDRAWAL_DAPP_PATH=$(CURDIR)/applications/erc20-withdrawal-dapp; \
 	$(MAKE) integration-test
 
 deploy-load-test-apps: applications/echo-dapp ## Deploy 3 echo-dapp instances for load testing
@@ -516,7 +573,7 @@ build-debian-package: install
 	dpkg-deb -Zxz --root-owner-group --build $(DESTDIR) $(DEB_FILENAME)
 
 .PHONY: \
-	build build-go $(GO_ARTIFACTS) \
+	build build-go $(GO_ARTIFACTS) cartesi-rollups-machine-tool \
 	clean clean-go clean-contracts clean-docs clean-devnet-files clean-dapps clean-test-dependencies clean-debian-packages \
 	test unit-test unit-test-with-compose integration-test integration-test-with-compose integration-test-local test-with-compose ci-test coverage-report \
 	generate generate-contracts generate-config generate-inspect check-generate generate-db \
@@ -525,4 +582,5 @@ build-debian-package: install
 	devnet image tester-image debian-packager run-with-compose shutdown-compose \
 	start start-devnet start-postgres stop stop-devnet stop-postgres restart restart-devnet restart-postgres \
 	install copy-debian-package build-debian-package \
+	deploy-erc20-withdrawal-dapp fund-wallet withdraw-wallet \
 	env help version

cmd/cartesi-rollups-machine-tool/accountdrive/accountdrive.go

@@ -0,0 +1,171 @@
+// (c) Cartesi and individual authors (see AUTHORS)
+// SPDX-License-Identifier: Apache-2.0 (see LICENSE)
+
+package accountdrive
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"math"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+)
+
+const (
+	Log2AccountSize       = 5
+	AccountSize           = 1 << Log2AccountSize
+	DefaultLog2MaxAccount = 17
+)
+
+var (
+	ErrUnsupportedLayout = errors.New("unsupported accounts-drive layout")
+	ErrAccountNotFound   = errors.New("account not found")
+)
+
+type Proof struct {
+	Account      [AccountSize]byte
+	AccountIndex uint64
+	AccountRoot  common.Hash
+	DriveRoot    common.Hash
+	Siblings     []common.Hash
+}
+
+func DriveSize(log2MaxNumOfAccounts uint8, log2LeavesPerAccount uint8) (uint64, error) {
+	if log2LeavesPerAccount != 0 {
+		return 0, fmt.Errorf("%w: log2_leaves_per_account=%d", ErrUnsupportedLayout, log2LeavesPerAccount)
+	}
+	if log2MaxNumOfAccounts >= 58 { // 2^(5+58) still fits in uint64; keep a margin for int conversion.
+		return 0, fmt.Errorf("log2_max_num_of_accounts %d is too large", log2MaxNumOfAccounts)
+	}
+	return 1 << (Log2AccountSize + log2MaxNumOfAccounts), nil
+}
+
+func Encode(address common.Address, balance uint64) ([AccountSize]byte, error) {
+	var account [AccountSize]byte
+	if address == (common.Address{}) {
+		return account, errors.New("account address must not be zero")
+	}
+	if balance == 0 {
+		return account, errors.New("account balance must be positive")
+	}
+	if balance > math.MaxInt64 {
+		return account, fmt.Errorf("account balance %d exceeds int64 accounts-drive limit", balance)
+	}
+	binary.LittleEndian.PutUint64(account[:8], balance)
+	copy(account[8:28], address.Bytes())
+	return account, nil
+}
+
+func Decode(account []byte) (common.Address, uint64, bool, error) {
+	var zero [AccountSize]byte
+	if len(account) != AccountSize {
+		return common.Address{}, 0, false, fmt.Errorf("account record must be %d bytes, got %d", AccountSize, len(account))
+	}
+	if bytes.Equal(account, zero[:]) {
+		return common.Address{}, 0, false, nil
+	}
+	balance := binary.LittleEndian.Uint64(account[:8])
+	if balance == 0 {
+		return common.Address{}, 0, false, errors.New("non-empty account has zero balance")
+	}
+	if balance > math.MaxInt64 {
+		return common.Address{}, 0, false, fmt.Errorf("account balance %d exceeds int64 accounts-drive limit", balance)
+	}
+	address := common.BytesToAddress(account[8:28])
+	if address == (common.Address{}) {
+		return common.Address{}, 0, false, errors.New("non-empty account has zero address")
+	}
+	if !bytes.Equal(account[28:32], []byte{0, 0, 0, 0}) {
+		return common.Address{}, 0, false, errors.New("non-empty account has non-zero padding")
+	}
+	return address, balance, true, nil
+}
+
+func BuildProof(
+	drive []byte,
+	address common.Address,
+	log2MaxNumOfAccounts uint8,
+	log2LeavesPerAccount uint8,
+) (*Proof, error) {
+	if address == (common.Address{}) {
+		return nil, errors.New("account address must not be zero")
+	}
+	driveSize, err := DriveSize(log2MaxNumOfAccounts, log2LeavesPerAccount)
+	if err != nil {
+		return nil, err
+	}
+	if uint64(len(drive)) > driveSize {
+		return nil, fmt.Errorf("accounts drive is too large: got %d bytes, want at most %d", len(drive), driveSize)
+	}
+
+	leafCount := 1 << log2MaxNumOfAccounts
+	leaves := make([]common.Hash, leafCount)
+	foundIndex := uint64(math.MaxUint64)
+	var foundAccount [AccountSize]byte
+	seenEnd := false
+
+	for i := range leaves {
+		var account [AccountSize]byte
+		offset := i * AccountSize
+		if offset < len(drive) {
+			copy(account[:], drive[offset:min(offset+AccountSize, len(drive))])
+		}
+
+		decodedAddress, _, nonEmpty, err := Decode(account[:])
+		if err != nil {
+			return nil, fmt.Errorf("decode account %d: %w", i, err)
+		}
+		if nonEmpty {
+			if seenEnd {
+				return nil, fmt.Errorf("account %d appears after the first empty slot", i)
+			}
+			if decodedAddress == address {
+				foundIndex = uint64(i)
+				foundAccount = account
+			}
+		} else {
+			seenEnd = true
+		}
+		leaves[i] = crypto.Keccak256Hash(account[:])
+	}
+	if foundIndex == math.MaxUint64 {
+		return nil, fmt.Errorf("%w: %s", ErrAccountNotFound, address)
+	}
+
+	accountRoot := leaves[foundIndex]
+	siblings := make([]common.Hash, log2MaxNumOfAccounts)
+	nodeIndex := foundIndex
+	level := leaves
+	for height := range int(log2MaxNumOfAccounts) {
+		siblings[height] = level[nodeIndex^1]
+		parents := make([]common.Hash, len(level)/2)
+		for i := 0; i < len(parents); i++ {
+			parents[i] = crypto.Keccak256Hash(level[2*i].Bytes(), level[2*i+1].Bytes())
+		}
+		nodeIndex >>= 1
+		level = parents
+	}
+
+	return &Proof{
+		Account:      foundAccount,
+		AccountIndex: foundIndex,
+		AccountRoot:  accountRoot,
+		DriveRoot:    level[0],
+		Siblings:     siblings,
+	}, nil
+}
+
+func RootFromProof(accountRoot common.Hash, accountIndex uint64, siblings []common.Hash) common.Hash {
+	root := accountRoot
+	for height, sibling := range siblings {
+		if (accountIndex>>height)&1 == 0 {
+			root = crypto.Keccak256Hash(root.Bytes(), sibling.Bytes())
+		} else {
+			root = crypto.Keccak256Hash(sibling.Bytes(), root.Bytes())
+		}
+	}
+	return root
+}

cmd/cartesi-rollups-machine-tool/accountdrive/accountdrive_test.go

@@ -0,0 +1,86 @@
+// (c) Cartesi and individual authors (see AUTHORS)
+// SPDX-License-Identifier: Apache-2.0 (see LICENSE)
+
+package accountdrive
+
+import (
+	"encoding/hex"
+	"errors"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/stretchr/testify/require"
+)
+
+func TestEncode_MatchesEwtoolsLayout(t *testing.T) {
+	account, err := Encode(common.HexToAddress("0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"), 7)
+	require.NoError(t, err)
+
+	require.Equal(t,
+		"0700000000000000bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb00000000",
+		hex.EncodeToString(account[:]),
+	)
+}
+
+func TestDecode_RejectsCorruptRecords(t *testing.T) {
+	t.Run("zero record is empty", func(t *testing.T) {
+		var zero [AccountSize]byte
+		_, _, ok, err := Decode(zero[:])
+		require.NoError(t, err)
+		require.False(t, ok)
+	})
+
+	t.Run("non-zero padding is invalid", func(t *testing.T) {
+		account, err := Encode(common.HexToAddress("0x1111111111111111111111111111111111111111"), 1)
+		require.NoError(t, err)
+		account[31] = 1
+
+		_, _, _, err = Decode(account[:])
+		require.ErrorContains(t, err, "padding")
+	})
+}
+
+func TestBuildProof_BuildsVerifiableAccountProof(t *testing.T) {
+	addr1 := common.HexToAddress("0x1111111111111111111111111111111111111111")
+	addr2 := common.HexToAddress("0x2222222222222222222222222222222222222222")
+	account1, err := Encode(addr1, 10)
+	require.NoError(t, err)
+	account2, err := Encode(addr2, 20)
+	require.NoError(t, err)
+
+	drive := make([]byte, 1<<(Log2AccountSize+DefaultLog2MaxAccount))
+	copy(drive[0:AccountSize], account1[:])
+	copy(drive[AccountSize:2*AccountSize], account2[:])
+
+	proof, err := BuildProof(drive, addr2, DefaultLog2MaxAccount, 0)
+	require.NoError(t, err)
+
+	require.Equal(t, uint64(1), proof.AccountIndex)
+	require.Equal(t, account2, proof.Account)
+	require.Len(t, proof.Siblings, DefaultLog2MaxAccount)
+	require.Equal(t, proof.DriveRoot, RootFromProof(proof.AccountRoot, proof.AccountIndex, proof.Siblings))
+}
+
+func TestBuildProof_ReturnsClearErrorForMissingAccount(t *testing.T) {
+	drive := make([]byte, 1<<(Log2AccountSize+DefaultLog2MaxAccount))
+	_, err := BuildProof(drive, common.HexToAddress("0x3333333333333333333333333333333333333333"), DefaultLog2MaxAccount, 0)
+	require.ErrorIs(t, err, ErrAccountNotFound)
+}
+
+func TestBuildProof_RejectsUnsupportedLayout(t *testing.T) {
+	_, err := BuildProof(nil, common.HexToAddress("0x1111111111111111111111111111111111111111"), DefaultLog2MaxAccount, 1)
+	require.ErrorIs(t, err, ErrUnsupportedLayout)
+}
+
+func TestBuildProof_RejectsNonCompactAccountTable(t *testing.T) {
+	addr := common.HexToAddress("0x1111111111111111111111111111111111111111")
+	account, err := Encode(addr, 10)
+	require.NoError(t, err)
+	drive := make([]byte, 3*AccountSize)
+	copy(drive[2*AccountSize:3*AccountSize], account[:])
+
+	_, err = BuildProof(drive, addr, 2, 0)
+	require.Error(t, err)
+	require.False(t, errors.Is(err, ErrAccountNotFound))
+	require.ErrorContains(t, err, "after the first empty slot")
+}