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,123 @@
+package core
+
+import (
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/state"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/params"
+)
+
+// GasStation struct storage slots structs
+type GasStationStorageSlots struct {
+	StructBaseSlotHash             common.Hash
+	CreditSlotHash                 common.Hash
+	WhitelistEnabledSlotHash       common.Hash
+	NestedWhitelistMapBaseSlotHash 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 = 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)
+	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)
+
+	return gasStationStorageSlots
+}
+
+func ValidateGaslessTx(to *common.Address, from common.Address, gasLimit uint64, sdb *state.StateDB) (*big.Int, *big.Int, *GasStationStorageSlots, error) {
+	if to == nil {
+		return nil, nil, nil, fmt.Errorf("gasless txn must have a valid to address")
+	}
+
+	// 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
+		userKeyPadded := common.LeftPadBytes(from.Bytes(), 32)
+		mapBaseSlotPadded := common.LeftPadBytes(gasStationStorageSlots.NestedWhitelistMapBaseSlotHash.Bytes(), 32)
+		userCombined := append(userKeyPadded, mapBaseSlotPadded...)
+		userWhitelistSlotHash := crypto.Keccak256Hash(userCombined)
+
+		// 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")
+		}
+	}
+
+	return availableCreditsBig, txRequiredCreditsBig, &gasStationStorageSlots, nil
+}

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

@@ -22,10 +22,13 @@ import (
 	"math"
 	"math/big"
 
+	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/state"
 	"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 +172,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 +197,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 +376,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.(*state.StateDB))
+		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 +647,53 @@ 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())
+
+		// Deduct the credits from the contract state directly
+		st.state.SetState(params.GasStationAddress, gasStationStorageSlots.CreditSlotHash, common.BigToHash(new(big.Int).Sub(availableCreditsBig, txRequiredCreditsBig)))
+
+		// Emit CreditsUsed event: CreditsUsed(address indexed contractAddress, address caller, uint256 gasUsed)
+		// Create ABI arguments for non-indexed parameters
+		addressType, _ := abi.NewType("address", "", nil)
+		uint256Type, _ := abi.NewType("uint256", "", nil)
+		arguments := abi.Arguments{
+			{Type: addressType}, // caller (not indexed)
+			{Type: uint256Type}, // gasUsed (not indexed)
+		}
+
+		// ABI encode the non-indexed data
+		data, err := arguments.Pack(st.msg.From, big.NewInt(int64(st.gasUsed())))
+		if err != nil {
+			// Fallback to manual encoding if ABI encoding fails
+			data = append(
+				common.LeftPadBytes(st.msg.From.Bytes(), 32),
+				common.LeftPadBytes(big.NewInt(int64(st.gasUsed())).Bytes(), 32)...,
+			)
+		}
+
+		st.state.AddLog(&types.Log{
+			Address: params.GasStationAddress,
+			Topics: []common.Hash{
+				crypto.Keccak256Hash([]byte("CreditsUsed(address,address,uint256)")), // Event signature
+				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(),