Add Gasless System

.github/workflows/build_and_publish.yml

@@ -0,0 +1,89 @@
+name: Test, Build Image & Push to ECR
+
+on:
+  push:
+    branches:
+      - main # Trigger the workflow on pushes to the main branch
+    tags:
+      - "**" # Trigger the workflow on tags including hierarchical tags like v1.0/beta
+  pull_request:
+    types: [opened, synchronize] # Trigger the workflow when a PR is opened or updated
+
+env:
+  RELEASE_REVISION: ${{ github.sha }}
+  AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
+  AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+  AWS_REGION: ${{ secrets.AWS_REGION }}
+  ECR_REPOSITORY: ll-geth
+
+jobs:
+  # test:
+  #   name: Run Go Tests
+  #   runs-on: ubuntu-latest
+  #   steps:
+  #     - uses: actions/checkout@v4
+
+  #     - name: Set up Go
+  #       uses: actions/setup-go@v5
+  #       with:
+  #         go-version: 1.21.5
+
+  #     - name: Test
+  #       run: go test -v ./...
+
+  release:
+    # needs: test
+    name: Build Image & Push to ECR
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.sha }}
+
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        with:
+          aws-access-key-id: ${{ env.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ env.AWS_SECRET_ACCESS_KEY }}
+          aws-region: ${{ env.AWS_REGION }}
+
+      - name: Login to Amazon ECR
+        id: login-ecr
+        uses: aws-actions/amazon-ecr-login@v2
+
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Docker cache layers
+        uses: actions/cache@v4
+        with:
+          path: /tmp/.buildx-cache
+          key: ${{ runner.os }}-single-buildx-${{ github.sha }}
+          restore-keys: |
+            ${{ runner.os }}-single-buildx
+
+      - name: Get the version tag or short SHA
+        id: get-tag
+        run: |
+          if [[ "${{ github.ref }}" == refs/tags/* ]]; then
+            echo "version=${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
+          else
+            echo "version=${GITHUB_SHA::7}" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Push Image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.login-ecr.outputs.registry }}/${{ env.ECR_REPOSITORY }}:${{ steps.get-tag.outputs.version }}
+          cache-from: type=local,src=/tmp/.buildx-cache
+          cache-to: type=local,dest=/tmp/.buildx-cache-new
+          build-args: VERSION=${{ steps.get-tag.outputs.version }}
+
+      - name: Move cache
+        run: |
+          rm -rf /tmp/.buildx-cache
+          mv /tmp/.buildx-cache-new /tmp/.buildx-cache

.gitignore

@@ -43,3 +43,6 @@ profile.cov
 .vscode
 
 tests/spec-tests/
+devdata/
+password.txt
+plain_key.txt

core/gas_station.go

@@ -0,0 +1,183 @@
+package core
+
+import (
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/params"
+)
+
+// Event signature
+var CreditsUsedEventSignature = crypto.Keccak256Hash([]byte("CreditsUsed(address,address,uint256)"))
+
+var (
+	addressType, _ = abi.NewType("address", "", nil)
+	uint256Type, _ = abi.NewType("uint256", "", nil)
+
+	// Pre-built arguments for CreditsUsed event
+	CreditsUsedEventArgs = abi.Arguments{
+		{Type: addressType}, // caller (not indexed)
+		{Type: uint256Type}, // gasUsed (not indexed)
+	}
+)
+
+// StateReader defines the minimal interface needed for gasless transaction validation
+// This allows ValidateGaslessTx to work with any state implementation that can read storage
+type StateReader interface {
+	GetState(addr common.Address, hash common.Hash) common.Hash
+}
+
+// GasStation struct storage slots structs
+type GasStationStorageSlots struct {
+	StructBaseSlotHash             common.Hash
+	CreditSlotHash                 common.Hash
+	WhitelistEnabledSlotHash       common.Hash
+	NestedWhitelistMapBaseSlotHash common.Hash
+	SingleUseEnabledSlotHash       common.Hash
+	UsedAddressesMapBaseSlotHash   common.Hash
+}
+
+// calculateGasStationSlots computes the storage slot hashes for a specific
+// registered contract within the GasStation's `contracts` mapping.
+// It returns the base slot for the struct (holding packed fields), the slot for credits,
+// the slot for whitelistEnabled, and the base slot for the nested whitelist mapping.
+func CalculateGasStationSlots(registeredContractAddress common.Address) GasStationStorageSlots {
+	gasStationStorageSlots := GasStationStorageSlots{}
+
+	// ERC-7201 storage location for GasStationStorage
+	// bytes32 private constant GasStationStorageLocation = keccak256(abi.encode(uint256(keccak256("gasstation.storage")) - 1)) & ~bytes32(uint256(0xff));
+	// Computed value: 0xc2eaf2cedf9e23687c6eb7c4717aa3eacbd015cc86eaad3f51aae2d3c955db00
+	gasStationStorageLocation := common.HexToHash("0xc2eaf2cedf9e23687c6eb7c4717aa3eacbd015cc86eaad3f51aae2d3c955db00")
+
+	// The 'contracts' mapping is at offset 1 from the storage location
+	// (dao is at offset 0, contracts is at offset 1)
+	contractsMapSlot := new(big.Int).Add(gasStationStorageLocation.Big(), big.NewInt(1))
+
+	// Calculate the base slot for the struct entry in the mapping
+	keyPadded := common.LeftPadBytes(registeredContractAddress.Bytes(), 32)
+	mapSlotPadded := common.LeftPadBytes(contractsMapSlot.Bytes(), 32)
+	combined := append(keyPadded, mapSlotPadded...)
+	gasStationStorageSlots.StructBaseSlotHash = crypto.Keccak256Hash(combined)
+
+	// Calculate subsequent slots by adding offsets to the base slot hash
+	// New struct layout: bool registered, bool active, address admin (all packed in slot 0)
+	// uint256 credits (slot 1), bool whitelistEnabled (slot 2), mapping whitelist (slot 3)
+	// bool singleUseEnabled (slot 4), mapping usedAddresses (slot 5)
+	structBaseSlotBig := gasStationStorageSlots.StructBaseSlotHash.Big()
+
+	// Slot for 'credits' (offset 1 from base - after the packed bools and address)
+	creditsSlotBig := new(big.Int).Add(structBaseSlotBig, big.NewInt(1))
+	gasStationStorageSlots.CreditSlotHash = common.BigToHash(creditsSlotBig)
+
+	// Slot for 'whitelistEnabled' (offset 2 from base)
+	whitelistEnabledSlotBig := new(big.Int).Add(structBaseSlotBig, big.NewInt(2))
+	gasStationStorageSlots.WhitelistEnabledSlotHash = common.BigToHash(whitelistEnabledSlotBig)
+
+	// Base slot for the nested 'whitelist' mapping (offset 3 from base)
+	nestedWhitelistMapBaseSlotBig := new(big.Int).Add(structBaseSlotBig, big.NewInt(3))
+	gasStationStorageSlots.NestedWhitelistMapBaseSlotHash = common.BigToHash(nestedWhitelistMapBaseSlotBig)
+
+	// Slot for 'singleUseEnabled' (offset 4 from base)
+	singleUseEnabledSlotBig := new(big.Int).Add(structBaseSlotBig, big.NewInt(4))
+	gasStationStorageSlots.SingleUseEnabledSlotHash = common.BigToHash(singleUseEnabledSlotBig)
+
+	// Base slot for the nested 'usedAddresses' mapping (offset 5 from base)
+	usedAddressesMapBaseSlotBig := new(big.Int).Add(structBaseSlotBig, big.NewInt(5))
+	gasStationStorageSlots.UsedAddressesMapBaseSlotHash = common.BigToHash(usedAddressesMapBaseSlotBig)
+
+	return gasStationStorageSlots
+}
+
+func ValidateGaslessTx(to *common.Address, from common.Address, gasLimit uint64, sdb StateReader) (*big.Int, *big.Int, *GasStationStorageSlots, error) {
+	if to == nil {
+		return nil, nil, nil, fmt.Errorf("gasless txn must have a valid to address")
+	}
+
+	if gasLimit == 0 {
+		return nil, nil, nil, fmt.Errorf("gasless txn must have a non-zero gas limit")
+	}
+
+	// Calculate GasStation storage slots
+	gasStationStorageSlots := CalculateGasStationSlots(*to)
+
+	// Get the storage for the GaslessContract struct for the given address
+	storageBaseSlot := sdb.GetState(params.GasStationAddress, gasStationStorageSlots.StructBaseSlotHash)
+
+	// Extract the registered and active bytes from the storage slot
+	isRegistered := storageBaseSlot[31] == 0x01
+	isActive := storageBaseSlot[30] == 0x01
+
+	if !isRegistered {
+		return nil, nil, nil, fmt.Errorf("gasless transaction to unregistered address")
+	}
+
+	if !isActive {
+		return nil, nil, nil, fmt.Errorf("gasless transaction to inactive address")
+	}
+
+	// Get the available credits from the credits storage slot in the GasStation contract for the given address
+	availableCredits := sdb.GetState(params.GasStationAddress, gasStationStorageSlots.CreditSlotHash)
+
+	// Convert credits (Hash) and tx gas (uint64) to big.Int for comparison
+	availableCreditsBig := new(big.Int).SetBytes(availableCredits.Bytes())
+	txRequiredCreditsBig := new(big.Int).SetUint64(gasLimit)
+
+	// Check if contract has enough available credits to cover the cost of the tx
+	if availableCreditsBig.Cmp(txRequiredCreditsBig) < 0 {
+		return nil, nil, nil, fmt.Errorf("gasless transaction has insufficient credits: have %v, need %v", availableCreditsBig, txRequiredCreditsBig)
+	}
+
+	// Get the whitelist enabled slot
+	whitelistEnabled := sdb.GetState(params.GasStationAddress, gasStationStorageSlots.WhitelistEnabledSlotHash)
+
+	// Get the whitelist enabled byte from the whitelist enabled slot
+	isWhitelistEnabled := whitelistEnabled[31] == 0x01
+
+	if isWhitelistEnabled {
+		// Calculate slot for the specific user in the nested whitelist map
+		userWhitelistSlotHash := calculateNestedMappingSlot(from, gasStationStorageSlots.NestedWhitelistMapBaseSlotHash)
+
+		// Get the whitelist status for the specific user
+		userWhitelist := sdb.GetState(params.GasStationAddress, userWhitelistSlotHash)
+
+		// Check if the user is whitelisted
+		userWhitelistByte := userWhitelist[31]
+		isUserWhitelistStorage := userWhitelistByte == 0x01
+
+		if !isUserWhitelistStorage {
+			return nil, nil, nil, fmt.Errorf("gasless transaction to non-whitelisted address")
+		}
+	}
+
+	// Check single-use mode if enabled
+	singleUseEnabled := sdb.GetState(params.GasStationAddress, gasStationStorageSlots.SingleUseEnabledSlotHash)
+	isSingleUseEnabled := singleUseEnabled[31] == 0x01
+
+	if isSingleUseEnabled {
+		// Calculate slot for the specific user in the nested usedAddresses map
+		userUsedSlotHash := calculateNestedMappingSlot(from, gasStationStorageSlots.UsedAddressesMapBaseSlotHash)
+
+		// Get the used status for the specific user
+		userUsed := sdb.GetState(params.GasStationAddress, userUsedSlotHash)
+
+		// Check if the user has already used gasless transactions
+		isUserAlreadyUsed := userUsed[31] == 0x01
+
+		if isUserAlreadyUsed {
+			return nil, nil, nil, fmt.Errorf("gasless transaction from address that has already used single-use gasless functionality")
+		}
+	}
+
+	return availableCreditsBig, txRequiredCreditsBig, &gasStationStorageSlots, nil
+}
+
+// calculateNestedMappingSlot computes the storage slot hash for a nested mapping
+func calculateNestedMappingSlot(key common.Address, baseSlot common.Hash) common.Hash {
+	keyPadded := common.LeftPadBytes(key.Bytes(), 32)
+	mapBaseSlotPadded := common.LeftPadBytes(baseSlot.Bytes(), 32)
+	combined := append(keyPadded, mapBaseSlotPadded...)
+	return crypto.Keccak256Hash(combined)
+}

core/genesis.go

@@ -815,6 +815,8 @@ func DeveloperGenesisBlock(gasLimit uint64, faucet *common.Address) *Genesis {
 			params.HistoryStorageAddress:     {Nonce: 1, Code: params.HistoryStorageCode, Balance: common.Big0},
 			params.WithdrawalQueueAddress:    {Nonce: 1, Code: params.WithdrawalQueueCode, Balance: common.Big0},
 			params.ConsolidationQueueAddress: {Nonce: 1, Code: params.ConsolidationQueueCode, Balance: common.Big0},
+			// Initialize GasStation: Set Nonce and Code, storage init empty (nil map)
+			params.GasStationAddress: {Nonce: 1, Code: params.GasStationCode, Balance: common.Big0, Storage: nil},
 		},
 	}
 	if faucet != nil {

core/state_transition.go

@@ -26,6 +26,7 @@ import (
 	"github.com/ethereum/go-ethereum/core/tracing"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/crypto/kzg4844"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/holiman/uint256"
@@ -169,6 +170,7 @@ type Message struct {
 	IsDepositTx    bool                 // IsDepositTx indicates the message is force-included and can persist a mint.
 	Mint           *big.Int             // Mint is the amount to mint before EVM processing, or nil if there is no minting.
 	RollupCostData types.RollupCostData // RollupCostData caches data to compute the fee we charge for data availability
+	IsGaslessTx    bool                 // IsGaslessTx indicates the message is a gasless transaction.
 }
 
 // TransactionToMessage converts a transaction into a Message.
@@ -193,6 +195,7 @@ func TransactionToMessage(tx *types.Transaction, s types.Signer, baseFee *big.In
 		IsDepositTx:    tx.IsDepositTx(),
 		Mint:           tx.Mint(),
 		RollupCostData: tx.RollupCostData(),
+		IsGaslessTx:    tx.IsGaslessTx(),
 	}
 	// If baseFee provided, set gasPrice to effectiveGasPrice.
 	if baseFee != nil {
@@ -371,6 +374,20 @@ func (st *stateTransition) preCheck() error {
 			return fmt.Errorf("%w: address %v, len(code): %d", ErrSenderNoEOA, msg.From.Hex(), len(code))
 		}
 	}
+
+	// Give EVM gas for free if gasless txn
+	if st.msg.IsGaslessTx {
+		// Validate gasless transaction requirements first
+		_, _, _, err := ValidateGaslessTx(st.msg.To, st.msg.From, st.msg.GasLimit, st.state)
+		if err != nil {
+			return err
+		}
+
+		st.initialGas = st.msg.GasLimit
+		st.gasRemaining += st.msg.GasLimit
+		return st.gp.SubGas(st.msg.GasLimit)
+	}
+
 	// Make sure that transaction gasFeeCap is greater than the baseFee (post london)
 	if st.evm.ChainConfig().IsLondon(st.evm.Context.BlockNumber) {
 		// Skip the checks if gas fields are zero and baseFee was explicitly disabled (eth_call)
@@ -628,10 +645,61 @@ func (st *stateTransition) innerExecute() (*ExecutionResult, error) {
 	}
 	st.returnGas()
 
+	// Handle gasless transaction credit deduction AFTER refunds are applied
+	if msg.IsGaslessTx {
+		// Calculate GasStation storage slots (validation already done in preCheck)
+		gasStationStorageSlots := CalculateGasStationSlots(*msg.To)
+		availableCredits := st.state.GetState(params.GasStationAddress, gasStationStorageSlots.CreditSlotHash)
+
+		// Convert credits (Hash) and tx gas (uint64) to big.Int for comparison
+		// Use the final gas used amount (after refunds are applied)
+		availableCreditsBig := new(big.Int).SetBytes(availableCredits.Bytes())
+		txRequiredCreditsBig := new(big.Int).SetUint64(st.gasUsed())
+
+		// Calculate the new credits after the transaction
+		newCredits := new(big.Int).Sub(availableCreditsBig, txRequiredCreditsBig)
+		if newCredits.Sign() < 0 {
+			// Safety net – should never happen but avoids corrupting state
+			newCredits = big.NewInt(0)
+		}
+
+		// Deduct the credits from the contract state directly
+		st.state.SetState(params.GasStationAddress, gasStationStorageSlots.CreditSlotHash, common.BigToHash(newCredits))
+
+		// Mark address as used if single-use mode is enabled
+		singleUseEnabled := st.state.GetState(params.GasStationAddress, gasStationStorageSlots.SingleUseEnabledSlotHash)
+		isSingleUseEnabled := singleUseEnabled[31] == 0x01
+
+		if isSingleUseEnabled {
+			// Calculate slot for the specific user in the nested usedAddresses map
+			userKeyPadded := common.LeftPadBytes(st.msg.From.Bytes(), 32)
+			mapBaseSlotPadded := common.LeftPadBytes(gasStationStorageSlots.UsedAddressesMapBaseSlotHash.Bytes(), 32)
+			userCombined := append(userKeyPadded, mapBaseSlotPadded...)
+			userUsedSlotHash := crypto.Keccak256Hash(userCombined)
+
+			// Mark the user as having used gasless transactions
+			st.state.SetState(params.GasStationAddress, userUsedSlotHash, common.HexToHash("0x01"))
+		}
+
+		// ABI encode the non-indexed data
+		gasUsedBig := new(big.Int).SetUint64(st.gasUsed())
+		data, err := CreditsUsedEventArgs.Pack(st.msg.From, gasUsedBig)
+		if err == nil {
+			st.state.AddLog(&types.Log{
+				Address: params.GasStationAddress,
+				Topics: []common.Hash{
+					CreditsUsedEventSignature,
+					common.BytesToHash(st.msg.To.Bytes()), // contractAddress (indexed)
+				},
+				Data: data,
+			})
+		}
+	}
+
 	// OP-Stack: Note for deposit tx there is no ETH refunded for unused gas, but that's taken care of by the fact that gasPrice
 	// is always 0 for deposit tx. So calling refundGas will ensure the gasUsed accounting is correct without actually
 	// changing the sender's balance.
-	if st.msg.IsDepositTx && rules.IsOptimismRegolith {
+	if (st.msg.IsDepositTx && rules.IsOptimismRegolith) || st.msg.IsGaslessTx {
 		// Skip coinbase payments for deposit tx in Regolith
 		return &ExecutionResult{
 			UsedGas:     st.gasUsed(),