Celo's op-geth

diff --git op-geth/core/vm/celo_contracts.go Celo/core/vm/celo_contracts.go new file mode 100644 index 0000000000000000000000000000000000000000..d16a7571c6a229d3123dfdf4293d5371d2b5faab --- /dev/null +++ Celo/core/vm/celo_contracts.go @@ -0,0 +1,105 @@ +package vm + +import ( + "fmt" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/common/math" + "github.com/ethereum/go-ethereum/contracts/addresses" + "github.com/ethereum/go-ethereum/params" + "github.com/holiman/uint256" +) + +type CeloPrecompiledContract interface { + RequiredGas(input []byte) uint64 // RequiredGas calculates the contract gas use + Run(input []byte, ctx *celoPrecompileContext) ([]byte, error) // Run runs the precompiled contract +} + +type wrap struct { + PrecompiledContract +} + +func (pw *wrap) Run(input []byte, ctx *celoPrecompileContext) ([]byte, error) { + return pw.PrecompiledContract.Run(input) +} + +type celoPrecompileContext struct { + *BlockContext + *params.Rules + + caller common.Address + evm *EVM +} + +func NewContext(caller common.Address, evm *EVM) *celoPrecompileContext { + return &celoPrecompileContext{ + BlockContext: &evm.Context, + Rules: &evm.chainRules, + caller: caller, + evm: evm, + } +} + +func celoPrecompileAddress(index byte) common.Address { + celoPrecompiledContractsAddressOffset := byte(0xff) + return common.BytesToAddress(append([]byte{0}, (celoPrecompiledContractsAddressOffset - index))) +} + +func (ctx *celoPrecompileContext) IsCallerCeloToken() (bool, error) { + tokenAddress := addresses.GetAddressesOrDefault(ctx.evm.ChainConfig().ChainID, addresses.MainnetAddresses).CeloToken + + return tokenAddress == ctx.caller, nil +} + +// Native transfer contract to make CELO ERC20 compatible. +type transfer struct{} + +func (c *transfer) RequiredGas(input []byte) uint64 { + return params.CallValueTransferGas +} + +func (c *transfer) Run(input []byte, ctx *celoPrecompileContext) ([]byte, error) { + if isCeloToken, err := ctx.IsCallerCeloToken(); err != nil { + return nil, err + } else if !isCeloToken { + return nil, fmt.Errorf("unable to call transfer from unpermissioned address") + } + + // input is comprised of 3 arguments: + // from: 32 bytes representing the address of the sender + // to: 32 bytes representing the address of the recipient + // value: 32 bytes, a 256 bit integer representing the amount of CELO to transfer + // 3 arguments x 32 bytes each = 96 bytes total input + if len(input) != 96 { + return nil, ErrInputLength + } + + // The from parameter should always be set to the caller of the + // function calling the precompile (tx.sender in Solidity). Reasons why + // we have to pass that into the precompile from outside: + // * We can't use ctx.caller because that is always the CELO token + // * We can't use ctx.evm.Origin because that would limit usage to EOA accounts + // * The real value we could use is the caller's caller, which is not readily available + from := common.BytesToAddress(input[0:32]) + to := common.BytesToAddress(input[32:64]) + + var parsed bool + value, parsed := math.ParseBig256(hexutil.Encode(input[64:96])) + if !parsed { + return nil, fmt.Errorf("Error parsing transfer: unable to parse value from " + hexutil.Encode(input[64:96])) + } + valueU256, overflow := uint256.FromBig(value) + if overflow { + return nil, fmt.Errorf("Error parsing transfer: value overflow") + } + + // Fail if we're trying to transfer more than the available balance + if !ctx.CanTransfer(ctx.evm.StateDB, from, valueU256) { + return nil, ErrInsufficientBalance + } + + ctx.Transfer(ctx.evm.StateDB, from, to, valueU256) + + return nil, nil +}

diff --git op-geth/core/vm/celo_contracts_test.go Celo/core/vm/celo_contracts_test.go new file mode 100644 index 0000000000000000000000000000000000000000..0b98ba1dd559c041b1f2c8ce2a34433ef5cd485a --- /dev/null +++ Celo/core/vm/celo_contracts_test.go @@ -0,0 +1,120 @@ +package vm + +import ( + "math/big" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/contracts/addresses" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/params" + "github.com/holiman/uint256" + "golang.org/x/crypto/sha3" +) + +func makeTestHeaderHash(number *big.Int) common.Hash { + preimage := append([]byte("fakeheader"), common.LeftPadBytes(number.Bytes()[:], 32)...) + return common.Hash(sha3.Sum256(preimage)) +} + +func makeTestHeader(number *big.Int) *types.Header { + return &types.Header{ + ParentHash: makeTestHeaderHash(new(big.Int).Sub(number, common.Big1)), + Number: number, + GasUsed: params.DefaultGasLimit / 2, + Time: number.Uint64() * 5, + } +} + +var testHeader = makeTestHeader(big.NewInt(10000)) + +var vmBlockCtx = BlockContext{ + CanTransfer: func(db StateDB, addr common.Address, amount *uint256.Int) bool { + // Assume all addresses but the zero address can transfer for testing + if addr == common.ZeroAddress { + return false + } else { + return true + } + }, + Transfer: func(db StateDB, a1, a2 common.Address, i *uint256.Int) { + panic("transfer: not implemented") + }, + GetHash: func(u uint64) common.Hash { + panic("getHash: not implemented") + }, + Coinbase: common.Address{}, + BlockNumber: new(big.Int).Set(testHeader.Number), + Time: testHeader.Time, +} + +var vmTxCtx = TxContext{ + GasPrice: common.Big1, + Origin: common.HexToAddress("a11ce"), +} + +// Create a global mock EVM for use in the following tests. +var mockEVM = &EVM{ + chainConfig: params.TestChainConfig, + Context: vmBlockCtx, + TxContext: vmTxCtx, +} + +var mockPrecompileContext = NewContext(common.HexToAddress("1337"), mockEVM) + +func TestPrecompileTransfer(t *testing.T) { + type args struct { + input []byte + ctx *celoPrecompileContext + } + tests := []struct { + name string + args args + wantErr bool + expectedErr string + }{ + { + name: "Test transfer with invalid caller", + args: args{ + input: []byte(""), + ctx: mockPrecompileContext, + }, + wantErr: true, + expectedErr: "unable to call transfer from unpermissioned address", + }, { + name: "Test transfer with short input", + args: args{ + input: []byte("0000"), + ctx: NewContext(addresses.MainnetAddresses.CeloToken, mockEVM), + }, + wantErr: true, + expectedErr: "invalid input length", + }, { + name: "Test transferring from zero address (was used for minting on Celo L1)", + args: args{ + // input consists of (from, to, value), each 32 bytes. In this case (0x0, 0x1, 2). + input: []byte{ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, + }, + ctx: NewContext(addresses.MainnetAddresses.CeloToken, mockEVM), + }, + wantErr: true, + expectedErr: "insufficient balance for transfer", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + c := &transfer{} + _, err := c.Run(tt.args.input, tt.args.ctx) + if tt.wantErr { + if err == nil { + t.Errorf("transfer.Run() expected error = %v", tt.expectedErr) + } else if err.Error() != tt.expectedErr { + t.Errorf("transfer.Run() error = %v, expected %v", err, tt.wantErr) + } + } + }) + } +}

diff --git op-geth/core/vm/contracts.go Celo/core/vm/contracts.go index 58146bdc526fa331be3fe349992fe27431fb07fc..4a3190fad17f0c072cc5aa7b973412bcd5971804 100644 --- op-geth/core/vm/contracts.go +++ Celo/core/vm/contracts.go @@ -176,8 +176,21 @@ common.BytesToAddress([]byte{0x0a}): &kzgPointEvaluation{}, common.BytesToAddress([]byte{0x01, 0x00}): &p256Verify{}, }   +// PrecompiledContractsCel2 contains the default set of pre-compiled Ethereum +// contracts used in the Cel2 release which don't require the extra +// celoPrecompileContext, while PrecompiledCeloContractsCel2 contains those +// that do. +var PrecompiledContractsCel2 = PrecompiledContractsGranite + +// PrecompiledCeloContractsCel2 contains a set of pre-compiled contracts used +// in the Cel2 release which require the extra celoPrecompileContext. +var PrecompiledCeloContractsCel2 = map[common.Address]CeloPrecompiledContract{ + celoPrecompileAddress(2): &transfer{}, +} + var ( PrecompiledAddressesGranite []common.Address + PrecompiledAddressesCel2 []common.Address PrecompiledAddressesFjord []common.Address PrecompiledAddressesPrague []common.Address PrecompiledAddressesCancun []common.Address @@ -242,8 +255,9 @@ func ActivePrecompiledContracts(rules params.Rules) PrecompiledContracts { return maps.Clone(activePrecompiledContracts(rules)) }   -// ActivePrecompiles returns the precompile addresses enabled with the current configuration. -func ActivePrecompiles(rules params.Rules) []common.Address { +// OptimismPrecompiles returns the original Optimism precompiles enabled with +// the current configuration. +func OptimismPrecompiles(rules params.Rules) []common.Address { switch { case rules.IsOptimismGranite: return PrecompiledAddressesGranite @@ -264,12 +278,30 @@ return PrecompiledAddressesHomestead } }   +// ActivePrecompiles returns the precompiles enabled with the current configuration. +func ActivePrecompiles(rules params.Rules) []common.Address { + addresses := OptimismPrecompiles(rules) + + if !rules.IsCel2 { + return addresses + } + + PrecompiledAddressesCel2 = PrecompiledAddressesCel2[:0] + PrecompiledAddressesCel2 = append(PrecompiledAddressesCel2, addresses...) + + for k := range PrecompiledCeloContractsCel2 { + PrecompiledAddressesCel2 = append(PrecompiledAddressesCel2, k) + } + + return PrecompiledAddressesCel2 +} + // RunPrecompiledContract runs and evaluates the output of a precompiled contract. // It returns // - the returned bytes, // - the _remaining_ gas, // - any error that occurred -func RunPrecompiledContract(p PrecompiledContract, input []byte, suppliedGas uint64, logger *tracing.Hooks) (ret []byte, remainingGas uint64, err error) { +func RunPrecompiledContract(p CeloPrecompiledContract, input []byte, suppliedGas uint64, logger *tracing.Hooks, ctx *celoPrecompileContext) (ret []byte, remainingGas uint64, err error) { gasCost := p.RequiredGas(input) if suppliedGas < gasCost { return nil, 0, ErrOutOfGas @@ -278,7 +310,7 @@ if logger != nil && logger.OnGasChange != nil { logger.OnGasChange(suppliedGas, suppliedGas-gasCost, tracing.GasChangeCallPrecompiledContract) } suppliedGas -= gasCost - output, err := p.Run(input) + output, err := p.Run(input, ctx) return output, suppliedGas, err }

diff --git op-geth/core/vm/contracts_fuzz_test.go Celo/core/vm/contracts_fuzz_test.go index 1e5cc8007471aa701d28c81706a27a45b3f319d7..6e5ce2f6f3615cfc21339348fe12d7e4feaaf91a 100644 --- op-geth/core/vm/contracts_fuzz_test.go +++ Celo/core/vm/contracts_fuzz_test.go @@ -36,7 +36,7 @@ if gas > 10_000_000 { return } inWant := string(input) - RunPrecompiledContract(p, input, gas, nil) + RunPrecompiledContract(p, input, gas, nil, mockPrecompileContext) if inHave := string(input); inWant != inHave { t.Errorf("Precompiled %v modified input data", a) }

diff --git op-geth/core/vm/contracts_test.go Celo/core/vm/contracts_test.go index 414a867f20888aa01f383baf880b10d7126d3dca..47e0f7ebb358a8f4ee8a3e00fc6bc2d94419ca45 100644 --- op-geth/core/vm/contracts_test.go +++ Celo/core/vm/contracts_test.go @@ -46,30 +46,30 @@ }   // allPrecompiles does not map to the actual set of precompiles, as it also contains // repriced versions of precompiles at certain slots -var allPrecompiles = map[common.Address]PrecompiledContract{ - common.BytesToAddress([]byte{1}): &ecrecover{}, - common.BytesToAddress([]byte{2}): &sha256hash{}, - common.BytesToAddress([]byte{3}): &ripemd160hash{}, - common.BytesToAddress([]byte{4}): &dataCopy{}, - common.BytesToAddress([]byte{5}): &bigModExp{eip2565: false}, - common.BytesToAddress([]byte{0xf5}): &bigModExp{eip2565: true}, - common.BytesToAddress([]byte{6}): &bn256AddIstanbul{}, - common.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{}, - common.BytesToAddress([]byte{8}): &bn256PairingGranite{}, - common.BytesToAddress([]byte{9}): &blake2F{}, - common.BytesToAddress([]byte{0x0a}): &kzgPointEvaluation{}, +var allPrecompiles = map[common.Address]CeloPrecompiledContract{ + common.BytesToAddress([]byte{1}): &wrap{&ecrecover{}}, + common.BytesToAddress([]byte{2}): &wrap{&sha256hash{}}, + common.BytesToAddress([]byte{3}): &wrap{&ripemd160hash{}}, + common.BytesToAddress([]byte{4}): &wrap{&dataCopy{}}, + common.BytesToAddress([]byte{5}): &wrap{&bigModExp{eip2565: false}}, + common.BytesToAddress([]byte{0xf5}): &wrap{&bigModExp{eip2565: true}}, + common.BytesToAddress([]byte{6}): &wrap{&bn256AddIstanbul{}}, + common.BytesToAddress([]byte{7}): &wrap{&bn256ScalarMulIstanbul{}}, + common.BytesToAddress([]byte{8}): &wrap{&bn256PairingGranite{}}, + common.BytesToAddress([]byte{9}): &wrap{&blake2F{}}, + common.BytesToAddress([]byte{0x0a}): &wrap{&kzgPointEvaluation{}},   - common.BytesToAddress([]byte{0x01, 0x00}): &p256Verify{}, + common.BytesToAddress([]byte{0x01, 0x00}): &wrap{&p256Verify{}},   - common.BytesToAddress([]byte{0x0f, 0x0a}): &bls12381G1Add{}, - common.BytesToAddress([]byte{0x0f, 0x0b}): &bls12381G1Mul{}, - common.BytesToAddress([]byte{0x0f, 0x0c}): &bls12381G1MultiExp{}, - common.BytesToAddress([]byte{0x0f, 0x0d}): &bls12381G2Add{}, - common.BytesToAddress([]byte{0x0f, 0x0e}): &bls12381G2Mul{}, - common.BytesToAddress([]byte{0x0f, 0x0f}): &bls12381G2MultiExp{}, - common.BytesToAddress([]byte{0x0f, 0x10}): &bls12381Pairing{}, - common.BytesToAddress([]byte{0x0f, 0x11}): &bls12381MapG1{}, - common.BytesToAddress([]byte{0x0f, 0x12}): &bls12381MapG2{}, + common.BytesToAddress([]byte{0x0f, 0x0a}): &wrap{&bls12381G1Add{}}, + common.BytesToAddress([]byte{0x0f, 0x0b}): &wrap{&bls12381G1Mul{}}, + common.BytesToAddress([]byte{0x0f, 0x0c}): &wrap{&bls12381G1MultiExp{}}, + common.BytesToAddress([]byte{0x0f, 0x0d}): &wrap{&bls12381G2Add{}}, + common.BytesToAddress([]byte{0x0f, 0x0e}): &wrap{&bls12381G2Mul{}}, + common.BytesToAddress([]byte{0x0f, 0x0f}): &wrap{&bls12381G2MultiExp{}}, + common.BytesToAddress([]byte{0x0f, 0x10}): &wrap{&bls12381Pairing{}}, + common.BytesToAddress([]byte{0x0f, 0x11}): &wrap{&bls12381MapG1{}}, + common.BytesToAddress([]byte{0x0f, 0x12}): &wrap{&bls12381MapG2{}}, }   // EIP-152 test vectors @@ -101,7 +101,7 @@ p := allPrecompiles[common.HexToAddress(addr)] in := common.Hex2Bytes(test.Input) gas := p.RequiredGas(in) t.Run(fmt.Sprintf("%s-Gas=%d", test.Name, gas), func(t *testing.T) { - if res, _, err := RunPrecompiledContract(p, in, gas, nil); err != nil { + if res, _, err := RunPrecompiledContract(p, in, gas, nil, mockPrecompileContext); err != nil { t.Error(err) } else if common.Bytes2Hex(res) != test.Expected { t.Errorf("Expected %v, got %v", test.Expected, common.Bytes2Hex(res)) @@ -123,7 +123,7 @@ in := common.Hex2Bytes(test.Input) gas := p.RequiredGas(in) - 1   t.Run(fmt.Sprintf("%s-Gas=%d", test.Name, gas), func(t *testing.T) { - _, _, err := RunPrecompiledContract(p, in, gas, nil) + _, _, err := RunPrecompiledContract(p, in, gas, nil, mockPrecompileContext) if err.Error() != "out of gas" { t.Errorf("Expected error [out of gas], got [%v]", err) } @@ -140,7 +140,7 @@ p := allPrecompiles[common.HexToAddress(addr)] in := common.Hex2Bytes(test.Input) gas := p.RequiredGas(in) t.Run(test.Name, func(t *testing.T) { - _, _, err := RunPrecompiledContract(p, in, gas, nil) + _, _, err := RunPrecompiledContract(p, in, gas, nil, mockPrecompileContext) if err.Error() != test.ExpectedError { t.Errorf("Expected error [%v], got [%v]", test.ExpectedError, err) } @@ -172,7 +172,7 @@ start := time.Now() bench.ResetTimer() for i := 0; i < bench.N; i++ { copy(data, in) - res, _, err = RunPrecompiledContract(p, data, reqGas, nil) + res, _, err = RunPrecompiledContract(p, data, reqGas, nil, mockPrecompileContext) } bench.StopTimer() elapsed := uint64(time.Since(start))

diff --git op-geth/core/vm/evm.go Celo/core/vm/evm.go index 1945a3b4dbb68f2a5a5c060f0031fd3778c232dd..f35dd5a2e0d4fa02e2a0ba056c114e1f8b55f076 100644 --- op-geth/core/vm/evm.go +++ Celo/core/vm/evm.go @@ -40,13 +40,27 @@ // and is used by the BLOCKHASH EVM op code. GetHashFunc func(uint64) common.Hash )   -func (evm *EVM) precompile(addr common.Address) (PrecompiledContract, bool) { +func (evm *EVM) precompile(addr common.Address) (CeloPrecompiledContract, bool) { p, ok := evm.precompiles[addr] if evm.Config.PrecompileOverrides != nil { override := evm.Config.PrecompileOverrides(evm.chainRules, p, addr) - return override, override != nil + p = override + ok = override != nil + } + + var cp CeloPrecompiledContract + if ok { + cp = &wrap{p} + } else { + var celoPrecompiles map[common.Address]CeloPrecompiledContract + switch { + case evm.chainRules.IsCel2: + celoPrecompiles = PrecompiledCeloContractsCel2 + } + cp, ok = celoPrecompiles[addr] } - return p, ok + + return cp, ok }   // BlockContext provides the EVM with auxiliary information. Once provided @@ -71,6 +85,9 @@ Difficulty *big.Int // Provides information for DIFFICULTY BaseFee *big.Int // Provides information for BASEFEE (0 if vm runs with NoBaseFee flag and 0 gas price) BlobBaseFee *big.Int // Provides information for BLOBBASEFEE (0 if vm runs with NoBaseFee flag and 0 blob gas price) Random *common.Hash // Provides information for PREVRANDAO + + // Celo specific information + FeeCurrencyContext common.FeeCurrencyContext }   // TxContext provides the EVM with information about a transaction. @@ -222,7 +239,7 @@ } evm.Context.Transfer(evm.StateDB, caller.Address(), addr, value)   if isPrecompile { - ret, gas, err = RunPrecompiledContract(p, input, gas, evm.Config.Tracer) + ret, gas, err = RunPrecompiledContract(p, input, gas, evm.Config.Tracer, NewContext(caller.Address(), evm)) } else { // Initialise a new contract and set the code that is to be used by the EVM. // The contract is a scoped environment for this execution context only. @@ -292,7 +309,7 @@ var snapshot = evm.StateDB.Snapshot()   // It is allowed to call precompiles, even via delegatecall if p, isPrecompile := evm.precompile(addr); isPrecompile { - ret, gas, err = RunPrecompiledContract(p, input, gas, evm.Config.Tracer) + ret, gas, err = RunPrecompiledContract(p, input, gas, evm.Config.Tracer, NewContext(caller.Address(), evm)) } else { addrCopy := addr // Initialise a new contract and set the code that is to be used by the EVM. @@ -344,7 +361,7 @@ var snapshot = evm.StateDB.Snapshot()   // It is allowed to call precompiles, even via delegatecall if p, isPrecompile := evm.precompile(addr); isPrecompile { - ret, gas, err = RunPrecompiledContract(p, input, gas, evm.Config.Tracer) + ret, gas, err = RunPrecompiledContract(p, input, gas, evm.Config.Tracer, NewContext(caller.Address(), evm)) } else { addrCopy := addr // Initialise a new contract and make initialise the delegate values @@ -399,7 +416,7 @@ // future scenarios evm.StateDB.AddBalance(addr, new(uint256.Int), tracing.BalanceChangeTouchAccount)   if p, isPrecompile := evm.precompile(addr); isPrecompile { - ret, gas, err = RunPrecompiledContract(p, input, gas, evm.Config.Tracer) + ret, gas, err = RunPrecompiledContract(p, input, gas, evm.Config.Tracer, NewContext(caller.Address(), evm)) } else { // At this point, we use a copy of address. If we don't, the go compiler will // leak the 'contract' to the outer scope, and make allocation for 'contract'

diff --git op-geth/contracts/fee_currencies.go Celo/contracts/fee_currencies.go new file mode 100644 index 0000000000000000000000000000000000000000..d4c99ed0efe942e66deb279a65e4f6f7376fc636 --- /dev/null +++ Celo/contracts/fee_currencies.go @@ -0,0 +1,299 @@ +package contracts + +import ( + "errors" + "fmt" + "math" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/exchange" + "github.com/ethereum/go-ethereum/contracts/addresses" + "github.com/ethereum/go-ethereum/contracts/celo/abigen" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/log" +) + +var feeCurrencyABI *abi.ABI + +var ErrFeeCurrencyEVMCall = errors.New("fee-currency contract error during internal EVM call") + +func init() { + var err error + feeCurrencyABI, err = abigen.FeeCurrencyMetaData.GetAbi() + if err != nil { + panic(err) + } +} + +// Returns nil if debit is possible, used in tx pool validation +func TryDebitFees(tx *types.Transaction, from common.Address, backend *CeloBackend, feeContext common.FeeCurrencyContext) error { + amount := new(big.Int).SetUint64(tx.Gas()) + amount.Mul(amount, tx.GasFeeCap()) + + snapshot := backend.State.Snapshot() + evm := backend.NewEVM(&feeContext) + _, err := DebitFees(evm, tx.FeeCurrency(), from, amount) + backend.State.RevertToSnapshot(snapshot) + return err +} + +// Debits transaction fees from the transaction sender and stores them in the temporary address +func DebitFees(evm *vm.EVM, feeCurrency *common.Address, address common.Address, amount *big.Int) (uint64, error) { + // Hide this function from traces + if evm.Config.Tracer != nil && !evm.Config.Tracer.TraceDebitCredit { + origTracer := evm.Config.Tracer + defer func() { + evm.Config.Tracer = origTracer + }() + evm.Config.Tracer = nil + } + + if amount.Cmp(big.NewInt(0)) == 0 { + return 0, nil + } + + maxIntrinsicGasCost, ok := common.MaxAllowedIntrinsicGasCost(evm.Context.FeeCurrencyContext.IntrinsicGasCosts, feeCurrency) + if !ok { + return 0, fmt.Errorf("%w: %x", exchange.ErrUnregisteredFeeCurrency, feeCurrency) + } + + leftoverGas, err := evm.CallWithABI( + feeCurrencyABI, "debitGasFees", *feeCurrency, maxIntrinsicGasCost, + // debitGasFees(address from, uint256 value) parameters + address, amount, + ) + if err != nil { + if errors.Is(err, vm.ErrOutOfGas) { + // This basically is a configuration / contract error, since + // the contract itself used way more gas than was expected (including grace limit) + return 0, fmt.Errorf( + "%w: surpassed maximum allowed intrinsic gas for DebitFees() in fee-currency: %w", + ErrFeeCurrencyEVMCall, + err, + ) + } + return 0, fmt.Errorf( + "%w: DebitFees() call error: %w", + ErrFeeCurrencyEVMCall, + err, + ) + } + + gasUsed := maxIntrinsicGasCost - leftoverGas + log.Trace("DebitFees called", "feeCurrency", *feeCurrency, "gasUsed", gasUsed) + return gasUsed, err +} + +// Credits fees to the respective parties +// - the base fee goes to the fee handler +// - the transaction tip goes to the miner +// - the l1 data fee goes the the data fee receiver, is the node runs in rollup mode +// - remaining funds are refunded to the transaction sender +func CreditFees( + evm *vm.EVM, + feeCurrency *common.Address, + txSender, tipReceiver, baseFeeReceiver, l1DataFeeReceiver common.Address, + refund, feeTip, baseFee, l1DataFee *big.Int, + gasUsedDebit uint64, +) error { + // Hide this function from traces + if evm.Config.Tracer != nil && !evm.Config.Tracer.TraceDebitCredit { + origTracer := evm.Config.Tracer + defer func() { + evm.Config.Tracer = origTracer + }() + evm.Config.Tracer = nil + } + + // Our old `creditGasFees` function does not accept an l1DataFee and + // the fee currencies do not implement the new interface yet. Since tip + // and data fee both go to the sequencer, we can work around that for + // now by addint the l1DataFee to the tip. + if l1DataFee != nil { + feeTip = new(big.Int).Add(feeTip, l1DataFee) + } + + // Not all fee currencies can handle a receiver being the zero address. + // In that case send the fee to the base fee recipient, which we know is non-zero. + if tipReceiver.Cmp(common.ZeroAddress) == 0 { + tipReceiver = baseFeeReceiver + } + maxAllowedGasForDebitAndCredit, ok := common.MaxAllowedIntrinsicGasCost(evm.Context.FeeCurrencyContext.IntrinsicGasCosts, feeCurrency) + if !ok { + return fmt.Errorf("%w: %x", exchange.ErrUnregisteredFeeCurrency, feeCurrency) + } + + maxAllowedGasForCredit := maxAllowedGasForDebitAndCredit - gasUsedDebit + leftoverGas, err := evm.CallWithABI( + feeCurrencyABI, "creditGasFees", *feeCurrency, maxAllowedGasForCredit, + // function creditGasFees( + // address from, + // address feeRecipient, + // address, // gatewayFeeRecipient, unused + // address communityFund, + // uint256 refund, + // uint256 tipTxFee, + // uint256, // gatewayFee, unused + // uint256 baseTxFee + // ) + txSender, tipReceiver, common.ZeroAddress, baseFeeReceiver, refund, feeTip, common.Big0, baseFee, + ) + if err != nil { + if errors.Is(err, vm.ErrOutOfGas) { + // This is a configuration / contract error, since + // the contract itself used way more gas than was expected (including grace limit) + return fmt.Errorf( + "%w: surpassed maximum allowed intrinsic gas for CreditFees() in fee-currency: %w", + ErrFeeCurrencyEVMCall, + err, + ) + } + return fmt.Errorf( + "%w: CreditFees() call error: %w", + ErrFeeCurrencyEVMCall, + err, + ) + } + + gasUsed := maxAllowedGasForCredit - leftoverGas + log.Trace("CreditFees called", "feeCurrency", *feeCurrency, "gasUsed", gasUsed) + + intrinsicGas, ok := common.CurrencyIntrinsicGasCost(evm.Context.FeeCurrencyContext.IntrinsicGasCosts, feeCurrency) + if !ok { + // this will never happen + return fmt.Errorf("%w: %x", exchange.ErrUnregisteredFeeCurrency, feeCurrency) + } + gasUsedForDebitAndCredit := gasUsedDebit + gasUsed + if gasUsedForDebitAndCredit > intrinsicGas { + log.Info( + "Gas usage for debit+credit exceeds intrinsic gas!", + "gasUsed", gasUsedForDebitAndCredit, + "intrinsicGas", intrinsicGas, + "feeCurrency", feeCurrency, + ) + } + return err +} + +func GetRegisteredCurrencies(caller *abigen.FeeCurrencyDirectoryCaller) ([]common.Address, error) { + currencies, err := caller.GetCurrencies(&bind.CallOpts{}) + if err != nil { + return currencies, fmt.Errorf("failed to get registered tokens: %w", err) + } + return currencies, nil +} + +// GetExchangeRates returns the exchange rates for the provided gas currencies +func GetExchangeRates(caller *CeloBackend) (common.ExchangeRates, error) { + directory, err := abigen.NewFeeCurrencyDirectoryCaller( + addresses.GetAddressesOrDefault(caller.ChainConfig.ChainID, addresses.MainnetAddresses).FeeCurrencyDirectory, + caller, + ) + if err != nil { + return common.ExchangeRates{}, fmt.Errorf("failed to access FeeCurrencyDirectory: %w", err) + } + currencies, err := GetRegisteredCurrencies(directory) + if err != nil { + return common.ExchangeRates{}, err + } + return getExchangeRatesForTokens(directory, currencies) +} + +// GetFeeCurrencyContext returns the fee currency block context for all registered gas currencies from CELO +func GetFeeCurrencyContext(caller *CeloBackend) (common.FeeCurrencyContext, error) { + var feeContext common.FeeCurrencyContext + directory, err := abigen.NewFeeCurrencyDirectoryCaller( + addresses.GetAddressesOrDefault(caller.ChainConfig.ChainID, addresses.MainnetAddresses).FeeCurrencyDirectory, + caller, + ) + if err != nil { + return feeContext, fmt.Errorf("failed to access FeeCurrencyDirectory: %w", err) + } + + currencies, err := GetRegisteredCurrencies(directory) + if err != nil { + return feeContext, err + } + rates, err := getExchangeRatesForTokens(directory, currencies) + if err != nil { + return feeContext, err + } + intrinsicGas, err := getIntrinsicGasForTokens(directory, currencies) + if err != nil { + return feeContext, err + } + return common.FeeCurrencyContext{ + ExchangeRates: rates, + IntrinsicGasCosts: intrinsicGas, + }, nil +} + +// GetBalanceERC20 returns an account's balance on a given ERC20 currency +func GetBalanceERC20(caller bind.ContractCaller, accountOwner common.Address, contractAddress common.Address) (result *big.Int, err error) { + token, err := abigen.NewFeeCurrencyCaller(contractAddress, caller) + if err != nil { + return nil, fmt.Errorf("failed to access FeeCurrency: %w", err) + } + + balance, err := token.BalanceOf(&bind.CallOpts{}, accountOwner) + if err != nil { + return nil, err + } + + return balance, nil +} + +// GetFeeBalance returns the account's balance from the specified feeCurrency +// (if feeCurrency is nil or ZeroAddress, native currency balance is returned). +func GetFeeBalance(backend *CeloBackend, account common.Address, feeCurrency *common.Address) *big.Int { + if feeCurrency == nil || *feeCurrency == common.ZeroAddress { + return backend.State.GetBalance(account).ToBig() + } + balance, err := GetBalanceERC20(backend, account, *feeCurrency) + if err != nil { + log.Error("Error while trying to get ERC20 balance:", "cause", err, "contract", feeCurrency.Hex(), "account", account.Hex()) + } + return balance +} + +// getIntrinsicGasForTokens returns the intrinsic gas costs for the provided gas currencies from CELO +func getIntrinsicGasForTokens(caller *abigen.FeeCurrencyDirectoryCaller, tokens []common.Address) (common.IntrinsicGasCosts, error) { + gasCosts := common.IntrinsicGasCosts{} + for _, tokenAddress := range tokens { + config, err := caller.GetCurrencyConfig(&bind.CallOpts{}, tokenAddress) + if err != nil { + log.Error("Failed to get intrinsic gas cost for gas currency!", "err", err, "tokenAddress", tokenAddress.Hex()) + continue + } + if !config.IntrinsicGas.IsUint64() { + log.Error("Intrinsic gas cost exceeds MaxUint64 limit, capping at MaxUint64", "err", err, "tokenAddress", tokenAddress.Hex()) + gasCosts[tokenAddress] = math.MaxUint64 + } else { + gasCosts[tokenAddress] = config.IntrinsicGas.Uint64() + } + } + return gasCosts, nil +} + +// getExchangeRatesForTokens returns the exchange rates for the provided gas currencies from CELO +func getExchangeRatesForTokens(caller *abigen.FeeCurrencyDirectoryCaller, tokens []common.Address) (common.ExchangeRates, error) { + exchangeRates := common.ExchangeRates{} + for _, tokenAddress := range tokens { + rate, err := caller.GetExchangeRate(&bind.CallOpts{}, tokenAddress) + if err != nil { + log.Error("Failed to get medianRate for gas currency!", "err", err, "tokenAddress", tokenAddress.Hex()) + continue + } + if rate.Numerator.Sign() <= 0 || rate.Denominator.Sign() <= 0 { + log.Error("Bad exchange rate for fee currency", "tokenAddress", tokenAddress.Hex(), "numerator", rate.Numerator, "denominator", rate.Denominator) + continue + } + exchangeRates[tokenAddress] = new(big.Rat).SetFrac(rate.Numerator, rate.Denominator) + } + + return exchangeRates, nil +}

diff --git op-geth/core/blockchain_celo_test.go Celo/core/blockchain_celo_test.go new file mode 100644 index 0000000000000000000000000000000000000000..d0f2a4bb1d0bf1ad3a0640d83d86bdb4f2570b01 --- /dev/null +++ Celo/core/blockchain_celo_test.go @@ -0,0 +1,146 @@ +// Copyright 2014 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. + +package core + +import ( + "math/big" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/exchange" + "github.com/ethereum/go-ethereum/consensus/ethash" + "github.com/ethereum/go-ethereum/contracts" + "github.com/ethereum/go-ethereum/contracts/addresses" + "github.com/ethereum/go-ethereum/core/rawdb" + "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/params" + "github.com/stretchr/testify/assert" +) + +// TestNativeTransferWithFeeCurrency tests the following: +// +// 1. A transaction whose gasFeeCap is greater than the baseFee is valid. +// 2. Gas accounting for celo fee currency transactions is correct. +// 3. Only the transaction's tip will be received by the coinbase. +// 4. The transaction sender pays for both the tip and baseFee. +// 5. The base fee goes to the fee handler. +func TestNativeTransferWithFeeCurrency(t *testing.T) { + testNativeTransferWithFeeCurrency(t, rawdb.HashScheme, DevFeeCurrencyAddr2) + testNativeTransferWithFeeCurrency(t, rawdb.PathScheme, DevFeeCurrencyAddr2) +} + +// Test that the gas price is checked against the base fee in the same currency. +// The tx has a GasFeeCap that matches the blocks base fee, so it would succeed +// when compared without currency conversion, but it must fail if the check is +// correct. +func TestNativeTransferWithFeeCurrencyAndTooLowGasPrice(t *testing.T) { + assert.PanicsWithError(t, "max fee per gas less than block base fee: address 0x71562b71999873DB5b286dF957af199Ec94617F7, maxFeePerGas: 875000000, baseFee: 1750000000", + func() { testNativeTransferWithFeeCurrency(t, rawdb.HashScheme, DevFeeCurrencyAddr) }, + ) +} + +func testNativeTransferWithFeeCurrency(t *testing.T, scheme string, feeCurrencyAddr common.Address) { + var ( + aa = common.HexToAddress("0x000000000000000000000000000000000000aaaa") + engine = ethash.NewFaker() + + // A sender who makes transactions, has some funds + key1, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") + addr1 = crypto.PubkeyToAddress(key1.PublicKey) + config = *params.AllEthashProtocolChanges + funds = DevBalance + gspec = &Genesis{ + Config: &config, + Alloc: CeloGenesisAccounts(addr1), + } + ) + gspec.Config.Cel2Time = uint64ptr(0) + + signer := types.LatestSigner(gspec.Config) + + _, blocks, _ := GenerateChainWithGenesis(gspec, engine, 1, func(i int, b *BlockGen) { + b.SetCoinbase(common.Address{1}) + + txdata := &types.CeloDynamicFeeTxV2{ + ChainID: gspec.Config.ChainID, + Nonce: 0, + To: &aa, + Gas: 100000, + GasFeeCap: b.header.BaseFee, + GasTipCap: big.NewInt(2), + Data: []byte{}, + FeeCurrency: &feeCurrencyAddr, + } + tx := types.NewTx(txdata) + tx, _ = types.SignTx(tx, signer, key1) + + b.AddTx(tx) + }) + chain, err := NewBlockChain(rawdb.NewMemoryDatabase(), DefaultCacheConfigWithScheme(scheme), gspec, nil, engine, vm.Config{}, nil) + if err != nil { + t.Fatalf("failed to create tester chain: %v", err) + } + defer chain.Stop() + + if n, err := chain.InsertChain(blocks); err != nil { + t.Fatalf("block %d: failed to insert into chain: %v", n, err) + } + + block := chain.GetBlockByNumber(1) + + // 1+2: Ensure correct gas amount is deducted + expectedGas := uint64(71000) + if block.GasUsed() != expectedGas { + t.Fatalf("incorrect amount of gas spent: expected %d, got %d", expectedGas, block.GasUsed()) + } + + state, _ := chain.State() + + backend := contracts.CeloBackend{ + ChainConfig: chain.chainConfig, + State: state, + } + exchangeRates, err := contracts.GetExchangeRates(&backend) + if err != nil { + t.Fatal("could not get exchange rates") + } + baseFeeInFeeCurrency, _ := exchange.ConvertCeloToCurrency(exchangeRates, &feeCurrencyAddr, block.BaseFee()) + actual, _ := contracts.GetBalanceERC20(&backend, block.Coinbase(), feeCurrencyAddr) + + // 3: Ensure that miner received only the tx's tip. + expected := new(big.Int).SetUint64(block.GasUsed() * block.Transactions()[0].GasTipCap().Uint64()) + if actual.Cmp(expected) != 0 { + t.Fatalf("miner balance incorrect: expected %d, got %d", expected, actual) + } + + // 4: Ensure the tx sender paid for the gasUsed * (tip + block baseFee). + actual, _ = contracts.GetBalanceERC20(&backend, addr1, feeCurrencyAddr) + actual = new(big.Int).Sub(funds, actual) + expected = new(big.Int).SetUint64(block.GasUsed() * (block.Transactions()[0].GasTipCap().Uint64() + baseFeeInFeeCurrency.Uint64())) + if actual.Cmp(expected) != 0 { + t.Fatalf("sender balance incorrect: expected %d, got %d", expected, actual) + } + + // 5: Check that base fee has been moved to the fee handler. + actual, _ = contracts.GetBalanceERC20(&backend, addresses.MainnetAddresses.FeeHandler, feeCurrencyAddr) + expected = new(big.Int).SetUint64(block.GasUsed() * baseFeeInFeeCurrency.Uint64()) + if actual.Cmp(expected) != 0 { + t.Fatalf("fee handler balance incorrect: expected %d, got %d", expected, actual) + } +}

diff --git op-geth/core/celo_evm.go Celo/core/celo_evm.go new file mode 100644 index 0000000000000000000000000000000000000000..3858f30aeee2f9891893b17c1f90619334b8beb9 --- /dev/null +++ Celo/core/celo_evm.go @@ -0,0 +1,38 @@ +package core + +import ( + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/contracts" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/params" +) + +func GetFeeCurrencyContext(header *types.Header, config *params.ChainConfig, statedb vm.StateDB) *common.FeeCurrencyContext { + if !config.IsCel2(header.Time) { + return &common.FeeCurrencyContext{} + } + + caller := &contracts.CeloBackend{ChainConfig: config, State: statedb} + + feeCurrencyContext, err := contracts.GetFeeCurrencyContext(caller) + if err != nil { + log.Error("Error fetching exchange rates!", "err", err) + } + return &feeCurrencyContext +} + +func GetExchangeRates(header *types.Header, config *params.ChainConfig, statedb vm.StateDB) common.ExchangeRates { + if !config.IsCel2(header.Time) { + return nil + } + + caller := &contracts.CeloBackend{ChainConfig: config, State: statedb} + + feeCurrencyContext, err := contracts.GetFeeCurrencyContext(caller) + if err != nil { + log.Error("Error fetching exchange rates!", "err", err) + } + return feeCurrencyContext.ExchangeRates +}

diff --git op-geth/core/evm.go Celo/core/evm.go index e8016fbb782145ac28fdf78e02e59f0e2b9784be..11a665b4f7be978ef83f19f4a688f861c044d29f 100644 --- op-geth/core/evm.go +++ Celo/core/evm.go @@ -40,7 +40,7 @@ GetHeader(common.Hash, uint64) *types.Header }   // NewEVMBlockContext creates a new context for use in the EVM. -func NewEVMBlockContext(header *types.Header, chain ChainContext, author *common.Address, config *params.ChainConfig, statedb types.StateGetter) vm.BlockContext { +func NewEVMBlockContext(header *types.Header, chain ChainContext, author *common.Address, config *params.ChainConfig, statedb vm.StateDB, feeCurrencyContext *common.FeeCurrencyContext) vm.BlockContext { var ( beneficiary common.Address baseFee *big.Int @@ -63,7 +63,7 @@ } if header.Difficulty.Sign() == 0 { random = &header.MixDigest } - return vm.BlockContext{ + blockContext := vm.BlockContext{ CanTransfer: CanTransfer, Transfer: Transfer, GetHash: GetHashFn(header, chain), @@ -77,6 +77,12 @@ GasLimit: header.GasLimit, Random: random, L1CostFunc: types.NewL1CostFunc(config, statedb), } + + if config.IsCel2(header.Time) { + blockContext.FeeCurrencyContext = *feeCurrencyContext + } + + return blockContext }   // NewEVMTxContext creates a new transaction context for a single transaction.

diff --git op-geth/core/state_processor.go Celo/core/state_processor.go index a1042cf868eac6a0e09ae481547ee435c3e84ead..363cd3ee40381c6d84b9e4b87dbe740ee037e542 100644 --- op-geth/core/state_processor.go +++ Celo/core/state_processor.go @@ -21,11 +21,13 @@ "fmt" "math/big"   "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/exchange" "github.com/ethereum/go-ethereum/consensus/misc" "github.com/ethereum/go-ethereum/core/state" "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/log" "github.com/ethereum/go-ethereum/params" )   @@ -74,7 +76,8 @@ context vm.BlockContext signer = types.MakeSigner(p.config, header.Number, header.Time) err error ) - context = NewEVMBlockContext(header, p.chain, nil, p.config, statedb) + feeCurrencyContext := GetFeeCurrencyContext(header, p.config, statedb) + context = NewEVMBlockContext(header, p.chain, nil, p.config, statedb, feeCurrencyContext) vmenv := vm.NewEVM(context, vm.TxContext{}, statedb, p.config, cfg) if beaconRoot := block.BeaconRoot(); beaconRoot != nil { ProcessBeaconBlockRoot(*beaconRoot, vmenv, statedb) @@ -84,7 +87,7 @@ ProcessParentBlockHash(block.ParentHash(), vmenv, statedb) } // Iterate over and process the individual transactions for i, tx := range block.Transactions() { - msg, err := TransactionToMessage(tx, signer, header.BaseFee) + msg, err := TransactionToMessage(tx, signer, header.BaseFee, context.FeeCurrencyContext.ExchangeRates) if err != nil { return nil, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err) } @@ -180,6 +183,17 @@ receipt.DepositReceiptVersion = new(uint64) *receipt.DepositReceiptVersion = types.CanyonDepositReceiptVersion } } + if tx.Type() == types.CeloDynamicFeeTxV2Type { + alternativeBaseFee := evm.Context.BaseFee + if tx.FeeCurrency() != nil { + var err error + alternativeBaseFee, err = exchange.ConvertCeloToCurrency(evm.Context.FeeCurrencyContext.ExchangeRates, tx.FeeCurrency(), evm.Context.BaseFee) + if err != nil { + log.Error("Can't calc base fee in currency for receipt", "err", err) + } + } + receipt.BaseFee = new(big.Int).Set(alternativeBaseFee) + } if tx.Type() == types.BlobTxType { receipt.BlobGasUsed = uint64(len(tx.BlobHashes()) * params.BlobTxBlobGasPerBlob) receipt.BlobGasPrice = evm.Context.BlobBaseFee @@ -209,16 +223,16 @@ // ApplyTransaction attempts to apply a transaction to the given state database // and uses the input parameters for its environment. It returns the receipt // for the transaction, gas used and an error if the transaction failed, // indicating the block was invalid. -func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config) (*types.Receipt, error) { - return ApplyTransactionExtended(config, bc, author, gp, statedb, header, tx, usedGas, cfg, nil) +func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config, feeCurrencyContext *common.FeeCurrencyContext) (*types.Receipt, error) { + return ApplyTransactionExtended(config, bc, author, gp, statedb, header, tx, usedGas, cfg, nil, feeCurrencyContext) }   type ApplyTransactionOpts struct { PostValidation func(evm *vm.EVM, result *ExecutionResult) error }   -func ApplyTransactionExtended(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config, extraOpts *ApplyTransactionOpts) (*types.Receipt, error) { - msg, err := TransactionToMessage(tx, types.MakeSigner(config, header.Number, header.Time), header.BaseFee) +func ApplyTransactionExtended(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config, extraOpts *ApplyTransactionOpts, feeCurrencyContext *common.FeeCurrencyContext) (*types.Receipt, error) { + msg, err := TransactionToMessage(tx, types.MakeSigner(config, header.Number, header.Time), header.BaseFee, feeCurrencyContext.ExchangeRates) if err != nil { return nil, err } @@ -226,7 +240,7 @@ if extraOpts != nil { msg.PostValidation = extraOpts.PostValidation } // Create a new context to be used in the EVM environment - blockContext := NewEVMBlockContext(header, bc, author, config, statedb) + blockContext := NewEVMBlockContext(header, bc, author, config, statedb, feeCurrencyContext) txContext := NewEVMTxContext(msg) vmenv := vm.NewEVM(blockContext, txContext, statedb, config, cfg) return ApplyTransactionWithEVM(msg, config, gp, statedb, header.Number, header.Hash(), tx, usedGas, vmenv)

diff --git op-geth/core/state_transition.go Celo/core/state_transition.go index 2de1cad7626c317894ed184a19daecc4f5e44c4b..edd0bd5eae19a835eb3135712d267289bbe89cb1 100644 --- op-geth/core/state_transition.go +++ Celo/core/state_transition.go @@ -22,11 +22,13 @@ "math" "math/big"   "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/exchange" cmath "github.com/ethereum/go-ethereum/common/math" "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/kzg4844" + "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" "github.com/holiman/uint256" ) @@ -68,7 +70,7 @@ return common.CopyBytes(result.ReturnData) }   // IntrinsicGas computes the 'intrinsic gas' for a message with the given data. -func IntrinsicGas(data []byte, accessList types.AccessList, isContractCreation, isHomestead, isEIP2028, isEIP3860 bool) (uint64, error) { +func IntrinsicGas(data []byte, accessList types.AccessList, isContractCreation, isHomestead, isEIP2028, isEIP3860 bool, feeCurrency *common.Address, feeIntrinsicGas common.IntrinsicGasCosts) (uint64, error) { // Set the starting gas for the raw transaction var gas uint64 if isContractCreation && isHomestead { @@ -110,6 +112,32 @@ } gas += lenWords * params.InitCodeWordGas } } + + // This gas is used for charging user for one `transfer` call to deduct their fee in + // non-native currency and (up to) three `transfer` calls for fee payouts. + // The three transfers cover the following cases: + // - Base fee transfer to the fee handler + // - Tip fee transfer to the block proposer + // - Refund of leftover fees to the transaction sender + // + // A user might or might not have a gas refund at the end and even if they do the gas refund might + // be smaller than maxGasForDebitAndCreditTransactions. We still decide to deduct and do the refund + // since it makes the mining fee more consistent with respect to the gas fee. Otherwise, we would + // have to expect the user to estimate the mining fee right or else end up losing + // `min(gas sent - gas charged, maxGasForDebitAndCreditTransactions)` extra. + // In this case, however, the user always ends up paying `maxGasForDebitAndCreditTransactions` + // keeping it consistent. + if feeCurrency != nil { + intrinsicGasForFeeCurrency, ok := common.CurrencyIntrinsicGasCost(feeIntrinsicGas, feeCurrency) + if !ok { + return 0, fmt.Errorf("%w: %x", exchange.ErrUnregisteredFeeCurrency, feeCurrency) + } + if (math.MaxUint64 - gas) < intrinsicGasForFeeCurrency { + return 0, ErrGasUintOverflow + } + gas += intrinsicGasForFeeCurrency + } + if accessList != nil { gas += uint64(len(accessList)) * params.TxAccessListAddressGas gas += uint64(accessList.StorageKeys()) * params.TxAccessListStorageKeyGas @@ -156,10 +184,18 @@ 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   PostValidation func(evm *vm.EVM, result *ExecutionResult) error + + // Celo additions + + // FeeCurrency specifies the currency for gas fees. + // `nil` corresponds to CELO (native currency). + // All other values should correspond to ERC20 contract addresses. + FeeCurrency *common.Address + MaxFeeInFeeCurrency *big.Int // MaxFeeInFeeCurrency is the maximum fee that can be charged in the fee currency. }   // TransactionToMessage converts a transaction into a Message. -func TransactionToMessage(tx *types.Transaction, s types.Signer, baseFee *big.Int) (*Message, error) { +func TransactionToMessage(tx *types.Transaction, s types.Signer, baseFee *big.Int, exchangeRates map[common.Address]*big.Rat) (*Message, error) { msg := &Message{ Nonce: tx.Nonce(), GasLimit: tx.Gas(), @@ -179,9 +215,19 @@ IsSystemTx: tx.IsSystemTx(), IsDepositTx: tx.IsDepositTx(), Mint: tx.Mint(), RollupCostData: tx.RollupCostData(), + + FeeCurrency: tx.FeeCurrency(), + MaxFeeInFeeCurrency: nil, // Will only be set once CIP-66 is implemented } // If baseFee provided, set gasPrice to effectiveGasPrice. if baseFee != nil { + if tx.Type() == types.CeloDynamicFeeTxV2Type { + var err error + baseFee, err = exchange.ConvertCeloToCurrency(exchangeRates, msg.FeeCurrency, baseFee) + if err != nil { + return nil, err + } + } msg.GasPrice = cmath.BigMin(msg.GasPrice.Add(msg.GasTipCap, baseFee), msg.GasFeeCap) } var err error @@ -189,6 +235,13 @@ msg.From, err = types.Sender(s, tx) return msg, err }   +// IsFeeCurrencyDenominated returns whether the gas-price related +// fields are denominated in a given fee currency or in the native token. +// This effectively is only true for CIP-64 transactions. +func (msg *Message) IsFeeCurrencyDenominated() bool { + return msg.FeeCurrency != nil && msg.MaxFeeInFeeCurrency == nil +} + // ApplyMessage computes the new state by applying the given message // against the old state within the environment. // @@ -197,6 +250,7 @@ // the gas used (which includes gas refunds) and an error if it failed. An error always // indicates a core error meaning that the message would always fail for that particular // state and would never be accepted within a block. func ApplyMessage(evm *vm.EVM, msg *Message, gp *GasPool) (*ExecutionResult, error) { + log.Trace("Applying state transition message", "from", msg.From, "nonce", msg.Nonce, "to", msg.To, "gasPrice", msg.GasPrice, "feeCurrency", msg.FeeCurrency, "gas", msg.GasLimit, "value", msg.Value, "data", msg.Data) return NewStateTransition(evm, msg, gp).TransitionDb() }   @@ -229,6 +283,8 @@ gasRemaining uint64 initialGas uint64 state vm.StateDB evm *vm.EVM + + feeCurrencyGasUsed uint64 }   // NewStateTransition initialises and returns a new state transition object. @@ -267,7 +323,8 @@ if l1Cost != nil { balanceCheck.Add(balanceCheck, l1Cost) } } - balanceCheck.Add(balanceCheck, st.msg.Value) + // Moved to canPayFee + // balanceCheck.Add(balanceCheck, st.msg.Value)   if st.evm.ChainConfig().IsCancun(st.evm.Context.BlockNumber, st.evm.Context.Time) { if blobGas := st.blobGasUsed(); blobGas > 0 { @@ -281,12 +338,8 @@ blobFee.Mul(blobFee, st.evm.Context.BlobBaseFee) mgval.Add(mgval, blobFee) } } - balanceCheckU256, overflow := uint256.FromBig(balanceCheck) - if overflow { - return fmt.Errorf("%w: address %v required balance exceeds 256 bits", ErrInsufficientFunds, st.msg.From.Hex()) - } - if have, want := st.state.GetBalance(st.msg.From), balanceCheckU256; have.Cmp(want) < 0 { - return fmt.Errorf("%w: address %v have %v want %v", ErrInsufficientFunds, st.msg.From.Hex(), have, want) + if err := st.canPayFee(balanceCheck); err != nil { + return err } if err := st.gp.SubGas(st.msg.GasLimit); err != nil { return err @@ -298,9 +351,8 @@ } st.gasRemaining = st.msg.GasLimit   st.initialGas = st.msg.GasLimit - mgvalU256, _ := uint256.FromBig(mgval) - st.state.SubBalance(st.msg.From, mgvalU256, tracing.BalanceDecreaseGasBuy) - return nil + + return st.subFees(mgval) }   func (st *StateTransition) preCheck() error { @@ -343,6 +395,19 @@ return fmt.Errorf("%w: address %v, codehash: %s", ErrSenderNoEOA, msg.From.Hex(), codeHash) } } + + // Verify that fee currency is registered + if msg.FeeCurrency != nil { + if !st.evm.ChainConfig().IsCel2(st.evm.Context.Time) { + return ErrCel2NotEnabled + } else { + if !common.IsCurrencyAllowed(st.evm.Context.FeeCurrencyContext.ExchangeRates, msg.FeeCurrency) { + log.Trace("fee currency not allowed", "fee currency address", msg.FeeCurrency) + return fmt.Errorf("%w: %x", exchange.ErrUnregisteredFeeCurrency, msg.FeeCurrency) + } + } + } + // 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) @@ -360,14 +425,20 @@ if msg.GasFeeCap.Cmp(msg.GasTipCap) < 0 { return fmt.Errorf("%w: address %v, maxPriorityFeePerGas: %s, maxFeePerGas: %s", ErrTipAboveFeeCap, msg.From.Hex(), msg.GasTipCap, msg.GasFeeCap) } + // This will panic if baseFee is nil, but basefee presence is verified // as part of header validation. - if msg.GasFeeCap.Cmp(st.evm.Context.BaseFee) < 0 { + baseFeeInFeeCurrency, err := exchange.ConvertCeloToCurrency(st.evm.Context.FeeCurrencyContext.ExchangeRates, msg.FeeCurrency, st.evm.Context.BaseFee) + if err != nil { + return fmt.Errorf("preCheck: %w", err) + } + if msg.GasFeeCap.Cmp(baseFeeInFeeCurrency) < 0 { return fmt.Errorf("%w: address %v, maxFeePerGas: %s, baseFee: %s", ErrFeeCapTooLow, - msg.From.Hex(), msg.GasFeeCap, st.evm.Context.BaseFee) + msg.From.Hex(), msg.GasFeeCap, baseFeeInFeeCurrency) } } } + // Check the blob version validity if msg.BlobHashes != nil { // The to field of a blob tx type is mandatory, and a `BlobTx` transaction internally @@ -470,11 +541,6 @@ // 4. the purchased gas is enough to cover intrinsic usage // 5. there is no overflow when calculating intrinsic gas // 6. caller has enough balance to cover asset transfer for **topmost** call   - // Check clauses 1-3, buy gas if everything is correct - if err := st.preCheck(); err != nil { - return nil, err - } - var ( msg = st.msg sender = vm.AccountRef(msg.From) @@ -482,8 +548,27 @@ rules = st.evm.ChainConfig().Rules(st.evm.Context.BlockNumber, st.evm.Context.Random != nil, st.evm.Context.Time) contractCreation = msg.To == nil )   + // Execute the preparatory steps for state transition which includes: + // - prepare accessList(post-berlin) + // - reset transient storage(eip 1153) + st.state.Prepare(rules, msg.From, st.evm.Context.Coinbase, msg.To, vm.ActivePrecompiles(rules), msg.AccessList) + + // Check clauses 1-3, buy gas if everything is correct + if err := st.preCheck(); err != nil { + return nil, err + } + // Check clauses 4-5, subtract intrinsic gas if everything is correct - gas, err := IntrinsicGas(msg.Data, msg.AccessList, contractCreation, rules.IsHomestead, rules.IsIstanbul, rules.IsShanghai) + gas, err := IntrinsicGas( + msg.Data, + msg.AccessList, + contractCreation, + rules.IsHomestead, + rules.IsIstanbul, + rules.IsShanghai, + msg.FeeCurrency, + st.evm.Context.FeeCurrencyContext.IntrinsicGasCosts, + ) if err != nil { return nil, err } @@ -520,11 +605,6 @@ // Check whether the init code size has been exceeded. if rules.IsShanghai && contractCreation && len(msg.Data) > params.MaxInitCodeSize { return nil, fmt.Errorf("%w: code size %v limit %v", ErrMaxInitCodeSizeExceeded, len(msg.Data), params.MaxInitCodeSize) } - - // Execute the preparatory steps for state transition which includes: - // - prepare accessList(post-berlin) - // - reset transient storage(eip 1153) - st.state.Prepare(rules, msg.From, st.evm.Context.Coinbase, msg.To, vm.ActivePrecompiles(rules), msg.AccessList)   var ( ret []byte @@ -573,43 +653,9 @@ Err: vmerr, ReturnData: ret, }, nil } - effectiveTip := msg.GasPrice - if rules.IsLondon { - effectiveTip = cmath.BigMin(msg.GasTipCap, new(big.Int).Sub(msg.GasFeeCap, st.evm.Context.BaseFee)) - } - effectiveTipU256, _ := uint256.FromBig(effectiveTip)   - if st.evm.Config.NoBaseFee && msg.GasFeeCap.Sign() == 0 && msg.GasTipCap.Sign() == 0 { - // Skip fee payment when NoBaseFee is set and the fee fields - // are 0. This avoids a negative effectiveTip being applied to - // the coinbase when simulating calls. - } else { - fee := new(uint256.Int).SetUint64(st.gasUsed()) - fee.Mul(fee, effectiveTipU256) - st.state.AddBalance(st.evm.Context.Coinbase, fee, tracing.BalanceIncreaseRewardTransactionFee) - - // add the coinbase to the witness iff the fee is greater than 0 - if rules.IsEIP4762 && fee.Sign() != 0 { - st.evm.AccessEvents.AddAccount(st.evm.Context.Coinbase, true) - } - - // Check that we are post bedrock to enable op-geth to be able to create pseudo pre-bedrock blocks (these are pre-bedrock, but don't follow l2 geth rules) - // Note optimismConfig will not be nil if rules.IsOptimismBedrock is true - if optimismConfig := st.evm.ChainConfig().Optimism; optimismConfig != nil && rules.IsOptimismBedrock && !st.msg.IsDepositTx { - gasCost := new(big.Int).Mul(new(big.Int).SetUint64(st.gasUsed()), st.evm.Context.BaseFee) - amtU256, overflow := uint256.FromBig(gasCost) - if overflow { - return nil, fmt.Errorf("optimism gas cost overflows U256: %d", gasCost) - } - st.state.AddBalance(params.OptimismBaseFeeRecipient, amtU256, tracing.BalanceIncreaseRewardTransactionFee) - if l1Cost := st.evm.Context.L1CostFunc(st.msg.RollupCostData, st.evm.Context.Time); l1Cost != nil { - amtU256, overflow = uint256.FromBig(l1Cost) - if overflow { - return nil, fmt.Errorf("optimism l1 cost overflows U256: %d", l1Cost) - } - st.state.AddBalance(params.OptimismL1FeeRecipient, amtU256, tracing.BalanceIncreaseRewardTransactionFee) - } - } + if err := st.distributeTxFees(); err != nil { + return nil, err }   return &ExecutionResult{ @@ -633,14 +679,7 @@ }   st.gasRemaining += refund   - // Return ETH for remaining gas, exchanged at the original rate. - remaining := uint256.NewInt(st.gasRemaining) - remaining.Mul(remaining, uint256.MustFromBig(st.msg.GasPrice)) - st.state.AddBalance(st.msg.From, remaining, tracing.BalanceIncreaseGasReturn) - - if st.evm.Config.Tracer != nil && st.evm.Config.Tracer.OnGasChange != nil && st.gasRemaining > 0 { - st.evm.Config.Tracer.OnGasChange(st.gasRemaining, 0, tracing.GasChangeTxLeftOverReturned) - } + // Gas refund now handled in `distributeTxFees`   // Also return remaining gas to the block gas counter so it is // available for the next transaction.

diff --git op-geth/core/txpool/blobpool/blobpool.go Celo/core/txpool/blobpool/blobpool.go index 19908d9e8fb61078ff0242728bbc89cac0c2371f..e94a6d69c7225ecd996a7f939bfa59b02354d444 100644 --- op-geth/core/txpool/blobpool/blobpool.go +++ Celo/core/txpool/blobpool/blobpool.go @@ -32,6 +32,7 @@ "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/consensus/misc/eip1559" "github.com/ethereum/go-ethereum/consensus/misc/eip4844" + "github.com/ethereum/go-ethereum/contracts" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/txpool" @@ -116,7 +117,7 @@ hash: tx.Hash(), id: id, size: size, nonce: tx.Nonce(), - costCap: uint256.MustFromBig(tx.Cost()), + costCap: uint256.MustFromBig(tx.NativeCost()), execTipCap: uint256.MustFromBig(tx.GasTipCap()), execFeeCap: uint256.MustFromBig(tx.GasFeeCap()), blobFeeCap: uint256.MustFromBig(tx.BlobGasFeeCap()), @@ -315,6 +316,10 @@ discoverFeed event.Feed // Event feed to send out new tx events on pool discovery (reorg excluded) insertFeed event.Feed // Event feed to send out new tx events on pool inclusion (reorg included)   lock sync.RWMutex // Mutex protecting the pool during reorg handling + + // Celo specific + celoBackend *contracts.CeloBackend // For fee currency balances & exchange rate calculation + feeCurrencyContext common.FeeCurrencyContext }   // New creates a new blob transaction pool to gather, sort and filter inbound @@ -370,6 +375,7 @@ if err != nil { return err } p.head, p.state = head, state + p.recreateCeloProperties()   // Index all transactions on disk and delete anything unprocessable var fails []uint64 @@ -796,6 +802,7 @@ return } p.head = newHead p.state = statedb + p.recreateCeloProperties()   // Run the reorg between the old and new head and figure out which accounts // need to be rechecked and which transactions need to be readded @@ -1081,13 +1088,13 @@ // rules and adheres to some heuristic limits of the local node (price and size). func (p *BlobPool) validateTx(tx *types.Transaction) error { // Ensure the transaction adheres to basic pool filters (type, size, tip) and // consensus rules - baseOpts := &txpool.ValidationOptions{ - Config: p.chain.Config(), - Accept: 1 << types.BlobTxType, - MaxSize: txMaxSize, - MinTip: p.gasTip.ToBig(), + baseOpts := &txpool.CeloValidationOptions{ + Config: p.chain.Config(), + AcceptSet: txpool.NewAcceptSet(types.BlobTxType), + MaxSize: txMaxSize, + MinTip: p.gasTip.ToBig(), } - if err := txpool.ValidateTransaction(tx, p.head, p.signer, baseOpts); err != nil { + if err := txpool.CeloValidateTransaction(tx, p.head, p.signer, baseOpts, p.feeCurrencyContext); err != nil { return err } // Ensure the transaction adheres to the stateful pool filters (nonce, balance) @@ -1107,20 +1114,24 @@ return have, 0 } return have, maxTxsPerAccount - have }, - ExistingExpenditure: func(addr common.Address) *big.Int { + ExistingExpenditure: func(addr common.Address) (*big.Int, *big.Int) { if spent := p.spent[addr]; spent != nil { - return spent.ToBig() + return new(big.Int), spent.ToBig() } - return new(big.Int) + return new(big.Int), new(big.Int) }, - ExistingCost: func(addr common.Address, nonce uint64) *big.Int { + ExistingCost: func(addr common.Address, nonce uint64) (*big.Int, *big.Int) { next := p.state.GetNonce(addr) if uint64(len(p.index[addr])) > nonce-next { - return p.index[addr][int(nonce-next)].costCap.ToBig() + return new(big.Int), p.index[addr][int(nonce-next)].costCap.ToBig() } - return nil + return nil, nil + }, + ExistingBalance: func(addr common.Address, feeCurrency *common.Address) *big.Int { + return contracts.GetFeeBalance(p.celoBackend, addr, feeCurrency) }, } + if err := txpool.ValidateTransactionWithState(tx, p.signer, stateOpts); err != nil { return err }

diff --git op-geth/core/txpool/blobpool/celo_blobpool.go Celo/core/txpool/blobpool/celo_blobpool.go new file mode 100644 index 0000000000000000000000000000000000000000..7b453a3ca44edcc8b4e218ea1c4233f38c3c1ae8 --- /dev/null +++ Celo/core/txpool/blobpool/celo_blobpool.go @@ -0,0 +1,18 @@ +package blobpool + +import ( + "github.com/ethereum/go-ethereum/contracts" + "github.com/ethereum/go-ethereum/log" +) + +func (pool *BlobPool) recreateCeloProperties() { + pool.celoBackend = &contracts.CeloBackend{ + ChainConfig: pool.chain.Config(), + State: pool.state, + } + currencyContext, err := contracts.GetFeeCurrencyContext(pool.celoBackend) + if err != nil { + log.Error("Error trying to get fee currency context in txpool.", "cause", err) + } + pool.feeCurrencyContext = currencyContext +}

diff --git op-geth/core/txpool/celo_validation.go Celo/core/txpool/celo_validation.go new file mode 100644 index 0000000000000000000000000000000000000000..d82b85db744367f495594d90f91dd89c0d9180d2 --- /dev/null +++ Celo/core/txpool/celo_validation.go @@ -0,0 +1,102 @@ +package txpool + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/exchange" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/params" +) + +var ( + + // ErrGasPriceDoesNotExceedBaseFeeFloor is returned if the gas price specified is + // lower than the configured base-fee-floor + ErrGasPriceDoesNotExceedBaseFeeFloor = errors.New("gas-price is less than the base-fee-floor") + ErrMinimumEffectiveGasTipBelowMinTip = errors.New("effective gas tip at base-fee-floor is below threshold") +) + +// AcceptSet is a set of accepted transaction types for a transaction subpool. +type AcceptSet = map[uint8]struct{} + +// CeloValidationOptions define certain differences between transaction validation +// across the different pools without having to duplicate those checks. +// In comparison to the standard ValidationOptions, the Accept field has been +// changed to allow to test for CeloDynamicFeeTx types. +type CeloValidationOptions struct { + Config *params.ChainConfig // Chain configuration to selectively validate based on current fork rules + + AcceptSet AcceptSet // Set of transaction types that should be accepted for the calling pool + MaxSize uint64 // Maximum size of a transaction that the caller can meaningfully handle + MinTip *big.Int // Minimum gas tip needed to allow a transaction into the caller pool + + EffectiveGasCeil uint64 // if non-zero, a gas ceiling to enforce independent of the header's gaslimit value +} + +// NewAcceptSet creates a new AcceptSet with the types provided. +func NewAcceptSet(types ...uint8) AcceptSet { + m := make(AcceptSet, len(types)) + for _, t := range types { + m[t] = struct{}{} + } + return m +} + +// Accepts returns true iff txType is accepted by this CeloValidationOptions. +func (cvo *CeloValidationOptions) Accepts(txType uint8) bool { + _, ok := cvo.AcceptSet[txType] + return ok +} + +// CeloValidateTransaction is a helper method to check whether a transaction is valid +// according to the consensus rules, but does not check state-dependent validation +// (balance, nonce, etc). +// +// This check is public to allow different transaction pools to check the basic +// rules without duplicating code and running the risk of missed updates. +func CeloValidateTransaction(tx *types.Transaction, head *types.Header, + signer types.Signer, opts *CeloValidationOptions, currencyCtx common.FeeCurrencyContext) error { + if err := ValidateTransaction(tx, head, signer, opts, currencyCtx); err != nil { + return err + } + + if !common.IsCurrencyAllowed(currencyCtx.ExchangeRates, tx.FeeCurrency()) { + return exchange.ErrUnregisteredFeeCurrency + } + + if opts.Config.Celo != nil { + // Make sure that the effective gas tip at the base fee floor is at least the + // requested min-tip. + // The min-tip for local transactions is set to 0, we can skip checking here. + if opts.MinTip != nil && opts.MinTip.Cmp(new(big.Int)) > 0 { + // If not, this would never be included, so we can reject early. + minTip, err := exchange.ConvertCeloToCurrency(currencyCtx.ExchangeRates, tx.FeeCurrency(), opts.MinTip) + if err != nil { + return err + } + baseFeeFloor, err := exchange.ConvertCeloToCurrency(currencyCtx.ExchangeRates, tx.FeeCurrency(), new(big.Int).SetUint64(opts.Config.Celo.EIP1559BaseFeeFloor)) + if err != nil { + return err + } + if tx.EffectiveGasTipIntCmp(minTip, baseFeeFloor) < 0 { + return ErrUnderpriced + } + } + + celoGasPrice, err := exchange.ConvertCurrencyToCelo( + currencyCtx.ExchangeRates, + tx.FeeCurrency(), + tx.GasFeeCap(), + ) + if err != nil { + return err + } + + if new(big.Int).SetUint64(opts.Config.Celo.EIP1559BaseFeeFloor).Cmp(celoGasPrice) == 1 { + return ErrGasPriceDoesNotExceedBaseFeeFloor + } + } + return nil +}

diff --git op-geth/core/txpool/legacypool/celo_legacypool.go Celo/core/txpool/legacypool/celo_legacypool.go new file mode 100644 index 0000000000000000000000000000000000000000..a6f4da7a2ba8874ecf70e055188f66bf256db896 --- /dev/null +++ Celo/core/txpool/legacypool/celo_legacypool.go @@ -0,0 +1,43 @@ +package legacypool + +import ( + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/contracts" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/log" + "github.com/holiman/uint256" +) + +// filter Filters transactions from the given list, according to remaining balance (per currency) +// and gasLimit. Returns drops and invalid txs. +func (pool *LegacyPool) filter(list *list, addr common.Address, gasLimit uint64) (types.Transactions, types.Transactions) { + // CELO: drop all transactions that no longer have a registered currency + dropsAllowlist, invalidsAllowlist := list.FilterAllowlisted(pool.feeCurrencyContext.ExchangeRates) + // Check from which currencies we need to get balances + currenciesInList := list.FeeCurrencies() + drops, invalids := list.Filter(pool.getBalances(addr, currenciesInList), gasLimit) + totalDrops := append(dropsAllowlist, drops...) + totalInvalids := append(invalidsAllowlist, invalids...) + return totalDrops, totalInvalids +} + +func (pool *LegacyPool) getBalances(address common.Address, currencies []common.Address) map[common.Address]*uint256.Int { + balances := make(map[common.Address]*uint256.Int, len(currencies)) + for _, curr := range currencies { + balances[curr] = uint256.MustFromBig(contracts.GetFeeBalance(pool.celoBackend, address, &curr)) + } + return balances +} + +func (pool *LegacyPool) recreateCeloProperties() { + pool.celoBackend = &contracts.CeloBackend{ + ChainConfig: pool.chainconfig, + State: pool.currentState, + } + feeCurrencyContext, err := contracts.GetFeeCurrencyContext(pool.celoBackend) + if err != nil { + log.Error("Error trying to get fee currency context in txpool.", "cause", err) + } + + pool.feeCurrencyContext = feeCurrencyContext +}

diff --git op-geth/core/txpool/legacypool/celo_legacypool_test.go Celo/core/txpool/legacypool/celo_legacypool_test.go new file mode 100644 index 0000000000000000000000000000000000000000..88a694a74c90c933c9761360d4aa6e9f185f6e50 --- /dev/null +++ Celo/core/txpool/legacypool/celo_legacypool_test.go @@ -0,0 +1,205 @@ +package legacypool + +import ( + "crypto/ecdsa" + "errors" + "math/big" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/core/state" + "github.com/ethereum/go-ethereum/core/txpool" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/event" + "github.com/ethereum/go-ethereum/params" + "github.com/ethereum/go-ethereum/triedb" +) + +func celoConfig(baseFeeFloor uint64) *params.ChainConfig { + cpy := *params.TestChainConfig + config := &cpy + ct := uint64(0) + config.Cel2Time = &ct + config.Celo = &params.CeloConfig{EIP1559BaseFeeFloor: baseFeeFloor} + return config +} + +var ( + // worth half as much as native celo + feeCurrencyOne = core.DevFeeCurrencyAddr + // worth twice as much as native celo + feeCurrencyTwo = core.DevFeeCurrencyAddr2 + feeCurrencyIntrinsicGas = core.FeeCurrencyIntrinsicGas + defaultBaseFeeFloor = 100 + defaultChainConfig = celoConfig(uint64(defaultBaseFeeFloor)) +) + +func pricedCip64Transaction( + config *params.ChainConfig, + nonce uint64, + gasLimit uint64, + gasFeeCap *big.Int, + gasTipCap *big.Int, + feeCurrency *common.Address, + key *ecdsa.PrivateKey, +) *types.Transaction { + tx, _ := types.SignTx(types.NewTx(&types.CeloDynamicFeeTxV2{ + Nonce: nonce, + To: &common.Address{}, + Value: big.NewInt(100), + Gas: gasLimit, + GasFeeCap: gasFeeCap, + GasTipCap: gasTipCap, + FeeCurrency: feeCurrency, + Data: nil, + }), types.LatestSigner(config), key) + return tx +} + +func newDBWithCeloGenesis(config *params.ChainConfig, fundedAddress common.Address) (state.Database, *types.Block) { + gspec := &core.Genesis{ + Config: config, + Alloc: core.CeloGenesisAccounts(fundedAddress), + } + db := rawdb.NewMemoryDatabase() + triedb := triedb.NewDatabase(db, triedb.HashDefaults) + defer triedb.Close() + block, err := gspec.Commit(db, triedb) + if err != nil { + panic(err) + } + return state.NewDatabase(triedb, nil), block +} + +func setupCeloPoolWithConfig(config *params.ChainConfig) (*LegacyPool, *ecdsa.PrivateKey) { + key, _ := crypto.GenerateKey() + addr := crypto.PubkeyToAddress(key.PublicKey) + + ddb, genBlock := newDBWithCeloGenesis(config, addr) + stateRoot := genBlock.Header().Root + statedb, err := state.New(stateRoot, ddb) + if err != nil { + panic(err) + } + blockchain := newTestBlockChain(config, 10000000, statedb, new(event.Feed)) + pool := New(testTxPoolConfig, blockchain) + + block := blockchain.CurrentBlock() + // inject the state-root from the genesis chain, so + // that the fee-currency allocs are accessible from the state + // and can be used to create the fee-currency context in the txpool + block.Root = stateRoot + if err := pool.Init(testTxPoolConfig.PriceLimit, block, makeAddressReserver()); err != nil { + panic(err) + } + // wait for the pool to initialize + <-pool.initDoneCh + return pool, key +} + +func TestBelowBaseFeeFloorValidityCheck(t *testing.T) { + t.Parallel() + + pool, key := setupCeloPoolWithConfig(defaultChainConfig) + defer pool.Close() + + // gas-price below base-fee-floor should return early + // and thus raise an error in the validation + + // use local transactions here to skip the min-tip conversion + // the PriceLimit config is set to 1, so we need at least a tip of 1 + tx := pricedCip64Transaction(defaultChainConfig, 0, 21000, big.NewInt(99), big.NewInt(0), nil, key) + if err, want := pool.addLocal(tx), txpool.ErrGasPriceDoesNotExceedBaseFeeFloor; !errors.Is(err, want) { + t.Errorf("want %v have %v", want, err) + } + // also test with fee currency conversion + tx = pricedCip64Transaction(defaultChainConfig, 0, 21000+feeCurrencyIntrinsicGas, big.NewInt(198), big.NewInt(0), &feeCurrencyOne, key) + if err, want := pool.addLocal(tx), txpool.ErrGasPriceDoesNotExceedBaseFeeFloor; !errors.Is(err, want) { + t.Errorf("want %v have %v", want, err) + } + tx = pricedCip64Transaction(defaultChainConfig, 0, 21000+feeCurrencyIntrinsicGas, big.NewInt(48), big.NewInt(0), &feeCurrencyTwo, key) + if err, want := pool.addLocal(tx), txpool.ErrGasPriceDoesNotExceedBaseFeeFloor; !errors.Is(err, want) { + t.Errorf("want %v have %v", want, err) + } +} + +func TestAboveBaseFeeFloorValidityCheck(t *testing.T) { + t.Parallel() + + pool, key := setupCeloPoolWithConfig(defaultChainConfig) + defer pool.Close() + + // gas-price just at base-fee-floor should be valid, + // this also adds the required min-tip of 1 + tx := pricedCip64Transaction(defaultChainConfig, 0, 21000, big.NewInt(101), big.NewInt(1), nil, key) + assert.NoError(t, pool.addRemote(tx)) + // also test with fee currency conversion, increase nonce because of previous tx was valid + tx = pricedCip64Transaction(defaultChainConfig, 1, 21000+feeCurrencyIntrinsicGas, big.NewInt(202), big.NewInt(2), &feeCurrencyOne, key) + assert.NoError(t, pool.addRemote(tx)) + tx = pricedCip64Transaction(defaultChainConfig, 2, 21000+feeCurrencyIntrinsicGas, big.NewInt(51), big.NewInt(1), &feeCurrencyTwo, key) + assert.NoError(t, pool.addRemote(tx)) +} + +func TestBelowMinTipValidityCheck(t *testing.T) { + t.Parallel() + + pool, key := setupCeloPoolWithConfig(defaultChainConfig) + defer pool.Close() + + // the min-tip is set to 1 per default + + // Gas-price just at base-fee-floor should be valid, + // the effective gas-price would also pass the min-tip restriction of 1. + // However the explicit gas-tip-cap at 0 should reject the transaction. + tx := pricedCip64Transaction(defaultChainConfig, 0, 21000, big.NewInt(101), big.NewInt(0), nil, key) + if err, want := pool.addRemote(tx), txpool.ErrUnderpriced; !errors.Is(err, want) { + t.Errorf("want %v have %v", want, err) + } + tx = pricedCip64Transaction(defaultChainConfig, 0, 21000+feeCurrencyIntrinsicGas, big.NewInt(202), big.NewInt(0), &feeCurrencyOne, key) + if err, want := pool.addRemote(tx), txpool.ErrUnderpriced; !errors.Is(err, want) { + t.Errorf("want %v have %v", want, err) + } + + // This passes the check that only checks the actual gas-tip-cap value for the min-tip that was + // tested above. + // Now the effective gas-tip should still be below the min-tip, since we consume everything + // for the base fee floor and thus the tx should get rejected. + tx = pricedCip64Transaction(defaultChainConfig, 0, 21000, big.NewInt(100), big.NewInt(1), nil, key) + if err, want := pool.addRemote(tx), txpool.ErrUnderpriced; !errors.Is(err, want) { + t.Errorf("want %v have %v", want, err) + } + tx = pricedCip64Transaction(defaultChainConfig, 0, 21000+feeCurrencyIntrinsicGas, big.NewInt(200), big.NewInt(2), &feeCurrencyOne, key) + if err, want := pool.addRemote(tx), txpool.ErrUnderpriced; !errors.Is(err, want) { + t.Errorf("want %v have %v", want, err) + } +} + +func TestExpectMinTipRoundingFeeCurrency(t *testing.T) { + t.Parallel() + + pool, key := setupCeloPoolWithConfig(defaultChainConfig) + defer pool.Close() + + // the min-tip is set to 1 per default + + // even though the gas-tip-cap as well as the effective gas tip at the base-fee-floor + // is 0, the transaction is still accepted. + // This is because at a min-tip requirement of 1, a more valuable currency than native + // token will get rounded down to a min-tip of 0 during conversion. + tx := pricedCip64Transaction(defaultChainConfig, 0, 21000+feeCurrencyIntrinsicGas, big.NewInt(50), big.NewInt(0), &feeCurrencyTwo, key) + assert.NoError(t, pool.addRemote(tx)) + + // set the required min-tip to 10 + pool.SetGasTip(big.NewInt(10)) + + // but as soon as we increase the min-tip, the check rejects a gas-tip-cap that is too low after conversion + tx = pricedCip64Transaction(defaultChainConfig, 0, 21000+feeCurrencyIntrinsicGas, big.NewInt(100), big.NewInt(4), &feeCurrencyTwo, key) + if err, want := pool.addRemote(tx), txpool.ErrUnderpriced; !errors.Is(err, want) { + t.Errorf("want %v have %v", want, err) + } +}

diff --git op-geth/core/txpool/legacypool/celo_list.go Celo/core/txpool/legacypool/celo_list.go new file mode 100644 index 0000000000000000000000000000000000000000..b1c5594e743fbab0c52ea00e0c6d79aea1b8edc9 --- /dev/null +++ Celo/core/txpool/legacypool/celo_list.go @@ -0,0 +1,134 @@ +package legacypool + +import ( + "math" + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/holiman/uint256" +) + +func (l *list) FilterAllowlisted(rates common.ExchangeRates) (types.Transactions, types.Transactions) { + removed := l.txs.Filter(func(tx *types.Transaction) bool { + return !common.IsCurrencyAllowed(rates, tx.FeeCurrency()) + }) + + if len(removed) == 0 { + return nil, nil + } + + invalid := l.dropInvalidsAfterRemovalAndReheap(removed) + l.subTotalCost(removed) + l.subTotalCost(invalid) + return removed, invalid +} + +func (l *list) dropInvalidsAfterRemovalAndReheap(removed types.Transactions) types.Transactions { + var invalids types.Transactions + // If the list was strict, filter anything above the lowest nonce + // Note that the 'invalid' txs have no intersection with the 'removed' txs + if l.strict { + lowest := uint64(math.MaxUint64) + for _, tx := range removed { + if nonce := tx.Nonce(); lowest > nonce { + lowest = nonce + } + } + invalids = l.txs.filter(func(tx *types.Transaction) bool { return tx.Nonce() > lowest }) + } + l.txs.reheap() + return invalids +} + +func (l *list) FeeCurrencies() []common.Address { + currencySet := make(map[common.Address]interface{}) + currencySet[getCurrencyKey(nil)] = struct{}{} // Always include native token to handle potential value transfers + for _, tx := range l.txs.items { + // native currency (nil) represented as Zero address + currencySet[getCurrencyKey(tx.FeeCurrency())] = struct{}{} + } + currencies := make([]common.Address, 0, len(currencySet)) + for curr := range currencySet { + currencies = append(currencies, curr) + } + return currencies +} + +func getCurrencyKey(feeCurrency *common.Address) common.Address { + if feeCurrency == nil { + return common.ZeroAddress + } + return *feeCurrency +} + +func (l *list) totalCostVar(feeCurrency *common.Address) *uint256.Int { + key := getCurrencyKey(feeCurrency) + if tc, ok := l.totalCost[key]; ok { + return tc + } + newTc := new(uint256.Int) + l.totalCost[key] = newTc + return newTc +} + +func (l *list) TotalCostFor(feeCurrency *common.Address) *uint256.Int { + if tc, ok := l.totalCost[getCurrencyKey(feeCurrency)]; ok { + return new(uint256.Int).Set(tc) + } + return new(uint256.Int) +} + +func (l *list) costCapFor(feeCurrency *common.Address) *uint256.Int { + if tc, ok := l.costCap[getCurrencyKey(feeCurrency)]; ok { + return tc + } + return new(uint256.Int) +} + +func (l *list) updateCostCapFor(feeCurrency *common.Address, possibleCap *uint256.Int) { + currentCap := l.costCapFor(feeCurrency) + if possibleCap.Cmp(currentCap) > 0 { + l.costCap[getCurrencyKey(feeCurrency)] = possibleCap + } +} + +func (l *list) costCapsLowerThan(costLimits map[common.Address]*uint256.Int) bool { + for curr, cap := range l.costCap { + limit, ok := costLimits[curr] + if !ok || limit == nil { + // If there's no limit for the currency we can assume the limit is zero + return cap.IsZero() + } + if cap.Cmp(limit) > 0 { + return false + } + } + return true +} + +func (l *list) setCapsTo(caps map[common.Address]*uint256.Int) { + l.costCap = make(map[common.Address]*uint256.Int) + for curr, cap := range caps { + if cap == nil || cap.IsZero() { + l.costCap[curr] = new(uint256.Int) + } else { + l.costCap[curr] = new(uint256.Int).Set(cap) + } + } +} + +// GetNativeBaseFee returns the base fee for this priceHeap +func (h *priceHeap) GetNativeBaseFee() *big.Int { + if h.ratesAndFees == nil { + return nil + } + return h.ratesAndFees.GetNativeBaseFee() +} + +func (h *priceHeap) GetBaseFeeIn(feeCurrency *common.Address) *big.Int { + if h.ratesAndFees == nil { + return nil + } + return h.ratesAndFees.GetBaseFeeIn(feeCurrency) +}

diff --git op-geth/core/txpool/legacypool/celo_list_test.go Celo/core/txpool/legacypool/celo_list_test.go new file mode 100644 index 0000000000000000000000000000000000000000..86782f41ded861297605af14b37556b510b96c0e --- /dev/null +++ Celo/core/txpool/legacypool/celo_list_test.go @@ -0,0 +1,199 @@ +package legacypool + +import ( + "math/big" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/holiman/uint256" + "github.com/stretchr/testify/assert" +) + +func txC(nonce int, feeCap int, tipCap int, gas int, currency *common.Address) *types.Transaction { + return types.NewTx(&types.CeloDynamicFeeTxV2{ + GasFeeCap: big.NewInt(int64(feeCap)), + GasTipCap: big.NewInt(int64(tipCap)), + FeeCurrency: currency, + Gas: uint64(gas), + Nonce: uint64(nonce), + }) +} + +func TestListFeeCost(t *testing.T) { + curr1 := common.HexToAddress("0002") + curr2 := common.HexToAddress("0004") + curr3 := common.HexToAddress("0006") + rates := common.ExchangeRates{ + curr1: big.NewRat(2, 1), + curr2: big.NewRat(4, 1), + curr3: big.NewRat(6, 1), + } + // Insert the transactions in a random order + list := newList(false) + + list.Add(txC(7, 1, 1, 10000, &curr1), DefaultConfig.PriceBump, nil, rates) + assert.Equal(t, uint64(10000), list.TotalCostFor(&curr1).Uint64()) + + toBeRemoved := txC(8, 2, 1, 15000, &curr2) + list.Add(toBeRemoved, DefaultConfig.PriceBump, nil, rates) + assert.Equal(t, uint64(30000), list.TotalCostFor(&curr2).Uint64()) + assert.Equal(t, uint64(10000), list.TotalCostFor(&curr1).Uint64()) + + list.Add(txC(9, 3, 2, 5000, &curr3), DefaultConfig.PriceBump, nil, rates) + assert.Equal(t, uint64(15000), list.TotalCostFor(&curr3).Uint64()) + assert.Equal(t, uint64(30000), list.TotalCostFor(&curr2).Uint64()) + assert.Equal(t, uint64(10000), list.TotalCostFor(&curr1).Uint64()) + + // Add another tx from curr1, check it adds properly + list.Add(txC(10, 1, 1, 10000, &curr1), DefaultConfig.PriceBump, nil, rates) + assert.Equal(t, uint64(15000), list.TotalCostFor(&curr3).Uint64()) + assert.Equal(t, uint64(30000), list.TotalCostFor(&curr2).Uint64()) + assert.Equal(t, uint64(20000), list.TotalCostFor(&curr1).Uint64()) + + // Remove a tx from curr2, check it subtracts properly + removed, _ := list.Remove(toBeRemoved) + assert.True(t, removed) + + assert.Equal(t, uint64(15000), list.TotalCostFor(&curr3).Uint64()) + assert.Equal(t, uint64(0), list.TotalCostFor(&curr2).Uint64()) + assert.Equal(t, uint64(20000), list.TotalCostFor(&curr1).Uint64()) +} + +func TestFilterAllowlisted(t *testing.T) { + curr1 := common.HexToAddress("0002") + curr2 := common.HexToAddress("0004") + curr3 := common.HexToAddress("0006") + rates := common.ExchangeRates{ + curr1: big.NewRat(2, 1), + curr2: big.NewRat(4, 1), + curr3: big.NewRat(6, 1), + } + + list := newList(false) + list.Add(txC(7, 1, 1, 10000, &curr1), DefaultConfig.PriceBump, nil, rates) + toBeRemoved := txC(8, 2, 1, 15000, &curr2) + list.Add(toBeRemoved, DefaultConfig.PriceBump, nil, rates) + list.Add(txC(9, 1, 1, 10000, &curr1), DefaultConfig.PriceBump, nil, rates) + assert.Equal(t, uint64(30000), list.TotalCostFor(&curr2).Uint64()) + + removed, invalids := list.FilterAllowlisted(common.ExchangeRates{curr1: nil, curr3: nil}) + assert.Len(t, removed, 1) + assert.Len(t, invalids, 0) + assert.Equal(t, removed[0], toBeRemoved) + assert.Equal(t, uint64(0), list.TotalCostFor(&curr2).Uint64()) +} + +func TestFilterAllowlistedStrict(t *testing.T) { + curr1 := common.HexToAddress("0002") + curr2 := common.HexToAddress("0004") + curr3 := common.HexToAddress("0006") + rates := common.ExchangeRates{ + curr1: big.NewRat(2, 1), + curr2: big.NewRat(4, 1), + curr3: big.NewRat(6, 1), + } + + list := newList(true) + list.Add(txC(7, 1, 1, 10000, &curr1), DefaultConfig.PriceBump, nil, rates) + toBeRemoved := txC(8, 2, 1, 15000, &curr2) + list.Add(toBeRemoved, DefaultConfig.PriceBump, nil, rates) + toBeInvalid := txC(9, 1, 1, 10000, &curr3) + list.Add(toBeInvalid, DefaultConfig.PriceBump, nil, rates) + + removed, invalids := list.FilterAllowlisted(common.ExchangeRates{curr1: nil, curr3: nil}) + assert.Len(t, removed, 1) + assert.Len(t, invalids, 1) + assert.Equal(t, removed[0], toBeRemoved) + assert.Equal(t, invalids[0], toBeInvalid) + assert.Equal(t, uint64(0), list.TotalCostFor(&curr2).Uint64()) + assert.Equal(t, uint64(0), list.TotalCostFor(&curr3).Uint64()) + assert.Equal(t, uint64(10000), list.TotalCostFor(&curr1).Uint64()) +} + +func TestFilterBalance(t *testing.T) { + curr1 := common.HexToAddress("0002") + curr2 := common.HexToAddress("0004") + curr3 := common.HexToAddress("0006") + rates := common.ExchangeRates{ + curr1: big.NewRat(2, 1), + curr2: big.NewRat(4, 1), + curr3: big.NewRat(6, 1), + } + + list := newList(false) + // each tx costs 10000 in each currency + list.Add(txC(7, 1, 1, 10000, &curr1), DefaultConfig.PriceBump, nil, rates) + toBeRemoved := txC(8, 1, 1, 10000, &curr2) + list.Add(toBeRemoved, DefaultConfig.PriceBump, nil, rates) + list.Add(txC(9, 1, 1, 10000, &curr3), DefaultConfig.PriceBump, nil, rates) + + removed, invalids := list.Filter(map[common.Address]*uint256.Int{ + curr1: uint256.NewInt(10000), + curr2: uint256.NewInt(9999), + curr3: uint256.NewInt(10000), + }, 15000) + assert.Len(t, removed, 1) + assert.Len(t, invalids, 0) + assert.Equal(t, removed[0], toBeRemoved) + assert.Equal(t, uint64(0), list.TotalCostFor(&curr2).Uint64()) +} + +func TestFilterBalanceStrict(t *testing.T) { + curr1 := common.HexToAddress("0002") + curr2 := common.HexToAddress("0004") + curr3 := common.HexToAddress("0006") + rates := common.ExchangeRates{ + curr1: big.NewRat(2, 1), + curr2: big.NewRat(4, 1), + curr3: big.NewRat(6, 1), + } + + list := newList(true) + // each tx costs 10000 in each currency + list.Add(txC(7, 1, 1, 10000, &curr1), DefaultConfig.PriceBump, nil, rates) + toBeRemoved := txC(8, 1, 1, 10000, &curr2) + list.Add(toBeRemoved, DefaultConfig.PriceBump, nil, rates) + toBeInvalid := txC(9, 1, 1, 10000, &curr3) + list.Add(toBeInvalid, DefaultConfig.PriceBump, nil, rates) + + removed, invalids := list.Filter(map[common.Address]*uint256.Int{ + curr1: uint256.NewInt(10001), + curr2: uint256.NewInt(9999), + curr3: uint256.NewInt(10001), + }, 15000) + assert.Len(t, removed, 1) + assert.Len(t, invalids, 1) + assert.Equal(t, removed[0], toBeRemoved) + assert.Equal(t, invalids[0], toBeInvalid) + assert.Equal(t, uint64(0), list.TotalCostFor(&curr2).Uint64()) + assert.Equal(t, uint64(0), list.TotalCostFor(&curr3).Uint64()) +} + +func TestFilterBalanceGasLimit(t *testing.T) { + curr1 := common.HexToAddress("0002") + curr2 := common.HexToAddress("0004") + curr3 := common.HexToAddress("0006") + rates := common.ExchangeRates{ + curr1: big.NewRat(2, 1), + curr2: big.NewRat(4, 1), + curr3: big.NewRat(6, 1), + } + + list := newList(false) + // each tx costs 10000 in each currency + list.Add(txC(7, 1, 1, 10000, &curr1), DefaultConfig.PriceBump, nil, rates) + toBeRemoved := txC(8, 1, 1, 10001, &curr2) + list.Add(toBeRemoved, DefaultConfig.PriceBump, nil, rates) + list.Add(txC(9, 1, 1, 10000, &curr3), DefaultConfig.PriceBump, nil, rates) + + removed, invalids := list.Filter(map[common.Address]*uint256.Int{ + curr1: uint256.NewInt(20000), + curr2: uint256.NewInt(20000), + curr3: uint256.NewInt(20000), + }, 10000) + assert.Len(t, removed, 1) + assert.Len(t, invalids, 0) + assert.Equal(t, removed[0], toBeRemoved) + assert.Equal(t, uint64(0), list.TotalCostFor(&curr2).Uint64()) +}

diff --git op-geth/core/txpool/legacypool/legacypool.go Celo/core/txpool/legacypool/legacypool.go index 2579104e5a4e1aae06f9f3f9da0ddd50600df506..c73c95b052817d10519bcee9902a917d7ff21134 100644 --- op-geth/core/txpool/legacypool/legacypool.go +++ Celo/core/txpool/legacypool/legacypool.go @@ -19,6 +19,7 @@ package legacypool   import ( "errors" + "fmt" "math" "math/big" "sort" @@ -27,8 +28,10 @@ "sync/atomic" "time"   "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/exchange" "github.com/ethereum/go-ethereum/common/prque" "github.com/ethereum/go-ethereum/consensus/misc/eip1559" + "github.com/ethereum/go-ethereum/contracts" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/txpool" @@ -102,6 +105,16 @@ localGauge = metrics.NewRegisteredGauge("txpool/local", nil) slotsGauge = metrics.NewRegisteredGauge("txpool/slots", nil)   reheapTimer = metrics.NewRegisteredTimer("txpool/reheap", nil) + + // Celo specific metrics + validTxMeterByTxType = map[byte]metrics.Meter{ + types.LegacyTxType: metrics.NewRegisteredMeter("txpool/txtype/legacy", nil), + types.AccessListTxType: metrics.NewRegisteredMeter("txpool/txtype/accesslist", nil), + types.DynamicFeeTxType: metrics.NewRegisteredMeter("txpool/txtype/dynamicfee", nil), + types.BlobTxType: metrics.NewRegisteredMeter("txpool/txtype/blob", nil), + types.CeloDynamicFeeTxV2Type: metrics.NewRegisteredMeter("txpool/txtype/cip64", nil), + } + validTxMeterByFeeCurrency = map[common.Address]metrics.Meter{} )   // BlockChain defines the minimal set of methods needed to back a tx pool with @@ -240,6 +253,10 @@ changesSinceReorg int // A counter for how many drops we've performed in-between reorg.   l1CostFn txpool.L1CostFunc // To apply L1 costs as rollup, optional field, may be nil. + + // Celo specific + celoBackend *contracts.CeloBackend // For fee currency balances & exchange rate calculation + feeCurrencyContext common.FeeCurrencyContext // context for fee currencies }   type txpoolResetRequest struct { @@ -286,7 +303,7 @@ // Filter returns whether the given transaction can be consumed by the legacy // pool, specifically, whether it is a Legacy, AccessList or Dynamic transaction. func (pool *LegacyPool) Filter(tx *types.Transaction) bool { switch tx.Type() { - case types.LegacyTxType, types.AccessListTxType, types.DynamicFeeTxType: + case types.LegacyTxType, types.AccessListTxType, types.DynamicFeeTxType, types.CeloDynamicFeeTxV2Type: return true default: return false @@ -317,6 +334,7 @@ } pool.currentHead.Store(head) pool.currentState = statedb pool.pendingNonces = newNoncer(statedb) + pool.recreateCeloProperties()   // Start the reorg loop early, so it can handle requests generated during // journal loading. @@ -546,15 +564,11 @@ defer pool.mu.Unlock()   // Convert the new uint256.Int types to the old big.Int ones used by the legacy pool var ( - minTipBig *big.Int - baseFeeBig *big.Int + minTipBig *big.Int ) if filter.MinTip != nil { minTipBig = filter.MinTip.ToBig() } - if filter.BaseFee != nil { - baseFeeBig = filter.BaseFee.ToBig() - } pending := make(map[common.Address][]*txpool.LazyTransaction, len(pool.pending)) for addr, list := range pool.pending { txs := list.Flatten() @@ -562,7 +576,8 @@ // If the miner requests tip enforcement, cap the lists now if minTipBig != nil && !pool.locals.contains(addr) { for i, tx := range txs { - if tx.EffectiveGasTipIntCmp(minTipBig, baseFeeBig) < 0 { + minTipInFeeCurrency, err := exchange.ConvertCeloToCurrency(pool.feeCurrencyContext.ExchangeRates, tx.FeeCurrency(), minTipBig) + if err != nil || tx.EffectiveGasTipIntCmp(minTipInFeeCurrency, pool.priced.urgent.GetBaseFeeIn(tx.FeeCurrency())) < 0 { txs = txs[:i] break } @@ -593,6 +608,9 @@ GasTipCap: uint256.MustFromBig(txs[i].GasTipCap()), Gas: txs[i].Gas(), BlobGas: txs[i].BlobGas(), DABytes: daBytes, + + // Celo specific + FeeCurrency: txs[i].FeeCurrency(), } } pending[addr] = lazies @@ -647,12 +665,13 @@ // rules, but does not check state-dependent validation such as sufficient balance. // This check is meant as an early check which only needs to be performed once, // and does not require the pool mutex to be held. func (pool *LegacyPool) validateTxBasics(tx *types.Transaction, local bool) error { - opts := &txpool.ValidationOptions{ + opts := &txpool.CeloValidationOptions{ Config: pool.chainconfig, - Accept: 0 | - 1<<types.LegacyTxType | - 1<<types.AccessListTxType | - 1<<types.DynamicFeeTxType, + AcceptSet: txpool.NewAcceptSet( + types.LegacyTxType, + types.AccessListTxType, + types.DynamicFeeTxType, + types.CeloDynamicFeeTxV2Type), MaxSize: txMaxSize, MinTip: pool.gasTip.Load().ToBig(), EffectiveGasCeil: pool.config.EffectiveGasCeil, @@ -660,7 +679,7 @@ } if local { opts.MinTip = new(big.Int) } - if err := txpool.ValidateTransaction(tx, pool.currentHead.Load(), pool.signer, opts); err != nil { + if err := txpool.CeloValidateTransaction(tx, pool.currentHead.Load(), pool.signer, opts, pool.feeCurrencyContext); err != nil { return err } return nil @@ -683,31 +702,68 @@ have += list.Len() } return have, math.MaxInt }, - ExistingExpenditure: func(addr common.Address) *big.Int { + ExistingExpenditure: func(addr common.Address) (*big.Int, *big.Int) { if list := pool.pending[addr]; list != nil { - return list.totalcost.ToBig() + if tx.FeeCurrency() != nil { + return list.TotalCostFor(tx.FeeCurrency()).ToBig(), list.TotalCostFor(nil).ToBig() + } else { + return common.Big0, list.TotalCostFor(nil).ToBig() + } } - return new(big.Int) + return new(big.Int), new(big.Int) }, - ExistingCost: func(addr common.Address, nonce uint64) *big.Int { + ExistingCost: func(addr common.Address, nonce uint64) (*big.Int, *big.Int) { if list := pool.pending[addr]; list != nil { + feeCurrency := tx.FeeCurrency() if tx := list.txs.Get(nonce); tx != nil { - cost := tx.Cost() + feeCurrencyCost, nativeCost := tx.Cost() if pool.l1CostFn != nil { if l1Cost := pool.l1CostFn(tx.RollupCostData()); l1Cost != nil { // add rollup cost - cost = cost.Add(cost, l1Cost) + nativeCost = nativeCost.Add(nativeCost, l1Cost) } } - return cost + if !common.AreSameAddress(tx.FeeCurrency(), feeCurrency) { + // We are only interested in costs in the same currency + feeCurrencyCost = new(big.Int) + } + return feeCurrencyCost, nativeCost } } - return nil + return nil, nil }, L1CostFn: pool.l1CostFn, + ExistingBalance: func(addr common.Address, feeCurrency *common.Address) *big.Int { + return contracts.GetFeeBalance(pool.celoBackend, addr, feeCurrency) + }, } + if err := txpool.ValidateTransactionWithState(tx, pool.signer, opts); err != nil { return err } + if tx.FeeCurrency() != nil { + from, err := pool.signer.Sender(tx) // already validated (and cached), but cleaner to check + if err != nil { + log.Error("Transaction sender recovery failed", "err", err) + return err + } + //NOTE: we only test the `debitFees` call here. + // If the `creditFees` reverts (or runs out of gas), + // the transaction reverts within the STF. This results in the user's + // transaction being computed free of charge. In order to mitigate this, + // the txpool worker keeps track of fee-currencies where this happens and + // limits the impact this can have on resources by adding them to a blocklist + // for a limited time. + // Note however that the fee-currency blocklist is kept downstream, + // so the TryDebitFees call below will be executed even for blocklisted fee-currencies. + err = contracts.TryDebitFees(tx, from, pool.celoBackend, pool.feeCurrencyContext) + if errors.Is(err, contracts.ErrFeeCurrencyEVMCall) { + log.Error("executing debit fees in legacypool validation failed", "err", err) + // make the error message less specific / verbose, + // this will get returned by the `eth_sendRawTransaction` call + err = fmt.Errorf("fee-currency internal error") + } + return err + } return nil }   @@ -826,7 +882,7 @@ // Try to replace an existing transaction in the pending pool if list := pool.pending[from]; list != nil && list.Contains(tx.Nonce()) { // Nonce already pending, check if required price bump is met - inserted, old := list.Add(tx, pool.config.PriceBump, pool.l1CostFn) + inserted, old := list.Add(tx, pool.config.PriceBump, pool.l1CostFn, pool.feeCurrencyContext.ExchangeRates) if !inserted { pendingDiscardMeter.Mark(1) return false, txpool.ErrReplaceUnderpriced @@ -900,7 +956,7 @@ from, _ := types.Sender(pool.signer, tx) // already validated if pool.queue[from] == nil { pool.queue[from] = newList(false) } - inserted, old := pool.queue[from].Add(tx, pool.config.PriceBump, pool.l1CostFn) + inserted, old := pool.queue[from].Add(tx, pool.config.PriceBump, pool.l1CostFn, pool.feeCurrencyContext.ExchangeRates) if !inserted { // An older transaction was better, discard this queuedDiscardMeter.Mark(1) @@ -954,7 +1010,7 @@ pool.pending[addr] = newList(true) } list := pool.pending[addr]   - inserted, old := list.Add(tx, pool.config.PriceBump, pool.l1CostFn) + inserted, old := list.Add(tx, pool.config.PriceBump, pool.l1CostFn, pool.feeCurrencyContext.ExchangeRates) if !inserted { // An older transaction was better, discard this pool.all.Remove(hash) @@ -1087,6 +1143,19 @@ replaced, err := pool.add(tx, local) errs[i] = err if err == nil && !replaced { dirty.addTx(tx) + if tx.FeeCurrency() != nil { + feeCurrencyMeter, ok := validTxMeterByFeeCurrency[*tx.FeeCurrency()] + if !ok { + feeCurrencyMeter = metrics.NewRegisteredMeter( + "txpool/feecurrency/"+tx.FeeCurrency().Hex(), + nil) + validTxMeterByFeeCurrency[*tx.FeeCurrency()] = feeCurrencyMeter + } + feeCurrencyMeter.Mark(1) + } + if txTypeMeter, ok := validTxMeterByTxType[tx.Type()]; ok { + txTypeMeter.Mark(1) + } } } validTxMeter.Mark(int64(len(dirty.accounts))) @@ -1350,7 +1419,7 @@ pool.demoteUnexecutables() if reset.newHead != nil { if pool.chainconfig.IsLondon(new(big.Int).Add(reset.newHead.Number, big.NewInt(1))) { pendingBaseFee := eip1559.CalcBaseFee(pool.chainconfig, reset.newHead, reset.newHead.Time+1) - pool.priced.SetBaseFee(pendingBaseFee) + pool.priced.SetBaseFeeAndRates(pendingBaseFee, pool.feeCurrencyContext.ExchangeRates) } else { pool.priced.Reheap() } @@ -1480,6 +1549,7 @@ } pool.currentHead.Store(newHead) pool.currentState = statedb pool.pendingNonces = newNoncer(statedb) + pool.recreateCeloProperties()   if costFn := types.NewL1CostFunc(pool.chainconfig, statedb); costFn != nil { pool.l1CostFn = func(rollupCostData types.RollupCostData) *big.Int { @@ -1493,24 +1563,6 @@ core.SenderCacher.Recover(pool.signer, reinject) pool.addTxsLocked(reinject, false) }   -// reduceBalanceByL1Cost returns the given balance, reduced by the L1Cost of the first transaction in list if applicable -// Other txs will get filtered out necessary. -func (pool *LegacyPool) reduceBalanceByL1Cost(list *list, balance *uint256.Int) *uint256.Int { - if !list.Empty() && pool.l1CostFn != nil { - el := list.txs.FirstElement() - if l1Cost := pool.l1CostFn(el.RollupCostData()); l1Cost != nil { - l1Cost256 := uint256.MustFromBig(l1Cost) - if l1Cost256.Cmp(balance) >= 0 { - // Avoid underflow - balance = uint256.NewInt(0) - } else { - balance = new(uint256.Int).Sub(balance, l1Cost256) - } - } - } - return balance -} - // promoteExecutables moves transactions that have become processable from the // future queue to the set of pending transactions. During this process, all // invalidated transactions (low nonce, low balance) are deleted. @@ -1532,10 +1584,9 @@ hash := tx.Hash() pool.all.Remove(hash) } log.Trace("Removed old queued transactions", "count", len(forwards)) - balance := pool.currentState.GetBalance(addr) - balance = pool.reduceBalanceByL1Cost(list, balance) + // Drop all transactions that are too costly (low balance or out of gas) - drops, _ := list.Filter(balance, gasLimit) + drops, _ := pool.filter(list, addr, gasLimit) for _, tx := range drops { hash := tx.Hash() pool.all.Remove(hash) @@ -1735,10 +1786,9 @@ hash := tx.Hash() pool.all.Remove(hash) log.Trace("Removed old pending transaction", "hash", hash) } - balance := pool.currentState.GetBalance(addr) - balance = pool.reduceBalanceByL1Cost(list, balance) + // Drop all transactions that are too costly (low balance or out of gas), and queue any invalids back for later - drops, invalids := list.Filter(balance, gasLimit) + drops, invalids := pool.filter(list, addr, gasLimit) for _, tx := range drops { hash := tx.Hash() log.Trace("Removed unpayable pending transaction", "hash", hash)

diff --git op-geth/core/txpool/legacypool/legacypool_test.go Celo/core/txpool/legacypool/legacypool_test.go index 2aecb3f2e7ddf3e80f4e898e00f8e67d19c9453d..10112b868e920d336eae817d83db753dd86edf8a 100644 --- op-geth/core/txpool/legacypool/legacypool_test.go +++ Celo/core/txpool/legacypool/legacypool_test.go @@ -199,6 +199,9 @@ } if nonce := pool.pendingNonces.get(addr); nonce != last+1 { return fmt.Errorf("pending nonce mismatch: have %v, want %v", nonce, last+1) } + if txs.TotalCostFor(nil).Cmp(new(uint256.Int)) < 0 { + return fmt.Errorf("totalcost went negative: %v", txs.TotalCostFor(nil)) + } } return nil } @@ -2105,7 +2108,7 @@ }   add(false) for baseFee = 0; baseFee <= 1000; baseFee += 100 { - pool.priced.SetBaseFee(big.NewInt(int64(baseFee))) + pool.priced.SetBaseFeeAndRates(big.NewInt(int64(baseFee)), nil) add(true) check(highCap, "fee cap") add(false) @@ -2261,6 +2264,50 @@ t.Fatalf("queued replacement event firing failed: %v", err) } if err := validatePoolInternals(pool); err != nil { t.Fatalf("pool internal state corrupted: %v", err) + } +} + +// Tests that the pool accepts replacement transactions if the account only owns Celo. +func TestCeloReplacement(t *testing.T) { + t.Parallel() + + // Create the pool to test the pricing enforcement with + statedb, _ := state.New(types.EmptyRootHash, state.NewDatabaseForTesting()) + blockchain := newTestBlockChain(params.TestChainConfig, 1000000, statedb, new(event.Feed)) + + pool := New(testTxPoolConfig, blockchain) + pool.Init(testTxPoolConfig.PriceLimit, blockchain.CurrentBlock(), makeAddressReserver()) + defer pool.Close() + + // Keep track of transaction events to ensure all executables get announced + events := make(chan core.NewTxsEvent, 32) + sub := pool.txFeed.Subscribe(events) + defer sub.Unsubscribe() + + // Create a test account to add transactions with + key, _ := crypto.GenerateKey() + balance := big.NewInt(6000000) + testAddBalance(pool, crypto.PubkeyToAddress(key.PublicKey), balance) + + // Add pending transactions, ensuring the minimum price bump is enforced for replacement (for ultra low prices too) + price := int64(100) + priceBumped := (price * (100 + int64(testTxPoolConfig.PriceBump))) / 100 + + if err := pool.addRemoteSync(pricedTransaction(0, 50000, big.NewInt(price), key)); err != nil { + t.Fatalf("failed to add original cheap pending transaction: %v", err) + } + if err := pool.addRemoteSync(pricedTransaction(0, 50000, big.NewInt(priceBumped-1), key)); err != txpool.ErrReplaceUnderpriced { + t.Fatalf("original cheap queued transaction replacement error mismatch: have %v, want %v", err, txpool.ErrReplaceUnderpriced) + } + if err := pool.addRemoteSync(pricedTransaction(0, 50000, big.NewInt(priceBumped), key)); err != nil { + t.Fatalf("failed to replace original transaction: %v", err) + } + if err := pool.addRemoteSync(pricedTransaction(0, 50000, big.NewInt(price*2), key)); !errors.Is(err, core.ErrInsufficientFunds) { + txCost := big.NewInt(price*2*50000 + 100) // 100 is the amount default of the pricedTransaction function + t.Fatalf("second queue replacement error mismatch: have %v, want %v", err, fmt.Errorf("%w: balance %v, tx cost %v, overshot %v", core.ErrInsufficientFunds, balance, txCost, new(big.Int).Sub(txCost, balance))) + } + if err := validateEvents(events, 2); err != nil { + t.Fatalf("replacement event firing failed: %v", err) } }

diff --git op-geth/core/txpool/legacypool/list.go Celo/core/txpool/legacypool/list.go index 24b18d2273252af4115825c94aaf6f9d8904dd1f..f8d0d399716fc5f7a2d23623d23ff9afcd2901f4 100644 --- op-geth/core/txpool/legacypool/list.go +++ Celo/core/txpool/legacypool/list.go @@ -18,7 +18,6 @@ package legacypool   import ( "container/heap" - "math" "math/big" "slices" "sort" @@ -27,6 +26,7 @@ "sync/atomic" "time"   "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/exchange" "github.com/ethereum/go-ethereum/core/txpool" "github.com/ethereum/go-ethereum/core/types" "github.com/holiman/uint256" @@ -283,9 +283,9 @@ type list struct { strict bool // Whether nonces are strictly continuous or not txs *sortedMap // Heap indexed sorted hash map of the transactions   - costcap *uint256.Int // Price of the highest costing transaction (reset only if exceeds balance) - gascap uint64 // Gas limit of the highest spending transaction (reset only if exceeds block limit) - totalcost *uint256.Int // Total cost of all transactions in the list + costCap map[common.Address]*uint256.Int // Price of the highest costing transaction per currency (reset only if exceeds balance) + gascap uint64 // Gas limit of the highest spending transaction (reset only if exceeds block limit) + totalCost map[common.Address]*uint256.Int // Total cost of all transactions in the list (by currency) }   // newList creates a new transaction list for maintaining nonce-indexable fast, @@ -294,8 +294,8 @@ func newList(strict bool) *list { return &list{ strict: strict, txs: newSortedMap(), - costcap: new(uint256.Int), - totalcost: new(uint256.Int), + costCap: make(map[common.Address]*uint256.Int), + totalCost: make(map[common.Address]*uint256.Int), } }   @@ -310,11 +310,12 @@ // transaction was accepted, and if yes, any previous transaction it replaced. // // If the new transaction is accepted into the list, the lists' cost and gas // thresholds are also potentially updated. -func (l *list) Add(tx *types.Transaction, priceBump uint64, l1CostFn txpool.L1CostFunc) (bool, *types.Transaction) { +func (l *list) Add(tx *types.Transaction, priceBump uint64, _ txpool.L1CostFunc, rates common.ExchangeRates) (bool, *types.Transaction) { // If there's an older better transaction, abort old := l.txs.Get(tx.Nonce()) if old != nil { - if old.GasFeeCapCmp(tx) >= 0 || old.GasTipCapCmp(tx) >= 0 { + // Short circuit when it's clear that the new tx is worse + if common.AreSameAddress(old.FeeCurrency(), tx.FeeCurrency()) && (old.GasFeeCapCmp(tx) >= 0 || old.GasTipCapCmp(tx) >= 0) { return false, nil } // thresholdFeeCap = oldFC * (100 + priceBump) / 100 @@ -327,31 +328,39 @@ b := big.NewInt(100) thresholdFeeCap := aFeeCap.Div(aFeeCap, b) thresholdTip := aTip.Div(aTip, b)   + var thresholdFeeCapInCurrency = thresholdFeeCap + var thresholdTipInCurrency = thresholdTip + if tx.FeeCurrency() != old.FeeCurrency() { + thresholdFeeCapInCurrency = exchange.ConvertCurrency(rates, thresholdFeeCap, old.FeeCurrency(), tx.FeeCurrency()) + thresholdTipInCurrency = exchange.ConvertCurrency(rates, thresholdTip, old.FeeCurrency(), tx.FeeCurrency()) + } // We have to ensure that both the new fee cap and tip are higher than the // old ones as well as checking the percentage threshold to ensure that // this is accurate for low (Wei-level) gas price replacements. - if tx.GasFeeCapIntCmp(thresholdFeeCap) < 0 || tx.GasTipCapIntCmp(thresholdTip) < 0 { + if tx.GasFeeCapIntCmp(thresholdFeeCapInCurrency) < 0 || tx.GasTipCapIntCmp(thresholdTipInCurrency) < 0 { return false, nil } // Old is being replaced, subtract old cost l.subTotalCost([]*types.Transaction{old}) } - // Add new tx cost to totalcost - cost, overflow := uint256.FromBig(tx.Cost()) + // Add new tx cost to total cost + feeCurrencyTc := l.totalCostVar(tx.FeeCurrency()) + nativeTc := l.totalCostVar(&common.ZeroAddress) + feeCurrencyCostBig, nativeCostBig := tx.Cost() + feeCurrencyCost, overflow := uint256.FromBig(feeCurrencyCostBig) if overflow { return false, nil } - l.totalcost.Add(l.totalcost, cost) - if l1CostFn != nil { - if l1Cost := l1CostFn(tx.RollupCostData()); l1Cost != nil { // add rollup cost - l.totalcost.Add(l.totalcost, cost) - } + nativeCost, overflow := uint256.FromBig(nativeCostBig) + if overflow { + return false, nil } + feeCurrencyTc.Add(feeCurrencyTc, feeCurrencyCost) + nativeTc.Add(nativeTc, nativeCost) // Otherwise overwrite the old transaction with the current one l.txs.Put(tx) - if l.costcap.Cmp(cost) < 0 { - l.costcap = cost - } + l.updateCostCapFor(tx.FeeCurrency(), feeCurrencyCost) + l.updateCostCapFor(&common.ZeroAddress, nativeCost) if gas := tx.Gas(); l.gascap < gas { l.gascap = gas } @@ -376,33 +385,25 @@ // This method uses the cached costcap and gascap to quickly decide if there's even // a point in calculating all the costs or if the balance covers all. If the threshold // is lower than the costgas cap, the caps will be reset to a new high after removing // the newly invalidated transactions. -func (l *list) Filter(costLimit *uint256.Int, gasLimit uint64) (types.Transactions, types.Transactions) { +func (l *list) Filter(costLimits map[common.Address]*uint256.Int, gasLimit uint64) (types.Transactions, types.Transactions) { // If all transactions are below the threshold, short circuit - if l.costcap.Cmp(costLimit) <= 0 && l.gascap <= gasLimit { + if l.costCapsLowerThan(costLimits) && l.gascap <= gasLimit { return nil, nil } - l.costcap = new(uint256.Int).Set(costLimit) // Lower the caps to the thresholds + l.setCapsTo(costLimits) // Lower the caps to the thresholds l.gascap = gasLimit   // Filter out all the transactions above the account's funds removed := l.txs.Filter(func(tx *types.Transaction) bool { - return tx.Gas() > gasLimit || tx.Cost().Cmp(costLimit.ToBig()) > 0 + feeCurrencyCost, nativeCost := tx.Cost() + return tx.Gas() > gasLimit || feeCurrencyCost.Cmp(l.costCapFor(tx.FeeCurrency()).ToBig()) > 0 || nativeCost.Cmp(l.costCapFor(&common.ZeroAddress).ToBig()) > 0 })   if len(removed) == 0 { return nil, nil } - var invalids types.Transactions - // If the list was strict, filter anything above the lowest nonce - if l.strict { - lowest := uint64(math.MaxUint64) - for _, tx := range removed { - if nonce := tx.Nonce(); lowest > nonce { - lowest = nonce - } - } - invalids = l.txs.filter(func(tx *types.Transaction) bool { return tx.Nonce() > lowest }) - } + + invalids := l.dropInvalidsAfterRemovalAndReheap(removed) // Reset total cost l.subTotalCost(removed) l.subTotalCost(invalids) @@ -477,9 +478,16 @@ // subTotalCost subtracts the cost of the given transactions from the // total cost of all transactions. func (l *list) subTotalCost(txs []*types.Transaction) { for _, tx := range txs { - _, underflow := l.totalcost.SubOverflow(l.totalcost, uint256.MustFromBig(tx.Cost())) + feeCurrencyCost, nativeCost := tx.Cost() + feeCurrencyTc := l.totalCostVar(tx.FeeCurrency()) + nativeTc := l.totalCostVar(&common.ZeroAddress) + _, underflow := feeCurrencyTc.SubOverflow(feeCurrencyTc, uint256.MustFromBig(feeCurrencyCost)) if underflow { - panic("totalcost underflow") + panic("totalcost underflow (feecurrency)") + } + _, underflow = nativeTc.SubOverflow(nativeTc, uint256.MustFromBig(nativeCost)) + if underflow { + panic("totalcost underflow (native)") } } } @@ -489,8 +497,11 @@ // price-sorted transactions to discard when the pool fills up. If baseFee is set // then the heap is sorted based on the effective tip based on the given base fee. // If baseFee is nil then the sorting is based on gasFeeCap. type priceHeap struct { - baseFee *big.Int // heap should always be re-sorted after baseFee is changed - list []*types.Transaction + list []*types.Transaction + + // Celo specific + ratesAndFees *exchange.RatesAndFees // current exchange rates and basefees + // heap should always be re-sorted after ratesAndFees is changed }   func (h *priceHeap) Len() int { return len(h.list) } @@ -508,18 +519,7 @@ } }   func (h *priceHeap) cmp(a, b *types.Transaction) int { - if h.baseFee != nil { - // Compare effective tips if baseFee is specified - if c := a.EffectiveGasTipCmp(b, h.baseFee); c != 0 { - return c - } - } - // Compare fee caps if baseFee is not specified or effective tips are equal - if c := a.GasFeeCapCmp(b); c != 0 { - return c - } - // Compare tips if effective tips and fee caps are equal - return a.GasTipCapCmp(b) + return types.CompareWithRates(a, b, h.ratesAndFees) }   func (h *priceHeap) Push(x interface{}) { @@ -693,9 +693,10 @@ heap.Init(&l.floating) reheapTimer.Update(time.Since(start)) }   -// SetBaseFee updates the base fee and triggers a re-heap. Note that Removed is not +// SetBaseFeeAndRates updates the base fee and triggers a re-heap. Note that Removed is not // necessary to call right before SetBaseFee when processing a new block. -func (l *pricedList) SetBaseFee(baseFee *big.Int) { - l.urgent.baseFee = baseFee +func (l *pricedList) SetBaseFeeAndRates(baseFee *big.Int, rates common.ExchangeRates) { + l.urgent.ratesAndFees = exchange.NewRatesAndFees(rates, baseFee) + l.floating.ratesAndFees = exchange.NewRatesAndFees(rates, nil) l.Reheap() }

diff --git op-geth/core/txpool/legacypool/list_test.go Celo/core/txpool/legacypool/list_test.go index 9f341a7f2026a9ef79944f542fbde08d558c21e2..55537e5965f1b33e905d4c6e933e8d500342ab31 100644 --- op-geth/core/txpool/legacypool/list_test.go +++ Celo/core/txpool/legacypool/list_test.go @@ -24,7 +24,6 @@ "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" - "github.com/holiman/uint256" )   // Tests that transactions can be added to strict lists and list contents and @@ -40,7 +39,7 @@ } // Insert the transactions in a random order list := newList(true) for _, v := range rand.Perm(len(txs)) { - list.Add(txs[v], DefaultConfig.PriceBump, nil) + list.Add(txs[v], DefaultConfig.PriceBump, nil, nil) } // Verify internal state if len(list.txs.items) != len(txs) { @@ -63,8 +62,9 @@ value := big.NewInt(100) gasprice, _ := new(big.Int).SetString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 0) gaslimit := uint64(i) tx, _ := types.SignTx(types.NewTransaction(uint64(i), common.Address{}, value, gaslimit, gasprice, nil), types.HomesteadSigner{}, key) - t.Logf("cost: %x bitlen: %d\n", tx.Cost(), tx.Cost().BitLen()) - list.Add(tx, DefaultConfig.PriceBump, nil) + costFeeCurrency, costNative := tx.Cost() + t.Logf("cost: %x %x\n", costFeeCurrency, costNative) + list.Add(tx, DefaultConfig.PriceBump, nil, nil) } }   @@ -77,13 +77,11 @@ for i := 0; i < len(txs); i++ { txs[i] = transaction(uint64(i), 0, key) } // Insert the transactions in a random order - priceLimit := uint256.NewInt(DefaultConfig.PriceLimit) b.ResetTimer() for i := 0; i < b.N; i++ { list := newList(true) for _, v := range rand.Perm(len(txs)) { - list.Add(txs[v], DefaultConfig.PriceBump, nil) - list.Filter(priceLimit, DefaultConfig.PriceBump) + list.Add(txs[v], DefaultConfig.PriceBump, nil, nil) } } } @@ -102,7 +100,7 @@ for i := 0; i < b.N; i++ { list := newList(true) // Insert the transactions in a random order for _, v := range rand.Perm(len(txs)) { - list.Add(txs[v], DefaultConfig.PriceBump, nil) + list.Add(txs[v], DefaultConfig.PriceBump, nil, nil) } b.StartTimer() list.Cap(list.Len() - 1)

diff --git op-geth/core/txpool/subpool.go Celo/core/txpool/subpool.go index 4e2a0133f33fb592666404afbec7a9898125c7d5..aa02faaa8dcc71c379b56d30dd5881d41b4b3755 100644 --- op-geth/core/txpool/subpool.go +++ Celo/core/txpool/subpool.go @@ -43,6 +43,9 @@ Gas uint64 // Amount of gas required by the transaction BlobGas uint64 // Amount of blob gas required by the transaction   DABytes *big.Int // Amount of data availability bytes this transaction may require if this is a rollup + + // Celo + FeeCurrency *common.Address }   // Resolve retrieves the full transaction belonging to a lazy handle if it is still

diff --git op-geth/core/txpool/validation.go Celo/core/txpool/validation.go index 17de989ad309ccd58a547d7538d9df410a6d4e31..9e49697a95a3b59831234e523a0dd079f28394c8 100644 --- op-geth/core/txpool/validation.go +++ Celo/core/txpool/validation.go @@ -23,6 +23,7 @@ "fmt" "math/big"   "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/exchange" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" @@ -74,7 +75,8 @@ // (balance, nonce, etc). // // This check is public to allow different transaction pools to check the basic // rules without duplicating code and running the risk of missed updates. -func ValidateTransaction(tx *types.Transaction, head *types.Header, signer types.Signer, opts *ValidationOptions) error { +// ONLY TO BE CALLED FROM "CeloValidateTransaction" +func ValidateTransaction(tx *types.Transaction, head *types.Header, signer types.Signer, opts *CeloValidationOptions, currencyCtx common.FeeCurrencyContext) error { // No unauthenticated deposits allowed in the transaction pool. // This is for spam protection, not consensus, // as the external engine-API user authenticates deposits. @@ -85,7 +87,7 @@ if opts.Config.IsOptimism() && tx.Type() == types.BlobTxType { return core.ErrTxTypeNotSupported } // Ensure transactions not implemented by the calling pool are rejected - if opts.Accept&(1<<tx.Type()) == 0 { + if !opts.Accepts(tx.Type()) { return fmt.Errorf("%w: tx type %v not supported by this pool", core.ErrTxTypeNotSupported, tx.Type()) } // Before performing any expensive validations, sanity check that the tx is @@ -133,7 +135,16 @@ return ErrInvalidSender } // Ensure the transaction has more gas than the bare minimum needed to cover // the transaction metadata - intrGas, err := core.IntrinsicGas(tx.Data(), tx.AccessList(), tx.To() == nil, true, opts.Config.IsIstanbul(head.Number), opts.Config.IsShanghai(head.Number, head.Time)) + intrGas, err := core.IntrinsicGas( + tx.Data(), + tx.AccessList(), + tx.To() == nil, + true, + opts.Config.IsIstanbul(head.Number), + opts.Config.IsShanghai(head.Number, head.Time), + tx.FeeCurrency(), + currencyCtx.IntrinsicGasCosts, + ) if err != nil { return err } @@ -141,7 +152,11 @@ if tx.Gas() < intrGas { return fmt.Errorf("%w: gas %v, minimum needed %v", core.ErrIntrinsicGas, tx.Gas(), intrGas) } // Ensure the gasprice is high enough to cover the requirement of the calling pool - if tx.GasTipCapIntCmp(opts.MinTip) < 0 { + minTip, err := exchange.ConvertCeloToCurrency(currencyCtx.ExchangeRates, tx.FeeCurrency(), opts.MinTip) + if err != nil { + return err + } + if tx.GasTipCapIntCmp(minTip) < 0 { return fmt.Errorf("%w: gas tip cap %v, minimum needed %v", ErrUnderpriced, tx.GasTipCap(), opts.MinTip) } if tx.Type() == types.BlobTxType { @@ -202,7 +217,7 @@ // ValidationOptionsWithState define certain differences between stateful transaction // validation across the different pools without having to duplicate those checks. type ValidationOptionsWithState struct { - State *state.StateDB // State database to check nonces and balances against + State *state.StateDB // State database to check nonces   // FirstNonceGap is an optional callback to retrieve the first nonce gap in // the list of pooled transactions of a specific account. If this method is @@ -217,14 +232,27 @@ UsedAndLeftSlots func(addr common.Address) (int, int)   // ExistingExpenditure is a mandatory callback to retrieve the cumulative // cost of the already pooled transactions to check for overdrafts. - ExistingExpenditure func(addr common.Address) *big.Int + // Returns (feeCurrencySpent, nativeSpent), where feeCurrencySpent only + // includes the spending for txs with the relevant feeCurrency. + // The feeCurrency relevant for feeCurrencySpent is fixed for every + // instance of ExistingExpenditure and therefore not passed in as a + // parameter. + ExistingExpenditure func(addr common.Address) (*big.Int, *big.Int)   // ExistingCost is a mandatory callback to retrieve an already pooled // transaction's cost with the given nonce to check for overdrafts. - ExistingCost func(addr common.Address, nonce uint64) *big.Int + // Returns (feeCurrencyCost, nativeCost), where feeCurrencyCost only + // includes the spending for txs with the relevant feeCurrency. + // The feeCurrency relevant for feeCurrencyCost is fixed for every + // instance of ExistingCost, and therefore not passed in as a + // parameter. + ExistingCost func(addr common.Address, nonce uint64) (*big.Int, *big.Int)   // L1CostFn is an optional extension, to validate L1 rollup costs of a tx L1CostFn L1CostFunc + + // ExistingBalance for a currency, to check for balance to cover transaction costs. + ExistingBalance func(addr common.Address, feeCurrency *common.Address) *big.Int }   // ValidateTransactionWithState is a helper method to check whether a transaction @@ -252,30 +280,51 @@ } } // Ensure the transactor has enough funds to cover the transaction costs var ( - balance = opts.State.GetBalance(from).ToBig() - cost = tx.Cost() + feeCurrencyBalance = common.Big0 + nativeBalance = opts.ExistingBalance(from, &common.ZeroAddress) + feeCurrencyCost, nativeCost = tx.Cost() ) + if tx.FeeCurrency() != nil { + feeCurrencyBalance = opts.ExistingBalance(from, tx.FeeCurrency()) + } + if feeCurrencyBalance == nil { + return fmt.Errorf("feeCurrencyBalance is nil for FeeCurrency %x", tx.FeeCurrency()) + } if opts.L1CostFn != nil { if l1Cost := opts.L1CostFn(tx.RollupCostData()); l1Cost != nil { // add rollup cost - cost = cost.Add(cost, l1Cost) + nativeCost = nativeCost.Add(nativeCost, l1Cost) } } - if balance.Cmp(cost) < 0 { - return fmt.Errorf("%w: balance %v, tx cost %v, overshot %v", core.ErrInsufficientFunds, balance, cost, new(big.Int).Sub(cost, balance)) + if feeCurrencyBalance.Cmp(feeCurrencyCost) < 0 { + return fmt.Errorf("%w: balance %v, tx cost %v, overshot %v, fee currency: %v", core.ErrInsufficientFunds, feeCurrencyBalance, feeCurrencyCost, new(big.Int).Sub(feeCurrencyCost, feeCurrencyBalance), tx.FeeCurrency().Hex()) + } + if nativeBalance.Cmp(nativeCost) < 0 { + return fmt.Errorf("%w: balance %v, tx cost %v, overshot %v", core.ErrInsufficientFunds, nativeBalance, nativeCost, new(big.Int).Sub(nativeCost, nativeBalance)) } // Ensure the transactor has enough funds to cover for replacements or nonce // expansions without overdrafts - spent := opts.ExistingExpenditure(from) - if prev := opts.ExistingCost(from, tx.Nonce()); prev != nil { - bump := new(big.Int).Sub(cost, prev) - need := new(big.Int).Add(spent, bump) - if balance.Cmp(need) < 0 { - return fmt.Errorf("%w: balance %v, queued cost %v, tx bumped %v, overshot %v", core.ErrInsufficientFunds, balance, spent, bump, new(big.Int).Sub(need, balance)) + feeCurrencySpent, nativeSpent := opts.ExistingExpenditure(from) + if feeCurrencyPrev, nativePrev := opts.ExistingCost(from, tx.Nonce()); feeCurrencyPrev != nil { + // Costs from all transactions refer to the same currency, + // which is ensured by ExistingCost and ExistingExpenditure. + feeCurrencyBump := new(big.Int).Sub(feeCurrencyCost, feeCurrencyPrev) + feeCurrencyNeed := new(big.Int).Add(feeCurrencySpent, feeCurrencyBump) + nativeBump := new(big.Int).Sub(nativeCost, nativePrev) + nativeNeed := new(big.Int).Add(nativeSpent, nativeBump) + if feeCurrencyBalance.Cmp(feeCurrencyNeed) < 0 { + return fmt.Errorf("%w: balance %v, queued cost %v, tx bumped %v, overshot %v, feeCurrency %v", core.ErrInsufficientFunds, feeCurrencyBalance, feeCurrencySpent, feeCurrencyBump, new(big.Int).Sub(feeCurrencyNeed, feeCurrencyBalance), tx.FeeCurrency()) + } + if nativeBalance.Cmp(nativeNeed) < 0 { + return fmt.Errorf("%w: balance %v, queued cost %v, tx bumped %v, overshot %v", core.ErrInsufficientFunds, nativeBalance, nativeSpent, nativeBump, new(big.Int).Sub(nativeNeed, nativeBalance)) } } else { - need := new(big.Int).Add(spent, cost) - if balance.Cmp(need) < 0 { - return fmt.Errorf("%w: balance %v, queued cost %v, tx cost %v, overshot %v", core.ErrInsufficientFunds, balance, spent, cost, new(big.Int).Sub(need, balance)) + feeCurrencyNeed := new(big.Int).Add(feeCurrencySpent, feeCurrencyCost) + nativeNeed := new(big.Int).Add(nativeSpent, nativeCost) + if feeCurrencyBalance.Cmp(feeCurrencyNeed) < 0 { + return fmt.Errorf("%w: balance %v, queued cost %v, tx cost %v, overshot %v, feeCurrency %v", core.ErrInsufficientFunds, feeCurrencyBalance, feeCurrencySpent, feeCurrencyCost, new(big.Int).Sub(feeCurrencyNeed, feeCurrencyBalance), tx.FeeCurrency()) + } + if nativeBalance.Cmp(nativeNeed) < 0 { + return fmt.Errorf("%w: balance %v, queued cost %v, tx cost %v, overshot %v", core.ErrInsufficientFunds, nativeBalance, nativeSpent, nativeCost, new(big.Int).Sub(nativeNeed, nativeBalance)) } // Transaction takes a new nonce value out of the pool. Ensure it doesn't // overflow the number of permitted transactions from a single account

diff --git op-geth/core/types/celo_dynamic_fee_tx.go Celo/core/types/celo_dynamic_fee_tx.go new file mode 100644 index 0000000000000000000000000000000000000000..f1fab1f4d8ce6e078311d6335e6fb117404cf019 --- /dev/null +++ Celo/core/types/celo_dynamic_fee_tx.go @@ -0,0 +1,136 @@ +// Copyright 2024 The Celo Authors +// This file is part of the celo library. +// +// The celo library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The celo library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the celo library. If not, see <http://www.gnu.org/licenses/>. + +package types + +import ( + "bytes" + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/rlp" +) + +const CeloDynamicFeeTxType = 0x7c + +type CeloDynamicFeeTx struct { + ChainID *big.Int + Nonce uint64 + GasTipCap *big.Int + GasFeeCap *big.Int + Gas uint64 + FeeCurrency *common.Address `rlp:"nil"` // nil means native currency + GatewayFeeRecipient *common.Address `rlp:"nil"` // nil means no gateway fee is paid + GatewayFee *big.Int `rlp:"nil"` + To *common.Address `rlp:"nil"` // nil means contract creation + Value *big.Int + Data []byte + AccessList AccessList + + // Signature values + V *big.Int `json:"v" gencodec:"required"` + R *big.Int `json:"r" gencodec:"required"` + S *big.Int `json:"s" gencodec:"required"` +} + +// copy creates a deep copy of the transaction data and initializes all fields. +func (tx *CeloDynamicFeeTx) copy() TxData { + cpy := &CeloDynamicFeeTx{ + Nonce: tx.Nonce, + To: copyAddressPtr(tx.To), + Data: common.CopyBytes(tx.Data), + Gas: tx.Gas, + FeeCurrency: copyAddressPtr(tx.FeeCurrency), + GatewayFeeRecipient: copyAddressPtr(tx.GatewayFeeRecipient), + // These are copied below. + AccessList: make(AccessList, len(tx.AccessList)), + GatewayFee: new(big.Int), + Value: new(big.Int), + ChainID: new(big.Int), + GasTipCap: new(big.Int), + GasFeeCap: new(big.Int), + V: new(big.Int), + R: new(big.Int), + S: new(big.Int), + } + copy(cpy.AccessList, tx.AccessList) + if tx.Value != nil { + cpy.Value.Set(tx.Value) + } + if tx.ChainID != nil { + cpy.ChainID.Set(tx.ChainID) + } + if tx.GasTipCap != nil { + cpy.GasTipCap.Set(tx.GasTipCap) + } + if tx.GasFeeCap != nil { + cpy.GasFeeCap.Set(tx.GasFeeCap) + } + if tx.GatewayFee != nil { + cpy.GatewayFee.Set(tx.GatewayFee) + } + if tx.V != nil { + cpy.V.Set(tx.V) + } + if tx.R != nil { + cpy.R.Set(tx.R) + } + if tx.S != nil { + cpy.S.Set(tx.S) + } + return cpy +} + +// accessors for innerTx. +func (tx *CeloDynamicFeeTx) txType() byte { return CeloDynamicFeeTxType } +func (tx *CeloDynamicFeeTx) chainID() *big.Int { return tx.ChainID } +func (tx *CeloDynamicFeeTx) accessList() AccessList { return tx.AccessList } +func (tx *CeloDynamicFeeTx) data() []byte { return tx.Data } +func (tx *CeloDynamicFeeTx) gas() uint64 { return tx.Gas } +func (tx *CeloDynamicFeeTx) gasFeeCap() *big.Int { return tx.GasFeeCap } +func (tx *CeloDynamicFeeTx) gasTipCap() *big.Int { return tx.GasTipCap } +func (tx *CeloDynamicFeeTx) gasPrice() *big.Int { return tx.GasFeeCap } +func (tx *CeloDynamicFeeTx) value() *big.Int { return tx.Value } +func (tx *CeloDynamicFeeTx) nonce() uint64 { return tx.Nonce } +func (tx *CeloDynamicFeeTx) to() *common.Address { return tx.To } +func (tx *CeloDynamicFeeTx) isSystemTx() bool { return false } + +func (tx *CeloDynamicFeeTx) effectiveGasPrice(dst *big.Int, baseFee *big.Int) *big.Int { + if baseFee == nil { + return dst.Set(tx.GasFeeCap) + } + tip := dst.Sub(tx.GasFeeCap, baseFee) + if tip.Cmp(tx.GasTipCap) > 0 { + tip.Set(tx.GasTipCap) + } + return tip.Add(tip, baseFee) +} + +func (tx *CeloDynamicFeeTx) rawSignatureValues() (v, r, s *big.Int) { + return tx.V, tx.R, tx.S +} + +func (tx *CeloDynamicFeeTx) setSignatureValues(chainID, v, r, s *big.Int) { + tx.ChainID, tx.V, tx.R, tx.S = chainID, v, r, s +} + +func (tx *CeloDynamicFeeTx) encode(b *bytes.Buffer) error { + return rlp.Encode(b, tx) +} + +func (tx *CeloDynamicFeeTx) decode(input []byte) error { + return rlp.DecodeBytes(input, tx) +}

diff --git op-geth/core/types/celo_transaction_signing.go Celo/core/types/celo_transaction_signing.go new file mode 100644 index 0000000000000000000000000000000000000000..823d9212d52cf6687625c889a872808777bc1fbb --- /dev/null +++ Celo/core/types/celo_transaction_signing.go @@ -0,0 +1,118 @@ +// Copyright 2024 The Celo Authors +// This file is part of the celo library. +// +// The celo library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The celo library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the celo library. If not, see <http://www.gnu.org/licenses/>. + +package types + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/params" +) + +var ( + ErrDeprecatedTxType = errors.New("deprecated transaction type") +) + +// celoSigner acts as an overlay signer that handles celo specific signing +// functionality and hands off to an upstream signer for any other transaction +// types. Unlike the signers in the go-ethereum library, the celoSigner is +// configured with a list of forks that determine it's signing capabilities so +// there should not be a need to create any further signers to handle celo +// specific transaction types. +type celoSigner struct { + upstreamSigner Signer + chainID *big.Int + activatedForks forks +} + +// makeCeloSigner creates a new celoSigner that is configured to handle all +// celo forks that are active at the given block time. If there are no active +// celo forks the upstream signer will be returned. +func makeCeloSigner(chainConfig *params.ChainConfig, blockTime uint64, upstreamSigner Signer) Signer { + s := &celoSigner{ + chainID: chainConfig.ChainID, + upstreamSigner: upstreamSigner, + activatedForks: celoForks.activeForks(blockTime, chainConfig), + } + + // If there are no active celo forks, return the upstream signer + if len(s.activatedForks) == 0 { + return upstreamSigner + } + return s +} + +// latestCeloSigner creates a new celoSigner that is configured to handle all +// celo forks for non celo transaction types it will delegate to the given +// upstream signer. +func latestCeloSigner(chainID *big.Int, upstreamSigner Signer) Signer { + return &celoSigner{ + chainID: chainID, + upstreamSigner: upstreamSigner, + activatedForks: celoForks, + } +} + +// Sender implements Signer. +func (c *celoSigner) Sender(tx *Transaction) (common.Address, error) { + if funcs := c.findTxFuncs(tx); funcs != nil { + return funcs.sender(tx, funcs.hash, c.ChainID()) + } + return c.upstreamSigner.Sender(tx) +} + +// SignatureValues implements Signer. +func (c *celoSigner) SignatureValues(tx *Transaction, sig []byte) (r *big.Int, s *big.Int, v *big.Int, err error) { + if funcs := c.findTxFuncs(tx); funcs != nil { + return funcs.signatureValues(tx, sig, c.ChainID()) + } + return c.upstreamSigner.SignatureValues(tx, sig) +} + +// Hash implements Signer. +func (c *celoSigner) Hash(tx *Transaction) common.Hash { + if funcs := c.findTxFuncs(tx); funcs != nil { + return funcs.hash(tx, c.ChainID()) + } + return c.upstreamSigner.Hash(tx) +} + +// findTxFuncs returns the txFuncs for the given tx if it is supported by one +// of the active forks. Note that this mechanism can be used to deprecate +// support for tx types by having forks return deprecatedTxFuncs for a tx type. +func (c *celoSigner) findTxFuncs(tx *Transaction) *txFuncs { + return c.activatedForks.findTxFuncs(tx) +} + +// ChainID implements Signer. +func (c *celoSigner) ChainID() *big.Int { + return c.chainID +} + +// Equal implements Signer. +func (c *celoSigner) Equal(s Signer) bool { + // Normally signers just check to see if the chainID and type are equal, + // because their logic is hardcoded to a specific fork. In our case we need + // to also know that the two signers have matching latest forks. + other, ok := s.(*celoSigner) + return ok && c.ChainID() == other.ChainID() && c.latestFork().equal(other.latestFork()) +} + +func (c *celoSigner) latestFork() fork { + return c.activatedForks[len(c.activatedForks)-1] +}

diff --git op-geth/core/types/receipt.go Celo/core/types/receipt.go index 4bc83bf988f84dbe37f3fc0a04577c2838f9363a..7b2befc199c8e276e34a6d8d30741c659c13ca0d 100644 --- op-geth/core/types/receipt.go +++ Celo/core/types/receipt.go @@ -92,6 +92,11 @@ L1Fee *big.Int `json:"l1Fee,omitempty"` // Present from pre-bedrock FeeScalar *big.Float `json:"l1FeeScalar,omitempty"` // Present from pre-bedrock to Ecotone. Nil after Ecotone L1BaseFeeScalar *uint64 `json:"l1BaseFeeScalar,omitempty"` // Always nil prior to the Ecotone hardfork L1BlobBaseFeeScalar *uint64 `json:"l1BlobBaseFeeScalar,omitempty"` // Always nil prior to the Ecotone hardfork + + // Celo + // The BaseFee is stored in fee currency for fee currency txs. We need + // this field to calculate the EffectiveGasPrice for fee currency txs. + BaseFee *big.Int `json:"baseFee,omitempty"` }   type receiptMarshaling struct { @@ -256,6 +261,9 @@ // encodeTyped writes the canonical encoding of a typed receipt to w. func (r *Receipt) encodeTyped(data *receiptRLP, w *bytes.Buffer) error { w.WriteByte(r.Type) switch r.Type { + case CeloDynamicFeeTxV2Type: + withBaseFee := &celoDynamicReceiptRLP{data.PostStateOrStatus, data.CumulativeGasUsed, data.Bloom, data.Logs, r.BaseFee} + return rlp.Encode(w, withBaseFee) case DepositTxType: withNonce := &depositReceiptRLP{data.PostStateOrStatus, data.CumulativeGasUsed, data.Bloom, data.Logs, r.DepositNonce, r.DepositReceiptVersion} return rlp.Encode(w, withNonce) @@ -329,7 +337,7 @@ if len(b) <= 1 { return errShortTypedReceipt } switch b[0] { - case DynamicFeeTxType, AccessListTxType, BlobTxType: + case DynamicFeeTxType, AccessListTxType, BlobTxType, CeloDynamicFeeTxType: var data receiptRLP err := rlp.DecodeBytes(b[1:], &data) if err != nil { @@ -337,6 +345,15 @@ return err } r.Type = b[0] return r.setFromRLP(data) + case CeloDynamicFeeTxV2Type: + var data celoDynamicReceiptRLP + err := rlp.DecodeBytes(b[1:], &data) + if err != nil { + return err + } + r.Type = b[0] + r.BaseFee = data.BaseFee + return r.setFromRLP(receiptRLP{data.PostStateOrStatus, data.CumulativeGasUsed, data.Bloom, data.Logs}) case DepositTxType: var data depositReceiptRLP err := rlp.DecodeBytes(b[1:], &data) @@ -401,6 +418,11 @@ // into an RLP stream. func (r *ReceiptForStorage) EncodeRLP(_w io.Writer) error { w := rlp.NewEncoderBuffer(_w) outerList := w.List() + if r.Type == CeloDynamicFeeTxV2Type { + // Mark receipt as CeloDynamicFee receipt by starting with an empty list + listIndex := w.List() + w.ListEnd(listIndex) + } w.WriteBytes((*Receipt)(r).statusEncoding()) w.WriteUint64(r.CumulativeGasUsed) logList := w.List() @@ -416,6 +438,9 @@ if r.DepositReceiptVersion != nil { w.WriteUint64(*r.DepositReceiptVersion) } } + if r.Type == CeloDynamicFeeTxV2Type && r.BaseFee != nil { + w.WriteBigInt(r.BaseFee) + } w.ListEnd(outerList) return w.Flush() } @@ -429,6 +454,9 @@ if err != nil { return err } // First try to decode the latest receipt database format, try the pre-bedrock Optimism legacy format otherwise. + if IsCeloDynamicFeeReceipt(blob) { + return decodeStoredCeloDynamicFeeReceiptRLP(r, blob) + } if err := decodeStoredReceiptRLP(r, blob); err == nil { return nil } @@ -502,8 +530,11 @@ return } w.WriteByte(r.Type) switch r.Type { - case AccessListTxType, DynamicFeeTxType, BlobTxType: + case AccessListTxType, DynamicFeeTxType, BlobTxType, CeloDynamicFeeTxType: rlp.Encode(w, data) + case CeloDynamicFeeTxV2Type: + celoDynamicData := &celoDynamicReceiptRLP{data.PostStateOrStatus, data.CumulativeGasUsed, data.Bloom, data.Logs, r.BaseFee} + rlp.Encode(w, celoDynamicData) case DepositTxType: if r.DepositReceiptVersion != nil { // post-canyon receipt hash computation update @@ -525,14 +556,39 @@ func (rs Receipts) DeriveFields(config *params.ChainConfig, hash common.Hash, number uint64, time uint64, baseFee *big.Int, blobGasPrice *big.Int, txs []*Transaction) error { signer := MakeSigner(config, new(big.Int).SetUint64(number), time)   logIndex := uint(0) - if len(txs) != len(rs) { + + // If rs are one longer than txs it indicates the presence of a celo block receipt. + if len(txs) != len(rs) && len(txs)+1 != len(rs) { return errors.New("transaction and receipt count mismatch") } - for i := 0; i < len(rs); i++ { + for i := 0; i < len(txs); i++ { // The transaction type and hash can be retrieved from the transaction itself rs[i].Type = txs[i].Type() rs[i].TxHash = txs[i].Hash() - rs[i].EffectiveGasPrice = txs[i].inner.effectiveGasPrice(new(big.Int), baseFee) + + switch rs[i].Type { + case LegacyTxType, AccessListTxType: + // These are the non dynamic tx types so we can simply set effective gas price to gas price. + rs[i].EffectiveGasPrice = txs[i].inner.effectiveGasPrice(new(big.Int), baseFee) + default: + // Pre-gingerbred the base fee was stored in state, but we don't try to recover it here, since A) we don't + // have access to the objects required to get the state and B) retrieving the base fee is quite code heavy + // and we don't want to bring that code across from the celo L1 to op-geth. In the celo L1 we would return a + // nil base fee if the state was not available, so that is what we do here. + // + // We also check for the London hardfork here, in order to not break tests from upstream that have not + // configured the gingerbread block, since the london hardfork introduced dynamic fee transactions. + if config.IsGingerbread(new(big.Int).SetUint64(number)) || config.IsLondon(new(big.Int).SetUint64(number)) { + // The post transition CeloDynamicFeeV2Txs set the baseFee in the receipt, so if we have it use it. + // Otherwise we can set the effectiveGasPrice only if the transaction does not specify a fee currency, + // since we would need state to discover the true base fee. + if rs[i].BaseFee != nil { + rs[i].EffectiveGasPrice = txs[i].inner.effectiveGasPrice(new(big.Int), rs[i].BaseFee) + } else if txs[i].FeeCurrency() == nil || txs[i].Type() == CeloDenominatedTxType { + rs[i].EffectiveGasPrice = txs[i].inner.effectiveGasPrice(new(big.Int), baseFee) + } + } + }   // EIP-4844 blob transaction fields if txs[i].Type() == BlobTxType { @@ -575,6 +631,20 @@ rs[i].Logs[j].Index = logIndex logIndex++ } } + + // This is a celo block receipt, which uses the block hash in place of the tx hash. + if len(txs)+1 == len(rs) { + j := len(txs) + for k := 0; k < len(rs[j].Logs); k++ { + rs[j].Logs[k].BlockNumber = number + rs[j].Logs[k].BlockHash = hash + rs[j].Logs[k].TxHash = hash + rs[j].Logs[k].TxIndex = uint(j) + rs[j].Logs[k].Index = logIndex + logIndex++ + } + } + if config.Optimism != nil && len(txs) >= 2 && config.IsBedrock(new(big.Int).SetUint64(number)) { // need at least an info tx and a non-info tx gasParams, err := extractL1GasParams(config, time, txs[0].Data()) if err != nil {

diff --git op-geth/core/types/receipt_test.go Celo/core/types/receipt_test.go index 76599fdd323980c098bca80d62393ec0bd945dae..49d23ace0c0c56888511c71942d85a86ec2c4e99 100644 --- op-geth/core/types/receipt_test.go +++ Celo/core/types/receipt_test.go @@ -99,6 +99,24 @@ }, }, Type: DynamicFeeTxType, } + celoDynamicFeeReceipt = &Receipt{ + Status: ReceiptStatusFailed, + CumulativeGasUsed: 1, + Logs: []*Log{ + { + Address: common.BytesToAddress([]byte{0x11}), + Topics: []common.Hash{common.HexToHash("dead"), common.HexToHash("beef")}, + Data: []byte{0x01, 0x00, 0xff}, + }, + { + Address: common.BytesToAddress([]byte{0x01, 0x11}), + Topics: []common.Hash{common.HexToHash("dead"), common.HexToHash("beef")}, + Data: []byte{0x01, 0x00, 0xff}, + }, + }, + BaseFee: new(big.Int).SetUint64(1), + Type: CeloDynamicFeeTxV2Type, + } depositReceiptNoNonce = &Receipt{ Status: ReceiptStatusFailed, CumulativeGasUsed: 1, @@ -624,6 +642,24 @@ eip1559Want := common.FromHex("02f901c58001b9010000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000014000000000000000000000000000000000000000000000000000000000000000000000000000010000080000000000000000000004000000000000000000000000000040000000000000000000000000000800000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000f8bef85d940000000000000000000000000000000000000011f842a0000000000000000000000000000000000000000000000000000000000000deada0000000000000000000000000000000000000000000000000000000000000beef830100fff85d940000000000000000000000000000000000000111f842a0000000000000000000000000000000000000000000000000000000000000deada0000000000000000000000000000000000000000000000000000000000000beef830100ff") if !bytes.Equal(have, eip1559Want) { t.Errorf("encoded RLP mismatch, got %x want %x", have, eip1559Want) } + + // Celo Dynamic Fee Receipt + buf.Reset() + celoDynamicFeeReceipt.Bloom = CreateBloom(Receipts{celoDynamicFeeReceipt}) + have, err = celoDynamicFeeReceipt.MarshalBinary() + if err != nil { + t.Fatalf("marshal binary error: %v", err) + } + celoDynamicFeeReceipts := Receipts{celoDynamicFeeReceipt} + celoDynamicFeeReceipts.EncodeIndex(0, buf) + haveEncodeIndex = buf.Bytes() + if !bytes.Equal(have, haveEncodeIndex) { + t.Errorf("BinaryMarshal and EncodeIndex mismatch, got %x want %x", have, haveEncodeIndex) + } + celoDynamicFeeWant := common.FromHex("7bf901c68001b9010000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000014000000000000000000000000000000000000000000000000000000000000000000000000000010000080000000000000000000004000000000000000000000000000040000000000000000000000000000800000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000f8bef85d940000000000000000000000000000000000000011f842a0000000000000000000000000000000000000000000000000000000000000deada0000000000000000000000000000000000000000000000000000000000000beef830100fff85d940000000000000000000000000000000000000111f842a0000000000000000000000000000000000000000000000000000000000000deada0000000000000000000000000000000000000000000000000000000000000beef830100ff01") + if !bytes.Equal(have, celoDynamicFeeWant) { + t.Errorf("encoded RLP mismatch, got %x want %x", have, celoDynamicFeeWant) + } }   func TestReceiptUnmarshalBinary(t *testing.T) { @@ -1002,6 +1038,7 @@ }{ {name: "Legacy", rcpt: legacyReceipt}, {name: "AccessList", rcpt: accessListReceipt}, {name: "EIP1559", rcpt: eip1559Receipt}, + {name: "CeloDynamicFee", rcpt: celoDynamicFeeReceipt}, {name: "DepositNoNonce", rcpt: depositReceiptNoNonce}, {name: "DepositWithNonce", rcpt: depositReceiptWithNonce}, {name: "DepositWithNonceAndVersion", rcpt: depositReceiptWithNonceAndVersion}, @@ -1038,6 +1075,7 @@ }{ {name: "Legacy", rcpt: legacyReceipt}, {name: "AccessList", rcpt: accessListReceipt}, {name: "EIP1559", rcpt: eip1559Receipt}, + {name: "CeloDynamicFee", rcpt: celoDynamicFeeReceipt}, {name: "DepositNoNonce", rcpt: depositReceiptNoNonce}, {name: "DepositWithNonce", rcpt: depositReceiptWithNonce}, {name: "DepositWithNonceAndVersion", rcpt: depositReceiptWithNonceAndVersion}, @@ -1056,6 +1094,9 @@ require.Equal(t, test.rcpt.CumulativeGasUsed, d.CumulativeGasUsed) require.Equal(t, test.rcpt.Logs, d.Logs) require.Equal(t, test.rcpt.DepositNonce, d.DepositNonce) require.Equal(t, test.rcpt.DepositReceiptVersion, d.DepositReceiptVersion) + if test.rcpt.Type == CeloDynamicFeeTxV2Type { + require.Equal(t, test.rcpt.EffectiveGasPrice, d.EffectiveGasPrice) + } }) } }

diff --git op-geth/core/types/transaction.go Celo/core/types/transaction.go index 3c94261061476ac453aaf252e49e0b66d8635cd9..b5ee77df6d141f61cac05eb22bb4c5a76d236992 100644 --- op-geth/core/types/transaction.go +++ Celo/core/types/transaction.go @@ -209,6 +209,11 @@ func (tx *Transaction) decodeTyped(b []byte) (TxData, error) { if len(b) <= 1 { return nil, errShortTypedTx } + + if inner, isCelo, err := celoDecodeTyped(b); isCelo { + return inner, err + } + var inner TxData switch b[0] { case AccessListTxType: @@ -372,14 +377,29 @@ func (tx *Transaction) IsSystemTx() bool { return tx.inner.isSystemTx() }   -// Cost returns (gas * gasPrice) + (blobGas * blobGasPrice) + value. -func (tx *Transaction) Cost() *big.Int { +// Cost returns both components of the tx costs: +// - cost in feeCurrency: (gas * gasPrice) + (blobGas * blobGasPrice) +// - native token cost: value sent to target contract +// For non-feeCurrency transactions, the first value is zero and the second is the total cost. +func (tx *Transaction) Cost() (*big.Int, *big.Int) { total := new(big.Int).Mul(tx.GasPrice(), new(big.Int).SetUint64(tx.Gas())) if tx.Type() == BlobTxType { total.Add(total, new(big.Int).Mul(tx.BlobGasFeeCap(), new(big.Int).SetUint64(tx.BlobGas()))) } - total.Add(total, tx.Value()) - return total + if tx.FeeCurrency() == nil { + nativeCost := total.Add(total, tx.Value()) + return new(big.Int), nativeCost + } else { + // Will need to be updated for CIP-66 + nativeCost := tx.Value() + return total, nativeCost + } +} + +// Returns the native token component of the transaction cost. +func (tx *Transaction) NativeCost() *big.Int { + _, nativeCost := tx.Cost() + return nativeCost }   // RollupCostData caches the information needed to efficiently compute the data availability fee

diff --git op-geth/core/types/transaction_marshalling.go Celo/core/types/transaction_marshalling.go index a07d65414c3846e49412a3083371e93b843d2553..a9dd124ceb500e033c40b9f374f8c8c5ba41e073 100644 --- op-geth/core/types/transaction_marshalling.go +++ Celo/core/types/transaction_marshalling.go @@ -63,6 +63,13 @@ Proofs []kzg4844.Proof `json:"proofs,omitempty"`   // Only used for encoding: Hash common.Hash `json:"hash"` + + // Celo specific fields + FeeCurrency *common.Address `json:"feeCurrency,omitempty"` // nil means native currency + MaxFeeInFeeCurrency *hexutil.Big `json:"maxFeeInFeeCurrency,omitempty"` + EthCompatible *bool `json:"ethCompatible,omitempty"` + GatewayFee *hexutil.Big `json:"gatewayFee,omitempty"` + GatewayFeeRecipient *common.Address `json:"gatewayFeeRecipient,omitempty"` }   // yParityValue returns the YParity value from JSON. For backwards-compatibility reasons, @@ -87,6 +94,9 @@ }   // MarshalJSON marshals as JSON with a hash. func (tx *Transaction) MarshalJSON() ([]byte, error) { + if marshalled, isCelo, err := celoTransactionMarshal(tx); isCelo { + return marshalled, err + } var enc txJSON // These are set for all tx types. enc.Hash = tx.Hash() @@ -202,6 +212,12 @@ }   // Decode / verify fields according to transaction type. var inner TxData + + if isCelo, err := celoTransactionUnmarshal(dec, &inner); isCelo { + tx.setDecoded(inner, 0) + return err + } + switch dec.Type { case LegacyTxType: var itx LegacyTx

diff --git op-geth/core/types/transaction_signing.go Celo/core/types/transaction_signing.go index 1238c9a6c38d7a5485f4ccf2b8c9b95ea7e5b48a..2bbb92afd758217d979fe0eb278ac70653c66f6c 100644 --- op-geth/core/types/transaction_signing.go +++ Celo/core/types/transaction_signing.go @@ -53,6 +53,10 @@ signer = HomesteadSigner{} default: signer = FrontierSigner{} } + + // Apply the celo overlay signer, if no celo forks have been enabled then the given signer is returned. + signer = makeCeloSigner(config, blockTime, signer) + return signer }   @@ -67,6 +71,13 @@ func LatestSigner(config *params.ChainConfig) Signer { var signer Signer if config.ChainID != nil { switch { + case config.Cel2Time != nil: + if config.CancunTime != nil { + // This branch is only used in testing + return latestCeloSigner(config.ChainID, NewCancunSigner(config.ChainID)) + } else { + return latestCeloSigner(config.ChainID, NewLondonSigner(config.ChainID)) + } case config.CancunTime != nil && !config.IsOptimism(): signer = NewCancunSigner(config.ChainID) case config.LondonBlock != nil: @@ -94,7 +105,7 @@ // If you have a ChainConfig and know the current block number, use MakeSigner instead. func LatestSignerForChainID(chainID *big.Int) Signer { var signer Signer if chainID != nil { - signer = NewCancunSigner(chainID) + signer = latestCeloSigner(chainID, NewCancunSigner(chainID)) } else { signer = HomesteadSigner{} }

diff --git op-geth/core/types/tx_legacy.go Celo/core/types/tx_legacy.go index bcb65c39349a3a1bef78948af48a30a1e14c71ba..782c3934c74eff4cbd26c290f72073be92c0d528 100644 --- op-geth/core/types/tx_legacy.go +++ Celo/core/types/tx_legacy.go @@ -25,13 +25,25 @@ )   // LegacyTx is the transaction data of the original Ethereum transactions. type LegacyTx struct { - Nonce uint64 // nonce of sender account - GasPrice *big.Int // wei per gas - Gas uint64 // gas limit - To *common.Address `rlp:"nil"` // nil means contract creation - Value *big.Int // wei amount - Data []byte // contract invocation input data - V, R, S *big.Int // signature values + Nonce uint64 // nonce of sender account + GasPrice *big.Int // wei per gas + Gas uint64 // gas limit + + // Celo-specific fields + FeeCurrency *common.Address // nil means native currency + GatewayFeeRecipient *common.Address // nil means no gateway fee is paid + GatewayFee *big.Int + + To *common.Address `rlp:"nil"` // nil means contract creation + Value *big.Int // wei amount + Data []byte // contract invocation input data + V, R, S *big.Int // signature values + + // This is only used when marshaling to JSON. + Hash *common.Hash `rlp:"-"` + + // Whether this is a celo legacy transaction (i.e. with FeeCurrency, GatewayFeeRecipient and GatewayFee) + CeloLegacy bool `rlp:"-"` }   // NewTransaction creates an unsigned legacy transaction. @@ -72,6 +84,12 @@ GasPrice: new(big.Int), V: new(big.Int), R: new(big.Int), S: new(big.Int), + + // Celo specific fields + FeeCurrency: copyAddressPtr(tx.FeeCurrency), + GatewayFeeRecipient: copyAddressPtr(tx.GatewayFeeRecipient), + GatewayFee: copyBigInt(tx.GatewayFee), + CeloLegacy: tx.CeloLegacy, } if tx.Value != nil { cpy.Value.Set(tx.Value)

diff --git op-geth/contracts/celo/README.md Celo/contracts/celo/README.md new file mode 100644 index 0000000000000000000000000000000000000000..3a0735f1fecc93d0c9e1f5932a755c022d139ad2 --- /dev/null +++ Celo/contracts/celo/README.md @@ -0,0 +1,18 @@ +# Celo contracts bytecode and ABI + +## Why contracts in this repo? + +The contracts bytecode is used to generate the genesis block in `geth --dev` +mode while the ABI is used to generate the contract bindings in `abigen`. The +bindings are necessary to access the FeeCurrencyDirectory and fee currencies. + +## How to update to newer contracts + +To compile contracts in the optimism repo and extract their ABI and bin-runtime +for relevant contracts into this repo, run `compiled/update.sh`. If your +optimism repo is not at `~/optimism`, set the `CELO_OPTIMISM_REPO` env variable +accordingly. The same is true for `~/celo-monorepo` and the `CELO_MONOREPO` env var. + +## How to rebuild ABI wrappers + +Use `go generate`, e.g. as `go generate ./contracts/celo/celo.go`.

diff --git op-geth/contracts/celo/abigen/FeeCurrency.go Celo/contracts/celo/abigen/FeeCurrency.go new file mode 100644 index 0000000000000000000000000000000000000000..64b51d54185afdb0838eda5b80a8c9728b3e56e3 --- /dev/null +++ Celo/contracts/celo/abigen/FeeCurrency.go @@ -0,0 +1,822 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package abigen + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// FeeCurrencyMetaData contains all meta data concerning the FeeCurrency contract. +var FeeCurrencyMetaData = &bind.MetaData{ + ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"name_\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"symbol_\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"allowance\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"approve\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"balanceOf\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"creditGasFees\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"feeRecipient\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"communityFund\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"refund\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"tipTxFee\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"baseTxFee\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"debitGasFees\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"decimals\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"decreaseAllowance\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"subtractedValue\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"increaseAllowance\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"addedValue\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"name\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"symbol\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"totalSupply\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"transfer\",\"inputs\":[{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferFrom\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"Approval\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"spender\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Transfer\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"to\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false}]", +} + +// FeeCurrencyABI is the input ABI used to generate the binding from. +// Deprecated: Use FeeCurrencyMetaData.ABI instead. +var FeeCurrencyABI = FeeCurrencyMetaData.ABI + +// FeeCurrency is an auto generated Go binding around an Ethereum contract. +type FeeCurrency struct { + FeeCurrencyCaller // Read-only binding to the contract + FeeCurrencyTransactor // Write-only binding to the contract + FeeCurrencyFilterer // Log filterer for contract events +} + +// FeeCurrencyCaller is an auto generated read-only Go binding around an Ethereum contract. +type FeeCurrencyCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// FeeCurrencyTransactor is an auto generated write-only Go binding around an Ethereum contract. +type FeeCurrencyTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// FeeCurrencyFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type FeeCurrencyFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// FeeCurrencySession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type FeeCurrencySession struct { + Contract *FeeCurrency // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// FeeCurrencyCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type FeeCurrencyCallerSession struct { + Contract *FeeCurrencyCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// FeeCurrencyTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type FeeCurrencyTransactorSession struct { + Contract *FeeCurrencyTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// FeeCurrencyRaw is an auto generated low-level Go binding around an Ethereum contract. +type FeeCurrencyRaw struct { + Contract *FeeCurrency // Generic contract binding to access the raw methods on +} + +// FeeCurrencyCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type FeeCurrencyCallerRaw struct { + Contract *FeeCurrencyCaller // Generic read-only contract binding to access the raw methods on +} + +// FeeCurrencyTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type FeeCurrencyTransactorRaw struct { + Contract *FeeCurrencyTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewFeeCurrency creates a new instance of FeeCurrency, bound to a specific deployed contract. +func NewFeeCurrency(address common.Address, backend bind.ContractBackend) (*FeeCurrency, error) { + contract, err := bindFeeCurrency(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &FeeCurrency{FeeCurrencyCaller: FeeCurrencyCaller{contract: contract}, FeeCurrencyTransactor: FeeCurrencyTransactor{contract: contract}, FeeCurrencyFilterer: FeeCurrencyFilterer{contract: contract}}, nil +} + +// NewFeeCurrencyCaller creates a new read-only instance of FeeCurrency, bound to a specific deployed contract. +func NewFeeCurrencyCaller(address common.Address, caller bind.ContractCaller) (*FeeCurrencyCaller, error) { + contract, err := bindFeeCurrency(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &FeeCurrencyCaller{contract: contract}, nil +} + +// NewFeeCurrencyTransactor creates a new write-only instance of FeeCurrency, bound to a specific deployed contract. +func NewFeeCurrencyTransactor(address common.Address, transactor bind.ContractTransactor) (*FeeCurrencyTransactor, error) { + contract, err := bindFeeCurrency(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &FeeCurrencyTransactor{contract: contract}, nil +} + +// NewFeeCurrencyFilterer creates a new log filterer instance of FeeCurrency, bound to a specific deployed contract. +func NewFeeCurrencyFilterer(address common.Address, filterer bind.ContractFilterer) (*FeeCurrencyFilterer, error) { + contract, err := bindFeeCurrency(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &FeeCurrencyFilterer{contract: contract}, nil +} + +// bindFeeCurrency binds a generic wrapper to an already deployed contract. +func bindFeeCurrency(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := FeeCurrencyMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_FeeCurrency *FeeCurrencyRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _FeeCurrency.Contract.FeeCurrencyCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_FeeCurrency *FeeCurrencyRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _FeeCurrency.Contract.FeeCurrencyTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_FeeCurrency *FeeCurrencyRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _FeeCurrency.Contract.FeeCurrencyTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_FeeCurrency *FeeCurrencyCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _FeeCurrency.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_FeeCurrency *FeeCurrencyTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _FeeCurrency.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_FeeCurrency *FeeCurrencyTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _FeeCurrency.Contract.contract.Transact(opts, method, params...) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_FeeCurrency *FeeCurrencyCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { + var out []interface{} + err := _FeeCurrency.contract.Call(opts, &out, "allowance", owner, spender) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_FeeCurrency *FeeCurrencySession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _FeeCurrency.Contract.Allowance(&_FeeCurrency.CallOpts, owner, spender) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_FeeCurrency *FeeCurrencyCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _FeeCurrency.Contract.Allowance(&_FeeCurrency.CallOpts, owner, spender) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_FeeCurrency *FeeCurrencyCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { + var out []interface{} + err := _FeeCurrency.contract.Call(opts, &out, "balanceOf", account) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_FeeCurrency *FeeCurrencySession) BalanceOf(account common.Address) (*big.Int, error) { + return _FeeCurrency.Contract.BalanceOf(&_FeeCurrency.CallOpts, account) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_FeeCurrency *FeeCurrencyCallerSession) BalanceOf(account common.Address) (*big.Int, error) { + return _FeeCurrency.Contract.BalanceOf(&_FeeCurrency.CallOpts, account) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_FeeCurrency *FeeCurrencyCaller) Decimals(opts *bind.CallOpts) (uint8, error) { + var out []interface{} + err := _FeeCurrency.contract.Call(opts, &out, "decimals") + + if err != nil { + return *new(uint8), err + } + + out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) + + return out0, err + +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_FeeCurrency *FeeCurrencySession) Decimals() (uint8, error) { + return _FeeCurrency.Contract.Decimals(&_FeeCurrency.CallOpts) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_FeeCurrency *FeeCurrencyCallerSession) Decimals() (uint8, error) { + return _FeeCurrency.Contract.Decimals(&_FeeCurrency.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_FeeCurrency *FeeCurrencyCaller) Name(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _FeeCurrency.contract.Call(opts, &out, "name") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_FeeCurrency *FeeCurrencySession) Name() (string, error) { + return _FeeCurrency.Contract.Name(&_FeeCurrency.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_FeeCurrency *FeeCurrencyCallerSession) Name() (string, error) { + return _FeeCurrency.Contract.Name(&_FeeCurrency.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_FeeCurrency *FeeCurrencyCaller) Symbol(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _FeeCurrency.contract.Call(opts, &out, "symbol") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_FeeCurrency *FeeCurrencySession) Symbol() (string, error) { + return _FeeCurrency.Contract.Symbol(&_FeeCurrency.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_FeeCurrency *FeeCurrencyCallerSession) Symbol() (string, error) { + return _FeeCurrency.Contract.Symbol(&_FeeCurrency.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_FeeCurrency *FeeCurrencyCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _FeeCurrency.contract.Call(opts, &out, "totalSupply") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_FeeCurrency *FeeCurrencySession) TotalSupply() (*big.Int, error) { + return _FeeCurrency.Contract.TotalSupply(&_FeeCurrency.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_FeeCurrency *FeeCurrencyCallerSession) TotalSupply() (*big.Int, error) { + return _FeeCurrency.Contract.TotalSupply(&_FeeCurrency.CallOpts) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_FeeCurrency *FeeCurrencyTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _FeeCurrency.contract.Transact(opts, "approve", spender, amount) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_FeeCurrency *FeeCurrencySession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _FeeCurrency.Contract.Approve(&_FeeCurrency.TransactOpts, spender, amount) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_FeeCurrency *FeeCurrencyTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _FeeCurrency.Contract.Approve(&_FeeCurrency.TransactOpts, spender, amount) +} + +// CreditGasFees is a paid mutator transaction binding the contract method 0x6a30b253. +// +// Solidity: function creditGasFees(address from, address feeRecipient, address , address communityFund, uint256 refund, uint256 tipTxFee, uint256 , uint256 baseTxFee) returns() +func (_FeeCurrency *FeeCurrencyTransactor) CreditGasFees(opts *bind.TransactOpts, from common.Address, feeRecipient common.Address, arg2 common.Address, communityFund common.Address, refund *big.Int, tipTxFee *big.Int, arg6 *big.Int, baseTxFee *big.Int) (*types.Transaction, error) { + return _FeeCurrency.contract.Transact(opts, "creditGasFees", from, feeRecipient, arg2, communityFund, refund, tipTxFee, arg6, baseTxFee) +} + +// CreditGasFees is a paid mutator transaction binding the contract method 0x6a30b253. +// +// Solidity: function creditGasFees(address from, address feeRecipient, address , address communityFund, uint256 refund, uint256 tipTxFee, uint256 , uint256 baseTxFee) returns() +func (_FeeCurrency *FeeCurrencySession) CreditGasFees(from common.Address, feeRecipient common.Address, arg2 common.Address, communityFund common.Address, refund *big.Int, tipTxFee *big.Int, arg6 *big.Int, baseTxFee *big.Int) (*types.Transaction, error) { + return _FeeCurrency.Contract.CreditGasFees(&_FeeCurrency.TransactOpts, from, feeRecipient, arg2, communityFund, refund, tipTxFee, arg6, baseTxFee) +} + +// CreditGasFees is a paid mutator transaction binding the contract method 0x6a30b253. +// +// Solidity: function creditGasFees(address from, address feeRecipient, address , address communityFund, uint256 refund, uint256 tipTxFee, uint256 , uint256 baseTxFee) returns() +func (_FeeCurrency *FeeCurrencyTransactorSession) CreditGasFees(from common.Address, feeRecipient common.Address, arg2 common.Address, communityFund common.Address, refund *big.Int, tipTxFee *big.Int, arg6 *big.Int, baseTxFee *big.Int) (*types.Transaction, error) { + return _FeeCurrency.Contract.CreditGasFees(&_FeeCurrency.TransactOpts, from, feeRecipient, arg2, communityFund, refund, tipTxFee, arg6, baseTxFee) +} + +// DebitGasFees is a paid mutator transaction binding the contract method 0x58cf9672. +// +// Solidity: function debitGasFees(address from, uint256 value) returns() +func (_FeeCurrency *FeeCurrencyTransactor) DebitGasFees(opts *bind.TransactOpts, from common.Address, value *big.Int) (*types.Transaction, error) { + return _FeeCurrency.contract.Transact(opts, "debitGasFees", from, value) +} + +// DebitGasFees is a paid mutator transaction binding the contract method 0x58cf9672. +// +// Solidity: function debitGasFees(address from, uint256 value) returns() +func (_FeeCurrency *FeeCurrencySession) DebitGasFees(from common.Address, value *big.Int) (*types.Transaction, error) { + return _FeeCurrency.Contract.DebitGasFees(&_FeeCurrency.TransactOpts, from, value) +} + +// DebitGasFees is a paid mutator transaction binding the contract method 0x58cf9672. +// +// Solidity: function debitGasFees(address from, uint256 value) returns() +func (_FeeCurrency *FeeCurrencyTransactorSession) DebitGasFees(from common.Address, value *big.Int) (*types.Transaction, error) { + return _FeeCurrency.Contract.DebitGasFees(&_FeeCurrency.TransactOpts, from, value) +} + +// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. +// +// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) +func (_FeeCurrency *FeeCurrencyTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _FeeCurrency.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue) +} + +// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. +// +// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) +func (_FeeCurrency *FeeCurrencySession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _FeeCurrency.Contract.DecreaseAllowance(&_FeeCurrency.TransactOpts, spender, subtractedValue) +} + +// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. +// +// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) +func (_FeeCurrency *FeeCurrencyTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _FeeCurrency.Contract.DecreaseAllowance(&_FeeCurrency.TransactOpts, spender, subtractedValue) +} + +// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. +// +// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) +func (_FeeCurrency *FeeCurrencyTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _FeeCurrency.contract.Transact(opts, "increaseAllowance", spender, addedValue) +} + +// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. +// +// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) +func (_FeeCurrency *FeeCurrencySession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _FeeCurrency.Contract.IncreaseAllowance(&_FeeCurrency.TransactOpts, spender, addedValue) +} + +// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. +// +// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) +func (_FeeCurrency *FeeCurrencyTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _FeeCurrency.Contract.IncreaseAllowance(&_FeeCurrency.TransactOpts, spender, addedValue) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_FeeCurrency *FeeCurrencyTransactor) Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _FeeCurrency.contract.Transact(opts, "transfer", to, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_FeeCurrency *FeeCurrencySession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _FeeCurrency.Contract.Transfer(&_FeeCurrency.TransactOpts, to, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_FeeCurrency *FeeCurrencyTransactorSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _FeeCurrency.Contract.Transfer(&_FeeCurrency.TransactOpts, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_FeeCurrency *FeeCurrencyTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _FeeCurrency.contract.Transact(opts, "transferFrom", from, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_FeeCurrency *FeeCurrencySession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _FeeCurrency.Contract.TransferFrom(&_FeeCurrency.TransactOpts, from, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_FeeCurrency *FeeCurrencyTransactorSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _FeeCurrency.Contract.TransferFrom(&_FeeCurrency.TransactOpts, from, to, amount) +} + +// FeeCurrencyApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the FeeCurrency contract. +type FeeCurrencyApprovalIterator struct { + Event *FeeCurrencyApproval // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *FeeCurrencyApprovalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(FeeCurrencyApproval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(FeeCurrencyApproval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *FeeCurrencyApprovalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *FeeCurrencyApprovalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// FeeCurrencyApproval represents a Approval event raised by the FeeCurrency contract. +type FeeCurrencyApproval struct { + Owner common.Address + Spender common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_FeeCurrency *FeeCurrencyFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*FeeCurrencyApprovalIterator, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var spenderRule []interface{} + for _, spenderItem := range spender { + spenderRule = append(spenderRule, spenderItem) + } + + logs, sub, err := _FeeCurrency.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return &FeeCurrencyApprovalIterator{contract: _FeeCurrency.contract, event: "Approval", logs: logs, sub: sub}, nil +} + +// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_FeeCurrency *FeeCurrencyFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *FeeCurrencyApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var spenderRule []interface{} + for _, spenderItem := range spender { + spenderRule = append(spenderRule, spenderItem) + } + + logs, sub, err := _FeeCurrency.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(FeeCurrencyApproval) + if err := _FeeCurrency.contract.UnpackLog(event, "Approval", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_FeeCurrency *FeeCurrencyFilterer) ParseApproval(log types.Log) (*FeeCurrencyApproval, error) { + event := new(FeeCurrencyApproval) + if err := _FeeCurrency.contract.UnpackLog(event, "Approval", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// FeeCurrencyTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the FeeCurrency contract. +type FeeCurrencyTransferIterator struct { + Event *FeeCurrencyTransfer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *FeeCurrencyTransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(FeeCurrencyTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(FeeCurrencyTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *FeeCurrencyTransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *FeeCurrencyTransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// FeeCurrencyTransfer represents a Transfer event raised by the FeeCurrency contract. +type FeeCurrencyTransfer struct { + From common.Address + To common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_FeeCurrency *FeeCurrencyFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*FeeCurrencyTransferIterator, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _FeeCurrency.contract.FilterLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return &FeeCurrencyTransferIterator{contract: _FeeCurrency.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_FeeCurrency *FeeCurrencyFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *FeeCurrencyTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _FeeCurrency.contract.WatchLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(FeeCurrencyTransfer) + if err := _FeeCurrency.contract.UnpackLog(event, "Transfer", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_FeeCurrency *FeeCurrencyFilterer) ParseTransfer(log types.Log) (*FeeCurrencyTransfer, error) { + event := new(FeeCurrencyTransfer) + if err := _FeeCurrency.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +}

diff --git op-geth/contracts/celo/abigen/FeeCurrencyDirectory.go Celo/contracts/celo/abigen/FeeCurrencyDirectory.go new file mode 100644 index 0000000000000000000000000000000000000000..d79c9bba15b1259761880cdeded76868b1c7108f --- /dev/null +++ Celo/contracts/celo/abigen/FeeCurrencyDirectory.go @@ -0,0 +1,294 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package abigen + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// IFeeCurrencyDirectoryCurrencyConfig is an auto generated low-level Go binding around an user-defined struct. +type IFeeCurrencyDirectoryCurrencyConfig struct { + Oracle common.Address + IntrinsicGas *big.Int +} + +// FeeCurrencyDirectoryMetaData contains all meta data concerning the FeeCurrencyDirectory contract. +var FeeCurrencyDirectoryMetaData = &bind.MetaData{ + ABI: "[{\"type\":\"function\",\"name\":\"getCurrencies\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"address[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getCurrencyConfig\",\"inputs\":[{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIFeeCurrencyDirectory.CurrencyConfig\",\"components\":[{\"name\":\"oracle\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"intrinsicGas\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getExchangeRate\",\"inputs\":[{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"numerator\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"denominator\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"}]", +} + +// FeeCurrencyDirectoryABI is the input ABI used to generate the binding from. +// Deprecated: Use FeeCurrencyDirectoryMetaData.ABI instead. +var FeeCurrencyDirectoryABI = FeeCurrencyDirectoryMetaData.ABI + +// FeeCurrencyDirectory is an auto generated Go binding around an Ethereum contract. +type FeeCurrencyDirectory struct { + FeeCurrencyDirectoryCaller // Read-only binding to the contract + FeeCurrencyDirectoryTransactor // Write-only binding to the contract + FeeCurrencyDirectoryFilterer // Log filterer for contract events +} + +// FeeCurrencyDirectoryCaller is an auto generated read-only Go binding around an Ethereum contract. +type FeeCurrencyDirectoryCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// FeeCurrencyDirectoryTransactor is an auto generated write-only Go binding around an Ethereum contract. +type FeeCurrencyDirectoryTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// FeeCurrencyDirectoryFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type FeeCurrencyDirectoryFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// FeeCurrencyDirectorySession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type FeeCurrencyDirectorySession struct { + Contract *FeeCurrencyDirectory // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// FeeCurrencyDirectoryCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type FeeCurrencyDirectoryCallerSession struct { + Contract *FeeCurrencyDirectoryCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// FeeCurrencyDirectoryTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type FeeCurrencyDirectoryTransactorSession struct { + Contract *FeeCurrencyDirectoryTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// FeeCurrencyDirectoryRaw is an auto generated low-level Go binding around an Ethereum contract. +type FeeCurrencyDirectoryRaw struct { + Contract *FeeCurrencyDirectory // Generic contract binding to access the raw methods on +} + +// FeeCurrencyDirectoryCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type FeeCurrencyDirectoryCallerRaw struct { + Contract *FeeCurrencyDirectoryCaller // Generic read-only contract binding to access the raw methods on +} + +// FeeCurrencyDirectoryTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type FeeCurrencyDirectoryTransactorRaw struct { + Contract *FeeCurrencyDirectoryTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewFeeCurrencyDirectory creates a new instance of FeeCurrencyDirectory, bound to a specific deployed contract. +func NewFeeCurrencyDirectory(address common.Address, backend bind.ContractBackend) (*FeeCurrencyDirectory, error) { + contract, err := bindFeeCurrencyDirectory(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &FeeCurrencyDirectory{FeeCurrencyDirectoryCaller: FeeCurrencyDirectoryCaller{contract: contract}, FeeCurrencyDirectoryTransactor: FeeCurrencyDirectoryTransactor{contract: contract}, FeeCurrencyDirectoryFilterer: FeeCurrencyDirectoryFilterer{contract: contract}}, nil +} + +// NewFeeCurrencyDirectoryCaller creates a new read-only instance of FeeCurrencyDirectory, bound to a specific deployed contract. +func NewFeeCurrencyDirectoryCaller(address common.Address, caller bind.ContractCaller) (*FeeCurrencyDirectoryCaller, error) { + contract, err := bindFeeCurrencyDirectory(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &FeeCurrencyDirectoryCaller{contract: contract}, nil +} + +// NewFeeCurrencyDirectoryTransactor creates a new write-only instance of FeeCurrencyDirectory, bound to a specific deployed contract. +func NewFeeCurrencyDirectoryTransactor(address common.Address, transactor bind.ContractTransactor) (*FeeCurrencyDirectoryTransactor, error) { + contract, err := bindFeeCurrencyDirectory(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &FeeCurrencyDirectoryTransactor{contract: contract}, nil +} + +// NewFeeCurrencyDirectoryFilterer creates a new log filterer instance of FeeCurrencyDirectory, bound to a specific deployed contract. +func NewFeeCurrencyDirectoryFilterer(address common.Address, filterer bind.ContractFilterer) (*FeeCurrencyDirectoryFilterer, error) { + contract, err := bindFeeCurrencyDirectory(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &FeeCurrencyDirectoryFilterer{contract: contract}, nil +} + +// bindFeeCurrencyDirectory binds a generic wrapper to an already deployed contract. +func bindFeeCurrencyDirectory(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := FeeCurrencyDirectoryMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_FeeCurrencyDirectory *FeeCurrencyDirectoryRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _FeeCurrencyDirectory.Contract.FeeCurrencyDirectoryCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_FeeCurrencyDirectory *FeeCurrencyDirectoryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _FeeCurrencyDirectory.Contract.FeeCurrencyDirectoryTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_FeeCurrencyDirectory *FeeCurrencyDirectoryRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _FeeCurrencyDirectory.Contract.FeeCurrencyDirectoryTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_FeeCurrencyDirectory *FeeCurrencyDirectoryCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _FeeCurrencyDirectory.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_FeeCurrencyDirectory *FeeCurrencyDirectoryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _FeeCurrencyDirectory.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_FeeCurrencyDirectory *FeeCurrencyDirectoryTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _FeeCurrencyDirectory.Contract.contract.Transact(opts, method, params...) +} + +// GetCurrencies is a free data retrieval call binding the contract method 0x61c661de. +// +// Solidity: function getCurrencies() view returns(address[]) +func (_FeeCurrencyDirectory *FeeCurrencyDirectoryCaller) GetCurrencies(opts *bind.CallOpts) ([]common.Address, error) { + var out []interface{} + err := _FeeCurrencyDirectory.contract.Call(opts, &out, "getCurrencies") + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// GetCurrencies is a free data retrieval call binding the contract method 0x61c661de. +// +// Solidity: function getCurrencies() view returns(address[]) +func (_FeeCurrencyDirectory *FeeCurrencyDirectorySession) GetCurrencies() ([]common.Address, error) { + return _FeeCurrencyDirectory.Contract.GetCurrencies(&_FeeCurrencyDirectory.CallOpts) +} + +// GetCurrencies is a free data retrieval call binding the contract method 0x61c661de. +// +// Solidity: function getCurrencies() view returns(address[]) +func (_FeeCurrencyDirectory *FeeCurrencyDirectoryCallerSession) GetCurrencies() ([]common.Address, error) { + return _FeeCurrencyDirectory.Contract.GetCurrencies(&_FeeCurrencyDirectory.CallOpts) +} + +// GetCurrencyConfig is a free data retrieval call binding the contract method 0xeab43d97. +// +// Solidity: function getCurrencyConfig(address token) view returns((address,uint256)) +func (_FeeCurrencyDirectory *FeeCurrencyDirectoryCaller) GetCurrencyConfig(opts *bind.CallOpts, token common.Address) (IFeeCurrencyDirectoryCurrencyConfig, error) { + var out []interface{} + err := _FeeCurrencyDirectory.contract.Call(opts, &out, "getCurrencyConfig", token) + + if err != nil { + return *new(IFeeCurrencyDirectoryCurrencyConfig), err + } + + out0 := *abi.ConvertType(out[0], new(IFeeCurrencyDirectoryCurrencyConfig)).(*IFeeCurrencyDirectoryCurrencyConfig) + + return out0, err + +} + +// GetCurrencyConfig is a free data retrieval call binding the contract method 0xeab43d97. +// +// Solidity: function getCurrencyConfig(address token) view returns((address,uint256)) +func (_FeeCurrencyDirectory *FeeCurrencyDirectorySession) GetCurrencyConfig(token common.Address) (IFeeCurrencyDirectoryCurrencyConfig, error) { + return _FeeCurrencyDirectory.Contract.GetCurrencyConfig(&_FeeCurrencyDirectory.CallOpts, token) +} + +// GetCurrencyConfig is a free data retrieval call binding the contract method 0xeab43d97. +// +// Solidity: function getCurrencyConfig(address token) view returns((address,uint256)) +func (_FeeCurrencyDirectory *FeeCurrencyDirectoryCallerSession) GetCurrencyConfig(token common.Address) (IFeeCurrencyDirectoryCurrencyConfig, error) { + return _FeeCurrencyDirectory.Contract.GetCurrencyConfig(&_FeeCurrencyDirectory.CallOpts, token) +} + +// GetExchangeRate is a free data retrieval call binding the contract method 0xefb7601d. +// +// Solidity: function getExchangeRate(address token) view returns(uint256 numerator, uint256 denominator) +func (_FeeCurrencyDirectory *FeeCurrencyDirectoryCaller) GetExchangeRate(opts *bind.CallOpts, token common.Address) (struct { + Numerator *big.Int + Denominator *big.Int +}, error) { + var out []interface{} + err := _FeeCurrencyDirectory.contract.Call(opts, &out, "getExchangeRate", token) + + outstruct := new(struct { + Numerator *big.Int + Denominator *big.Int + }) + if err != nil { + return *outstruct, err + } + + outstruct.Numerator = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + outstruct.Denominator = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// GetExchangeRate is a free data retrieval call binding the contract method 0xefb7601d. +// +// Solidity: function getExchangeRate(address token) view returns(uint256 numerator, uint256 denominator) +func (_FeeCurrencyDirectory *FeeCurrencyDirectorySession) GetExchangeRate(token common.Address) (struct { + Numerator *big.Int + Denominator *big.Int +}, error) { + return _FeeCurrencyDirectory.Contract.GetExchangeRate(&_FeeCurrencyDirectory.CallOpts, token) +} + +// GetExchangeRate is a free data retrieval call binding the contract method 0xefb7601d. +// +// Solidity: function getExchangeRate(address token) view returns(uint256 numerator, uint256 denominator) +func (_FeeCurrencyDirectory *FeeCurrencyDirectoryCallerSession) GetExchangeRate(token common.Address) (struct { + Numerator *big.Int + Denominator *big.Int +}, error) { + return _FeeCurrencyDirectory.Contract.GetExchangeRate(&_FeeCurrencyDirectory.CallOpts, token) +}

diff --git op-geth/contracts/celo/celo.go Celo/contracts/celo/celo.go new file mode 100644 index 0000000000000000000000000000000000000000..eee8c63da824cc170cbabbe8e6f17f199d10ab2f --- /dev/null +++ Celo/contracts/celo/celo.go @@ -0,0 +1,18 @@ +package celo + +import _ "embed" + +//go:generate go run ../../cmd/abigen --pkg abigen --out abigen/FeeCurrency.go --abi compiled/FeeCurrency.abi --type FeeCurrency +//go:generate go run ../../cmd/abigen --pkg abigen --out abigen/FeeCurrencyDirectory.go --abi compiled/IFeeCurrencyDirectory.abi --type FeeCurrencyDirectory + +//go:embed compiled/GoldToken.bin-runtime +var CeloTokenBytecodeRaw []byte + +//go:embed compiled/FeeCurrency.bin-runtime +var FeeCurrencyBytecodeRaw []byte + +//go:embed compiled/FeeCurrencyDirectory.bin-runtime +var FeeCurrencyDirectoryBytecodeRaw []byte + +//go:embed compiled/MockOracle.bin-runtime +var MockOracleBytecodeRaw []byte

diff --git op-geth/contracts/celo/compiled/FeeCurrency.abi Celo/contracts/celo/compiled/FeeCurrency.abi new file mode 100644 index 0000000000000000000000000000000000000000..279f6f754ab9192a2b8eb5f90a3aec6639c5e551 --- /dev/null +++ Celo/contracts/celo/compiled/FeeCurrency.abi @@ -0,0 +1,354 @@ +[ + { + "type": "constructor", + "inputs": [ + { + "name": "name_", + "type": "string", + "internalType": "string" + }, + { + "name": "symbol_", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "allowance", + "inputs": [ + { + "name": "owner", + "type": "address", + "internalType": "address" + }, + { + "name": "spender", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "approve", + "inputs": [ + { + "name": "spender", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "balanceOf", + "inputs": [ + { + "name": "account", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "creditGasFees", + "inputs": [ + { + "name": "from", + "type": "address", + "internalType": "address" + }, + { + "name": "feeRecipient", + "type": "address", + "internalType": "address" + }, + { + "name": "", + "type": "address", + "internalType": "address" + }, + { + "name": "communityFund", + "type": "address", + "internalType": "address" + }, + { + "name": "refund", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "tipTxFee", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "baseTxFee", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "debitGasFees", + "inputs": [ + { + "name": "from", + "type": "address", + "internalType": "address" + }, + { + "name": "value", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "decimals", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint8", + "internalType": "uint8" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "decreaseAllowance", + "inputs": [ + { + "name": "spender", + "type": "address", + "internalType": "address" + }, + { + "name": "subtractedValue", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "increaseAllowance", + "inputs": [ + { + "name": "spender", + "type": "address", + "internalType": "address" + }, + { + "name": "addedValue", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "name", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "symbol", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "totalSupply", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "transfer", + "inputs": [ + { + "name": "to", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "transferFrom", + "inputs": [ + { + "name": "from", + "type": "address", + "internalType": "address" + }, + { + "name": "to", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "event", + "name": "Approval", + "inputs": [ + { + "name": "owner", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "spender", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "value", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Transfer", + "inputs": [ + { + "name": "from", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "to", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "value", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + } +]

diff --git op-geth/contracts/celo/compiled/FeeCurrency.bin-runtime Celo/contracts/celo/compiled/FeeCurrency.bin-runtime new file mode 100644 index 0000000000000000000000000000000000000000..236826b180339f87deee821e74369a225b3d85db --- /dev/null +++ Celo/contracts/celo/compiled/FeeCurrency.bin-runtime @@ -0,0 +1 @@ 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

diff --git op-geth/contracts/celo/compiled/FeeCurrencyDirectory.bin-runtime Celo/contracts/celo/compiled/FeeCurrencyDirectory.bin-runtime new file mode 100644 index 0000000000000000000000000000000000000000..79b9c0731e3d8bb39908819291fcd1f31d5d2ce0 --- /dev/null +++ Celo/contracts/celo/compiled/FeeCurrencyDirectory.bin-runtime @@ -0,0 +1 @@ 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

diff --git op-geth/contracts/celo/compiled/GoldToken.abi Celo/contracts/celo/compiled/GoldToken.abi new file mode 100644 index 0000000000000000000000000000000000000000..d0d8926dac24f7446be224c6d0494d6bf799c8cd --- /dev/null +++ Celo/contracts/celo/compiled/GoldToken.abi @@ -0,0 +1,669 @@ +[ + { + "type": "constructor", + "inputs": [ + { + "name": "test", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "allocatedSupply", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "allowance", + "inputs": [ + { + "name": "_owner", + "type": "address", + "internalType": "address" + }, + { + "name": "spender", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "approve", + "inputs": [ + { + "name": "spender", + "type": "address", + "internalType": "address" + }, + { + "name": "value", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "balanceOf", + "inputs": [ + { + "name": "_owner", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "burn", + "inputs": [ + { + "name": "value", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "celoTokenDistributionSchedule", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract ICeloDistributionSchedule" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "circulatingSupply", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "decimals", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint8", + "internalType": "uint8" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "decreaseAllowance", + "inputs": [ + { + "name": "spender", + "type": "address", + "internalType": "address" + }, + { + "name": "value", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "depositAmount", + "inputs": [ + { + "name": "_depositAmount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "getBurnedAmount", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getVersionNumber", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "increaseAllowance", + "inputs": [ + { + "name": "spender", + "type": "address", + "internalType": "address" + }, + { + "name": "value", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "increaseSupply", + "inputs": [ + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "initialize", + "inputs": [ + { + "name": "registryAddress", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "initialized", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isL2", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isOwner", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "mint", + "inputs": [ + { + "name": "to", + "type": "address", + "internalType": "address" + }, + { + "name": "value", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "name", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "owner", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "registry", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IRegistry" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "renounceOwnership", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setCeloTokenDistributionScheduleAddress", + "inputs": [ + { + "name": "celoTokenDistributionScheduleAddress", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setRegistry", + "inputs": [ + { + "name": "registryAddress", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "symbol", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "totalSupply", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "transfer", + "inputs": [ + { + "name": "to", + "type": "address", + "internalType": "address" + }, + { + "name": "value", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "transferFrom", + "inputs": [ + { + "name": "from", + "type": "address", + "internalType": "address" + }, + { + "name": "to", + "type": "address", + "internalType": "address" + }, + { + "name": "value", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "transferOwnership", + "inputs": [ + { + "name": "newOwner", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "transferWithComment", + "inputs": [ + { + "name": "to", + "type": "address", + "internalType": "address" + }, + { + "name": "value", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "comment", + "type": "string", + "internalType": "string" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "withdrawAmount", + "inputs": [ + { + "name": "_withdrawAmount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "withdrawn", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "Approval", + "inputs": [ + { + "name": "owner", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "spender", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "value", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OwnershipTransferred", + "inputs": [ + { + "name": "previousOwner", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "newOwner", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "RegistrySet", + "inputs": [ + { + "name": "registryAddress", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "SetCeloTokenDistributionScheduleAddress", + "inputs": [ + { + "name": "newScheduleAddress", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Transfer", + "inputs": [ + { + "name": "from", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "to", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "value", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "TransferComment", + "inputs": [ + { + "name": "comment", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + } +]

diff --git op-geth/contracts/celo/compiled/GoldToken.bin-runtime Celo/contracts/celo/compiled/GoldToken.bin-runtime new file mode 100644 index 0000000000000000000000000000000000000000..6417be2913ecbddc6540400a74de1524bf696bc1 --- /dev/null +++ Celo/contracts/celo/compiled/GoldToken.bin-runtime @@ -0,0 +1 @@ +0x608060405234801561001057600080fd5b50600436106101fb5760003560e01c80637b1039991161011a578063a91ee0dc116100ad578063d4d83cfb1161007c578063d4d83cfb14610565578063db2b4d101461056d578063dd62ed3e14610593578063e1d6aceb146105c1578063f2fde38b14610646576101fb565b8063a91ee0dc146104f4578063b921e1631461051a578063c4d66de814610537578063c80ec5221461055d576101fb565b80639358928b116100e95780639358928b1461048c57806395d89b4114610494578063a457c2d71461049c578063a9059cbb146104c8576101fb565b80637b1039991461043b57806387f8ab261461045f5780638da5cb5b1461047c5780638f32d59b14610484576101fb565b8063395093511161019257806354255be01161016157806354255be0146103d757806370a0823114610405578063715018a61461042b57806376348f7114610433576101fb565b8063395093511461035a5780633a70a5ca1461038657806340c10f191461038e57806342966c68146103ba576101fb565b806318160ddd116101ce57806318160ddd146102e457806323b872dd146102fe578063265126bd14610334578063313ce5671461033c576101fb565b80630562b9f71461020057806306fdde031461021f578063095ea7b31461029c578063158ef93e146102dc575b600080fd5b61021d6004803603602081101561021657600080fd5b503561066c565b005b61022761070d565b6040805160208082528351818301528351919283929083019185019080838360005b83811015610261578181015183820152602001610249565b50505050905090810190601f16801561028e5780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b6102c8600480360360408110156102b257600080fd5b506001600160a01b038135169060200135610739565b604080519115158252519081900360200190f35b6102c86107fe565b6102ec610807565b60408051918252519081900360200190f35b6102c86004803603606081101561031457600080fd5b506001600160a01b03813581169160208101359091169060400135610846565b6102ec610b17565b610344610b29565b6040805160ff9092168252519081900360200190f35b6102c86004803603604081101561037057600080fd5b506001600160a01b038135169060200135610b2e565b6102ec610c2a565b6102c8600480360360408110156103a457600080fd5b506001600160a01b038135169060200135610c8e565b6102c8600480360360208110156103d057600080fd5b5035610eb6565b6103df610ec4565b604080519485526020850193909352838301919091526060830152519081900360800190f35b6102ec6004803603602081101561041b57600080fd5b50356001600160a01b0316610ed1565b61021d610ede565b6102c8610f74565b610443610f88565b604080516001600160a01b039092168252519081900360200190f35b61021d6004803603602081101561047557600080fd5b5035610f97565b610443611033565b6102c8611047565b6102ec611070565b61022761109e565b6102c8600480360360408110156104b257600080fd5b506001600160a01b0381351690602001356110bc565b6102c8600480360360408110156104de57600080fd5b506001600160a01b0381351690602001356110f1565b61021d6004803603602081101561050a57600080fd5b50356001600160a01b0316611104565b61021d6004803603602081101561053057600080fd5b50356111f0565b61021d6004803603602081101561054d57600080fd5b50356001600160a01b0316611257565b6102ec6112d4565b6104436112da565b61021d6004803603602081101561058357600080fd5b50356001600160a01b03166112e9565b6102ec600480360360408110156105a957600080fd5b506001600160a01b03813581169160200135166113e3565b6102c8600480360360608110156105d757600080fd5b6001600160a01b038235169160208101359181019060608101604082013564010000000081111561060757600080fd5b82018360208201111561061957600080fd5b8035906020019184600183028401116401000000008311171561063b57600080fd5b50909250905061140e565b61021d6004803603602081101561065c57600080fd5b50356001600160a01b0316611486565b610674610f74565b6106af5760405162461bcd60e51b81526004018080602001828103825260238152602001806119e76023913960400191505060405180910390fd5b6016602160991b0133146106f45760405162461bcd60e51b81526004018080602001828103825260228152602001806119076022913960400191505060405180910390fd5b600454610707908263ffffffff6114d616565b60045550565b60408051808201909152601181527010d95b1bc81b985d1a5d9948185cdcd95d607a1b60208201525b90565b60006001600160a01b038316610796576040805162461bcd60e51b815260206004820152601a60248201527f63616e6e6f742073657420616c6c6f77616e636520666f722030000000000000604482015290519081900360640190fd5b3360008181526003602090815260408083206001600160a01b03881680855290835292819020869055805186815290519293927f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925929181900390910190a35060015b92915050565b60005460ff1681565b6000610811610f74565b1561083d57600454610836906b033b2e3c9fd0803ce80000009063ffffffff61153016565b9050610736565b50600254610736565b60006001600160a01b03831661088d5760405162461bcd60e51b815260040180806020018281038252602a815260200180611a0a602a913960400191505060405180910390fd5b61089684610ed1565b8211156108d45760405162461bcd60e51b81526004018080602001828103825260298152602001806119be6029913960400191505060405180910390fd5b6001600160a01b03841660009081526003602090815260408083203384529091529020548211156109365760405162461bcd60e51b8152600401808060200182810382526036815260200180611a346036913960400191505060405180910390fd5b600060fd815a9087878760405160200180846001600160a01b03166001600160a01b03168152602001836001600160a01b03166001600160a01b0316815260200182815260200193505050506040516020818303038152906040526040518082805190602001908083835b602083106109c05780518252601f1990920191602091820191016109a1565b6001836020036101000a038019825116818451168082178552505050505050905001915050600060405180830381858888f193505050503d8060008114610a23576040519150601f19603f3d011682016040523d82523d6000602084013e610a28565b606091505b50508091505080610a77576040805162461bcd60e51b815260206004820152601460248201527310d15313c81d1c985b9cd9995c8819985a5b195960621b604482015290519081900360640190fd5b6001600160a01b0385166000908152600360209081526040808320338452909152902054610aab908463ffffffff61153016565b6001600160a01b03808716600081815260036020908152604080832033845282529182902094909455805187815290519288169391927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef929181900390910190a3506001949350505050565b6000610b2461dead610ed1565b905090565b601290565b60006001600160a01b038316610b8b576040805162461bcd60e51b815260206004820152601a60248201527f63616e6e6f742073657420616c6c6f77616e636520666f722030000000000000604482015290519081900360640190fd5b3360009081526003602090815260408083206001600160a01b038716845290915281205490610bc0828563ffffffff6114d616565b3360008181526003602090815260408083206001600160a01b038b16808552908352928190208590558051858152905194955091937f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9259281900390910190a3506001949350505050565b6000610c34610f74565b610c6f5760405162461bcd60e51b81526004018080602001828103825260238152602001806119e76023913960400191505060405180910390fd5b506005546001600160a01b0316316b033b2e3c9fd0803ce80000000390565b6000610c98611572565b3315610cde576040805162461bcd60e51b815260206004820152601060248201526f13db9b1e4815934818d85b8818d85b1b60821b604482015290519081900360640190fd5b81610ceb575060016107f8565b6001600160a01b038316610d305760405162461bcd60e51b81526004018080602001828103825260268152602001806119296026913960400191505060405180910390fd5b600254610d43908363ffffffff6114d616565b600255600060fd815a6040805160006020808301919091526001600160a01b038a168284015260608083018a905283518084039091018152608090920192839052815193949391929182918401908083835b60208310610db45780518252601f199092019160209182019101610d95565b6001836020036101000a038019825116818451168082178552505050505050905001915050600060405180830381858888f193505050503d8060008114610e17576040519150601f19603f3d011682016040523d82523d6000602084013e610e1c565b606091505b50508091505080610e6b576040805162461bcd60e51b815260206004820152601460248201527310d15313c81d1c985b9cd9995c8819985a5b195960621b604482015290519081900360640190fd5b6040805184815290516001600160a01b038616916000917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef9181900360200190a35060019392505050565b60006107f861dead836115b8565b6001806003600090919293565b6001600160a01b03163190565b610ee6611047565b610f25576040805162461bcd60e51b8152602060048201819052602482015260008051602061199e833981519152604482015290519081900360640190fd5b600080546040516101009091046001600160a01b0316907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a360008054610100600160a81b0319169055565b63ffffffff6018602160991b013b16151590565b6001546001600160a01b031681565b3315610fdd576040805162461bcd60e51b815260206004820152601060248201526f13db9b1e4815934818d85b8818d85b1b60821b604482015290519081900360640190fd5b610fe5610f74565b6110205760405162461bcd60e51b81526004018080602001828103825260238152602001806119e76023913960400191505060405180910390fd5b600454610707908263ffffffff61153016565b60005461010090046001600160a01b031690565b6000805461010090046001600160a01b031661106161176f565b6001600160a01b031614905090565b6000610b2461107f6000610ed1565b61109261108a610b17565b611092610807565b9063ffffffff61153016565b60408051808201909152600481526343454c4f60e01b602082015290565b3360009081526003602090815260408083206001600160a01b038616845290915281205481610bc0828563ffffffff61153016565b60006110fd8383611773565b9392505050565b61110c611047565b61114b576040805162461bcd60e51b8152602060048201819052602482015260008051602061199e833981519152604482015290519081900360640190fd5b6001600160a01b0381166111a6576040805162461bcd60e51b815260206004820181905260248201527f43616e6e6f7420726567697374657220746865206e756c6c2061646472657373604482015290519081900360640190fd5b600180546001600160a01b0319166001600160a01b0383169081179091556040517f27fe5f0c1c3b1ed427cc63d0f05759ffdecf9aec9e18d31ef366fc8a6cb5dc3b90600090a250565b6111f8611572565b331561123e576040805162461bcd60e51b815260206004820152601060248201526f13db9b1e4815934818d85b8818d85b1b60821b604482015290519081900360640190fd5b600254611251908263ffffffff6114d616565b60025550565b60005460ff16156112af576040805162461bcd60e51b815260206004820152601c60248201527f636f6e747261637420616c726561647920696e697469616c697a656400000000604482015290519081900360640190fd5b6000805460ff191660011781556002556112c8336117c4565b6112d181611104565b50565b60045481565b6005546001600160a01b031681565b6112f1611047565b611330576040805162461bcd60e51b8152602060048201819052602482015260008051602061199e833981519152604482015290519081900360640190fd5b6001600160a01b03811615158061135557506005546001600160a01b03828116911614155b611399576040805162461bcd60e51b815260206004820152601060248201526f24b73b30b634b21030b2323932b9b99760811b604482015290519081900360640190fd5b600580546001600160a01b0319166001600160a01b0383169081179091556040517f4b0e16c81bce2248d2d60ed469d2fe74152253bde95ba850f22ae056723980a690600090a250565b6001600160a01b03918216600090815260036020908152604080832093909416825291909152205490565b60008061141b8686611773565b90507fe5d4e30fb8364e57bc4d662a07d0cf36f4c34552004c4c3624620a2c1d1c03dc848460405180806020018281038252848482818152602001925080828437600083820152604051601f909101601f19169092018290039550909350505050a195945050505050565b61148e611047565b6114cd576040805162461bcd60e51b8152602060048201819052602482015260008051602061199e833981519152604482015290519081900360640190fd5b6112d1816117c4565b6000828201838110156110fd576040805162461bcd60e51b815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604482015290519081900360640190fd5b60006110fd83836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f77000081525061186f565b61157a610f74565b156115b65760405162461bcd60e51b81526004018080602001828103825260298152602001806119756029913960400191505060405180910390fd5b565b60006115c333610ed1565b8211156116015760405162461bcd60e51b81526004018080602001828103825260298152602001806119be6029913960400191505060405180910390fd5b600060fd815a60408051336020808301919091526001600160a01b038a168284015260608083018a905283518084039091018152608090920192839052815193949391929182918401908083835b6020831061166e5780518252601f19909201916020918201910161164f565b6001836020036101000a038019825116818451168082178552505050505050905001915050600060405180830381858888f193505050503d80600081146116d1576040519150601f19603f3d011682016040523d82523d6000602084013e6116d6565b606091505b50508091505080611725576040805162461bcd60e51b815260206004820152601460248201527310d15313c81d1c985b9cd9995c8819985a5b195960621b604482015290519081900360640190fd5b6040805184815290516001600160a01b0386169133917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef9181900360200190a35060019392505050565b3390565b60006001600160a01b0383166117ba5760405162461bcd60e51b815260040180806020018281038252602a815260200180611a0a602a913960400191505060405180910390fd5b6110fd83836115b8565b6001600160a01b0381166118095760405162461bcd60e51b815260040180806020018281038252602681526020018061194f6026913960400191505060405180910390fd5b600080546040516001600160a01b038085169361010090930416917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e091a3600080546001600160a01b0390921661010002610100600160a81b0319909216919091179055565b600081848411156118fe5760405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b838110156118c35781810151838201526020016118ab565b50505050905090810190601f1680156118f05780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b50505090039056fe4f6e6c79204c32546f4c314d6573736167655061737365722063616e2063616c6c2e6d696e7420617474656d7074656420746f2072657365727665642061646472657373203078304f776e61626c653a206e6577206f776e657220697320746865207a65726f206164647265737354686973206d6574686f64206973206e6f206c6f6e67657220737570706f7274656420696e204c322e4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65727472616e736665722076616c75652065786365656465642062616c616e6365206f662073656e64657254686973206d6574686f64206973206e6f7420737570706f7274656420696e204c312e7472616e7366657220617474656d7074656420746f2072657365727665642061646472657373203078307472616e736665722076616c75652065786365656465642073656e646572277320616c6c6f77616e636520666f72207370656e646572a265627a7a72315820883737fc20fdb370fa6d2083191051192e78e14b9c9ed5974e58cd42d97124f264736f6c63430005110032

diff --git op-geth/contracts/celo/compiled/IFeeCurrencyDirectory.abi Celo/contracts/celo/compiled/IFeeCurrencyDirectory.abi new file mode 100644 index 0000000000000000000000000000000000000000..90e071e994d161090a9347dfc7cf32ad918153d7 --- /dev/null +++ Celo/contracts/celo/compiled/IFeeCurrencyDirectory.abi @@ -0,0 +1,70 @@ +[ + { + "type": "function", + "name": "getCurrencies", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getCurrencyConfig", + "inputs": [ + { + "name": "token", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "tuple", + "internalType": "struct IFeeCurrencyDirectory.CurrencyConfig", + "components": [ + { + "name": "oracle", + "type": "address", + "internalType": "address" + }, + { + "name": "intrinsicGas", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getExchangeRate", + "inputs": [ + { + "name": "token", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "numerator", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "denominator", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + } +]

diff --git op-geth/contracts/celo/compiled/MockOracle.abi Celo/contracts/celo/compiled/MockOracle.abi new file mode 100644 index 0000000000000000000000000000000000000000..76bb6049a808f525e8460cd3ee1547e64de327c4 --- /dev/null +++ Celo/contracts/celo/compiled/MockOracle.abi @@ -0,0 +1,49 @@ +[ + { + "type": "function", + "name": "getExchangeRate", + "inputs": [ + { + "name": "_token", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "setExchangeRate", + "inputs": [ + { + "name": "_token", + "type": "address", + "internalType": "address" + }, + { + "name": "_numerator", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "_denominator", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + } +]

diff --git op-geth/contracts/celo/compiled/MockOracle.bin-runtime Celo/contracts/celo/compiled/MockOracle.bin-runtime new file mode 100644 index 0000000000000000000000000000000000000000..a82a67d31ce2048d3b6579467d5fbc8ec83df59f --- /dev/null +++ Celo/contracts/celo/compiled/MockOracle.bin-runtime @@ -0,0 +1 @@ +0x608060405234801561001057600080fd5b50600436106100365760003560e01c806358a5514f1461003b578063efb7601d1461007a575b600080fd5b61007861004936600461012d565b60009190915560015542600255600380546001600160a01b0319166001600160a01b0392909216919091179055565b005b61008d610088366004610160565b6100a6565b6040805192835260208301919091520160405180910390f35b60035460009081906001600160a01b038481169116146101025760405162461bcd60e51b8152602060048201526013602482015272151bdad95b881b9bdd081cdd5c1c1bdc9d1959606a1b604482015260640160405180910390fd5b60005460015491509150915091565b80356001600160a01b038116811461012857600080fd5b919050565b60008060006060848603121561014257600080fd5b61014b84610111565b95602085013595506040909401359392505050565b60006020828403121561017257600080fd5b61017b82610111565b939250505056fea2646970667358221220532d5a8180e3477753af960cd2ec6ffab9b57df9b867e656e78ca4ec2164930664736f6c63430008130033

diff --git op-geth/contracts/celo/compiled/update.sh Celo/contracts/celo/compiled/update.sh new file mode 100755 index 0000000000000000000000000000000000000000..d0f32423e162f3c0a479ef29dd41472c8566b148 --- /dev/null +++ Celo/contracts/celo/compiled/update.sh @@ -0,0 +1,27 @@ +#!/bin/bash + +SCRIPT_DIR=$(readlink -f "$(dirname "$0")") + +CONTRACTS_DIR=${CELO_OPTIMISM_REPO:-~/optimism}/packages/contracts-bedrock +forge build --root "$CONTRACTS_DIR" + +for contract in FeeCurrency +do + contract_json="$CONTRACTS_DIR/forge-artifacts/$contract.sol/$contract.json" + jq .abi "$contract_json" > "$SCRIPT_DIR/$contract.abi" + jq .deployedBytecode.object -r "$contract_json" > "$SCRIPT_DIR/$contract.bin-runtime" +done + +CONTRACTS_DIR=${CELO_MONOREPO:-~/celo-monorepo}/packages/protocol +forge build --root "$CONTRACTS_DIR" + +for contract in GoldToken FeeCurrencyDirectory IFeeCurrencyDirectory MockOracle +do + contract_json="$CONTRACTS_DIR/out/$contract.sol/$contract.json" + jq .abi "$contract_json" > "$SCRIPT_DIR/$contract.abi" + jq .deployedBytecode.object -r "$contract_json" > "$SCRIPT_DIR/$contract.bin-runtime" +done + +# We only need the abi for the interface (IFeeCurrencyDirectory) and the +# bytecode for the implementation (FeeCurrencyDirectory), so let's delete the other. +rm "$SCRIPT_DIR/IFeeCurrencyDirectory.bin-runtime" "$SCRIPT_DIR/FeeCurrencyDirectory.abi"

diff --git op-geth/core/celo_genesis.go Celo/core/celo_genesis.go new file mode 100644 index 0000000000000000000000000000000000000000..1e37f55b8f23a9dee0635c3b611e206c9beb193a --- /dev/null +++ Celo/core/celo_genesis.go @@ -0,0 +1,169 @@ +package core + +import ( + "encoding/hex" + "fmt" + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/contracts/addresses" + "github.com/ethereum/go-ethereum/contracts/celo" + "github.com/ethereum/go-ethereum/crypto" +) + +// Decode 0x prefixed hex string from file (including trailing newline) +func DecodeHex(hexbytes []byte) ([]byte, error) { + // Strip 0x prefix and trailing newline + hexbytes = hexbytes[2 : len(hexbytes)-1] // strip 0x prefix + + // Decode hex string + bytes := make([]byte, hex.DecodedLen(len(hexbytes))) + _, err := hex.Decode(bytes, hexbytes) + if err != nil { + return nil, fmt.Errorf("DecodeHex: %w", err) + } + + return bytes, nil +} + +// Calculate address in evm mapping: keccak(key ++ mapping_slot) +func CalcMapAddr(slot common.Hash, key common.Hash) common.Hash { + return crypto.Keccak256Hash(append(key.Bytes(), slot.Bytes()...)) +} + +// Increase a hash value by `i`, used for addresses in 32byte fields +func incHash(addr common.Hash, i int64) common.Hash { + return common.BigToHash(new(big.Int).Add(addr.Big(), big.NewInt(i))) +} + +var ( + DevPrivateKey, _ = crypto.HexToECDSA("2771aff413cac48d9f8c114fabddd9195a2129f3c2c436caa07e27bb7f58ead5") + DevAddr = common.BytesToAddress(DevAddr32.Bytes()) + DevAddr32 = common.HexToHash("0x42cf1bbc38BaAA3c4898ce8790e21eD2738c6A4a") + + DevFeeCurrencyAddr = common.HexToAddress("0x000000000000000000000000000000000000ce16") // worth half as much as native CELO + DevFeeCurrencyAddr2 = common.HexToAddress("0x000000000000000000000000000000000000ce17") // worth twice as much as native CELO + DevBalance, _ = new(big.Int).SetString("100000000000000000000", 10) + rateNumerator, _ = new(big.Int).SetString("2000000000000000000000000", 10) + rateNumerator2, _ = new(big.Int).SetString("500000000000000000000000", 10) + rateDenominator, _ = new(big.Int).SetString("1000000000000000000000000", 10) + mockOracleAddr = common.HexToAddress("0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb0001") + mockOracleAddr2 = common.HexToAddress("0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb0002") + mockOracleAddr3 = common.HexToAddress("0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb0003") + FaucetAddr = common.HexToAddress("0xfcf982bb4015852e706100b14e21f947a5bb718e") + FeeCurrencyIntrinsicGas = uint64(50000) +) + +func CeloGenesisAccounts(fundedAddr common.Address) GenesisAlloc { + // Initialize Bytecodes + celoTokenBytecode, err := DecodeHex(celo.CeloTokenBytecodeRaw) + if err != nil { + panic(err) + } + feeCurrencyBytecode, err := DecodeHex(celo.FeeCurrencyBytecodeRaw) + if err != nil { + panic(err) + } + feeCurrencyDirectoryBytecode, err := DecodeHex(celo.FeeCurrencyDirectoryBytecodeRaw) + if err != nil { + panic(err) + } + mockOracleBytecode, err := DecodeHex(celo.MockOracleBytecodeRaw) + if err != nil { + panic(err) + } + + var devBalance32 common.Hash + DevBalance.FillBytes(devBalance32[:]) + + arrayAtSlot2 := crypto.Keccak256Hash(common.HexToHash("0x2").Bytes()) + + faucetBalance, ok := new(big.Int).SetString("500000000000000000000000000", 10) // 500M + if !ok { + panic("Could not set faucet balance!") + } + genesisAccounts := map[common.Address]GenesisAccount{ + addresses.MainnetAddresses.CeloToken: { + Code: celoTokenBytecode, + Balance: big.NewInt(0), + }, + DevFeeCurrencyAddr: { + Code: feeCurrencyBytecode, + Balance: big.NewInt(0), + Storage: map[common.Hash]common.Hash{ + CalcMapAddr(common.HexToHash("0x0"), DevAddr32): devBalance32, // _balances[DevAddr] + CalcMapAddr(common.HexToHash("0x0"), common.BytesToHash(fundedAddr.Bytes())): devBalance32, // _balances[fund] + common.HexToHash("0x2"): devBalance32, // _totalSupply + }, + }, + DevFeeCurrencyAddr2: { + Code: feeCurrencyBytecode, + Balance: big.NewInt(0), + Storage: map[common.Hash]common.Hash{ + CalcMapAddr(common.HexToHash("0x0"), DevAddr32): devBalance32, // _balances[DevAddr] + CalcMapAddr(common.HexToHash("0x0"), common.BytesToHash(fundedAddr.Bytes())): devBalance32, // _balances[fund] + common.HexToHash("0x2"): devBalance32, // _totalSupply + }, + }, + mockOracleAddr: { + Code: mockOracleBytecode, + Balance: big.NewInt(0), + Storage: map[common.Hash]common.Hash{ + common.HexToHash("0x0"): common.BigToHash(rateNumerator), + common.HexToHash("0x1"): common.BigToHash(rateDenominator), + common.HexToHash("0x3"): common.BytesToHash(DevFeeCurrencyAddr.Bytes()), + }, + }, + mockOracleAddr2: { + Code: mockOracleBytecode, + Balance: big.NewInt(0), + Storage: map[common.Hash]common.Hash{ + common.HexToHash("0x0"): common.BigToHash(rateNumerator2), + common.HexToHash("0x1"): common.BigToHash(rateDenominator), + common.HexToHash("0x3"): common.BytesToHash(DevFeeCurrencyAddr2.Bytes()), + }, + }, + mockOracleAddr3: { + Code: mockOracleBytecode, + Balance: big.NewInt(0), + // This oracle is available for tests of contracts outside the celo_genesis, so no initialization is done at this point + }, + DevAddr: { + Balance: DevBalance, + }, + FaucetAddr: { + Balance: faucetBalance, + }, + fundedAddr: { + Balance: DevBalance, + }, + } + + // FeeCurrencyDirectory + devAddrOffset1 := common.Hash{} + copy(devAddrOffset1[11:], DevAddr.Bytes()) + feeCurrencyDirectoryStorage := map[common.Hash]common.Hash{ + // owner, slot 0 offset 1 + common.HexToHash("0x0"): devAddrOffset1, + // add entries to currencyList at slot 2 + common.HexToHash("0x2"): common.HexToHash("0x2"), // array length 2 + arrayAtSlot2: common.BytesToHash(DevFeeCurrencyAddr.Bytes()), // FeeCurrency + incHash(arrayAtSlot2, 1): common.BytesToHash(DevFeeCurrencyAddr2.Bytes()), // FeeCurrency2 + } + // add entries to currencyConfig mapping + addFeeCurrencyToStorage(DevFeeCurrencyAddr, mockOracleAddr, feeCurrencyDirectoryStorage) + addFeeCurrencyToStorage(DevFeeCurrencyAddr2, mockOracleAddr2, feeCurrencyDirectoryStorage) + genesisAccounts[addresses.MainnetAddresses.FeeCurrencyDirectory] = GenesisAccount{ + Code: feeCurrencyDirectoryBytecode, + Balance: big.NewInt(0), + Storage: feeCurrencyDirectoryStorage, + } + + return genesisAccounts +} + +func addFeeCurrencyToStorage(feeCurrencyAddr common.Address, oracleAddr common.Address, storage map[common.Hash]common.Hash) { + structStart := CalcMapAddr(common.HexToHash("0x1"), common.BytesToHash(feeCurrencyAddr.Bytes())) + storage[structStart] = common.BytesToHash(oracleAddr.Bytes()) // oracle + storage[incHash(structStart, 1)] = common.BigToHash(big.NewInt(int64(FeeCurrencyIntrinsicGas))) // intrinsicGas +}

diff --git op-geth/core/genesis.go Celo/core/genesis.go index f8032507337e24a6fcd32d8b0eba8c9edf3f6485..27ca1c0241e086edcb8146e986d7e977fa480235 100644 --- op-geth/core/genesis.go +++ Celo/core/genesis.go @@ -61,8 +61,8 @@ Config *params.ChainConfig `json:"config"` Nonce uint64 `json:"nonce"` Timestamp uint64 `json:"timestamp"` ExtraData []byte `json:"extraData"` - GasLimit uint64 `json:"gasLimit" gencodec:"required"` - Difficulty *big.Int `json:"difficulty" gencodec:"required"` + GasLimit uint64 `json:"gasLimit"` + Difficulty *big.Int `json:"difficulty"` Mixhash common.Hash `json:"mixHash"` Coinbase common.Address `json:"coinbase"` Alloc types.GenesisAlloc `json:"alloc" gencodec:"required"` @@ -258,6 +258,8 @@ OverrideOptimismGranite *uint64 OverrideOptimismHolocene *uint64 OverrideOptimismInterop *uint64 ApplySuperchainUpgrades bool + // celo + OverrideOptimismCel2 *uint64 }   // SetupGenesisBlock writes or updates the genesis block in db. @@ -324,6 +326,9 @@ config.HoloceneTime = overrides.OverrideOptimismHolocene } if overrides != nil && overrides.OverrideOptimismInterop != nil { config.InteropTime = overrides.OverrideOptimismInterop + } + if overrides != nil && overrides.OverrideOptimismCel2 != nil { + config.Cel2Time = overrides.OverrideOptimismCel2 } } } @@ -512,6 +517,9 @@ head.GasLimit = params.GenesisGasLimit } if g.Difficulty == nil && g.Mixhash == (common.Hash{}) { head.Difficulty = params.GenesisDifficulty + } else if g.Difficulty == nil { + // In the case of migrated chains we ensure a zero rather than nil difficulty. + head.Difficulty = new(big.Int) } if g.Config != nil && g.Config.IsLondon(common.Big0) { if g.BaseFee != nil { @@ -681,6 +689,12 @@ } if faucet != nil { genesis.Alloc[*faucet] = types.Account{Balance: new(big.Int).Sub(new(big.Int).Lsh(big.NewInt(1), 256), big.NewInt(9))} } + + // Add state from celoGenesisAccounts + for addr, data := range CeloGenesisAccounts(common.HexToAddress("0x2")) { + genesis.Alloc[addr] = data + } + return genesis }

diff --git op-geth/params/config.go Celo/params/config.go index 04cc43a8403775a9e9ba9ddf7c537535c437ced2..eea0f167cadeb77af39d3b1b9ed29dbf5417aa50 100644 --- op-geth/params/config.go +++ Celo/params/config.go @@ -164,6 +164,8 @@ ArrowGlacierBlock: big.NewInt(0), GrayGlacierBlock: big.NewInt(0), ShanghaiTime: newUint64(0), CancunTime: newUint64(0), + Cel2Time: newUint64(0), + GingerbreadBlock: big.NewInt(0), TerminalTotalDifficulty: big.NewInt(0), TerminalTotalDifficultyPassed: true, } @@ -222,6 +224,39 @@ ShanghaiTime: nil, CancunTime: nil, PragueTime: nil, VerkleTime: nil, + GingerbreadBlock: big.NewInt(0), + Cel2Time: newUint64(0), + TerminalTotalDifficulty: nil, + TerminalTotalDifficultyPassed: false, + Ethash: new(EthashConfig), + Clique: nil, + } + + // TestChainConfigNoCel2 contains every protocol change (EIPs) introduced + // and accepted by the Ethereum core developers for testing purposes. + TestChainConfigNoCel2 = &ChainConfig{ + ChainID: big.NewInt(1), + HomesteadBlock: big.NewInt(0), + DAOForkBlock: nil, + DAOForkSupport: false, + EIP150Block: big.NewInt(0), + EIP155Block: big.NewInt(0), + EIP158Block: big.NewInt(0), + ByzantiumBlock: big.NewInt(0), + ConstantinopleBlock: big.NewInt(0), + PetersburgBlock: big.NewInt(0), + IstanbulBlock: big.NewInt(0), + MuirGlacierBlock: big.NewInt(0), + BerlinBlock: big.NewInt(0), + LondonBlock: big.NewInt(0), + ArrowGlacierBlock: big.NewInt(0), + GrayGlacierBlock: big.NewInt(0), + MergeNetsplitBlock: nil, + ShanghaiTime: nil, + CancunTime: nil, + PragueTime: nil, + VerkleTime: nil, + Cel2Time: nil, TerminalTotalDifficulty: nil, TerminalTotalDifficultyPassed: false, Ethash: new(EthashConfig), @@ -248,6 +283,7 @@ LondonBlock: big.NewInt(0), ArrowGlacierBlock: big.NewInt(0), GrayGlacierBlock: big.NewInt(0), MergeNetsplitBlock: big.NewInt(0), + GingerbreadBlock: big.NewInt(0), ShanghaiTime: newUint64(0), CancunTime: newUint64(0), PragueTime: nil, @@ -343,6 +379,8 @@ CancunTime *uint64 `json:"cancunTime,omitempty"` // Cancun switch time (nil = no fork, 0 = already on cancun) PragueTime *uint64 `json:"pragueTime,omitempty"` // Prague switch time (nil = no fork, 0 = already on prague) VerkleTime *uint64 `json:"verkleTime,omitempty"` // Verkle switch time (nil = no fork, 0 = already on verkle)   + // Note that the bedrock block is also the first block of the celo L2, because it must be set for the celo l2 to + // function correctly and it can't be set before we migrate to the L2. BedrockBlock *big.Int `json:"bedrockBlock,omitempty"` // Bedrock switch block (nil = no fork, 0 = already on optimism bedrock) RegolithTime *uint64 `json:"regolithTime,omitempty"` // Regolith switch time (nil = no fork, 0 = already on optimism regolith) CanyonTime *uint64 `json:"canyonTime,omitempty"` // Canyon switch time (nil = no fork, 0 = already on optimism canyon) @@ -354,6 +392,9 @@ HoloceneTime *uint64 `json:"holoceneTime,omitempty"` // Holocene switch time (nil = no fork, 0 = already on Optimism Holocene)   InteropTime *uint64 `json:"interopTime,omitempty"` // Interop switch time (nil = no fork, 0 = already on optimism interop)   + Cel2Time *uint64 `json:"cel2Time,omitempty"` // Cel2 switch time (nil = no fork, 0 = already on optimism cel2) + GingerbreadBlock *big.Int `json:"gingerbreadBlock,omitempty"` // Gingerbread switch block (nil = no fork, 0 = already activated) + // TerminalTotalDifficulty is the amount of total difficulty reached by // the network that triggers the consensus upgrade. TerminalTotalDifficulty *big.Int `json:"terminalTotalDifficulty,omitempty"` @@ -373,6 +414,8 @@ Clique *CliqueConfig `json:"clique,omitempty"`   // Optimism config, nil if not active Optimism *OptimismConfig `json:"optimism,omitempty"` + // Celo config, nil if not active + Celo *CeloConfig `json:"celo,omitempty"` }   // EthashConfig is the consensus engine configs for proof-of-work based sealing. @@ -403,7 +446,21 @@ }   // String implements the stringer interface, returning the optimism fee config details. func (o *OptimismConfig) String() string { - return "optimism" + denominatorCanyonStr := "nil" + if o.EIP1559DenominatorCanyon != nil { + denominatorCanyonStr = fmt.Sprintf("%d", *o.EIP1559DenominatorCanyon) + } + return fmt.Sprintf("optimism(eip1559Elasticity: %d, eip1559Denominator: %d, eip1559DenominatorCanyon: %s)", + o.EIP1559Elasticity, o.EIP1559Denominator, denominatorCanyonStr) +} + +type CeloConfig struct { + EIP1559BaseFeeFloor uint64 `json:"eip1559BaseFeeFloor"` +} + +// String implements the stringer interface, returning the celo config details. +func (o *CeloConfig) String() string { + return fmt.Sprintf("celo(eip1559BaseFeeFloor: %d)", o.EIP1559BaseFeeFloor) }   // Description returns a human-readable description of ChainConfig. @@ -419,6 +476,8 @@ banner += fmt.Sprintf("Chain ID: %v (%s)\n", c.ChainID, network) switch { case c.Optimism != nil: banner += "Consensus: Optimism\n" + banner += fmt.Sprintf(" - %s\n", c.Optimism) + banner += fmt.Sprintf(" - %s\n", c.Celo) case c.Ethash != nil: if c.TerminalTotalDifficulty == nil { banner += "Consensus: Ethash (proof-of-work)\n" @@ -517,6 +576,9 @@ banner += fmt.Sprintf(" - Holocene: @%-10v\n", *c.HoloceneTime) } if c.InteropTime != nil { banner += fmt.Sprintf(" - Interop: @%-10v\n", *c.InteropTime) + } + if c.Cel2Time != nil { + banner += fmt.Sprintf(" - Cel2: @%-10v\n", *c.Cel2Time) } return banner } @@ -657,6 +719,15 @@ }   func (c *ChainConfig) IsInterop(time uint64) bool { return isTimestampForked(c.InteropTime, time) +} + +func (c *ChainConfig) IsCel2(time uint64) bool { + return isTimestampForked(c.Cel2Time, time) +} + +// IsGingerbread returns whether num represents a block number after the Gingerbread fork +func (c *ChainConfig) IsGingerbread(num *big.Int) bool { + return isBlockForked(c.GingerbreadBlock, num) }   // IsOptimism returns whether the node is an optimism node or not. @@ -1078,6 +1149,7 @@ IsVerkle bool IsOptimismBedrock, IsOptimismRegolith bool IsOptimismCanyon, IsOptimismFjord bool IsOptimismGranite, IsOptimismHolocene bool + IsCel2 bool }   // Rules ensures c's ChainID is not nil. @@ -1115,5 +1187,7 @@ IsOptimismCanyon: isMerge && c.IsOptimismCanyon(timestamp), IsOptimismFjord: isMerge && c.IsOptimismFjord(timestamp), IsOptimismGranite: isMerge && c.IsOptimismGranite(timestamp), IsOptimismHolocene: isMerge && c.IsOptimismHolocene(timestamp), + // Celo + IsCel2: c.IsCel2(timestamp), } }

diff --git op-geth/params/protocol_params.go Celo/params/protocol_params.go index 107a9fecfcb245c0c5f223ccc8ef0f9cb2e93ff8..16afc3b5ef147d9a768622447a59ae254c0948a3 100644 --- op-geth/params/protocol_params.go +++ Celo/params/protocol_params.go @@ -136,7 +136,7 @@ DefaultBaseFeeChangeDenominator = 8 // Bounds the amount the base fee can change between blocks. DefaultElasticityMultiplier = 2 // Bounds the maximum gas limit an EIP-1559 block may have. InitialBaseFee = 1000000000 // Initial base fee for EIP-1559 blocks.   - MaxCodeSize = 24576 // Maximum bytecode to permit for a contract + MaxCodeSize = 65536 // Maximum bytecode to permit for a contract MaxInitCodeSize = 2 * MaxCodeSize // Maximum initcode to permit in a creation transaction and create instructions   // Precompiled contract gas prices

diff --git op-geth/e2e_test/.gitignore Celo/e2e_test/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..d93e90bc6936c69f4976f29030cd041295ba09cb --- /dev/null +++ Celo/e2e_test/.gitignore @@ -0,0 +1,3 @@ +cache +out +geth.log

diff --git op-geth/e2e_test/debug-fee-currency/DebugFeeCurrency.sol Celo/e2e_test/debug-fee-currency/DebugFeeCurrency.sol new file mode 100644 index 0000000000000000000000000000000000000000..7f269dd5f20b56904ec98212b8ec93b212c0d83b --- /dev/null +++ Celo/e2e_test/debug-fee-currency/DebugFeeCurrency.sol @@ -0,0 +1,770 @@ +pragma solidity ^0.8.13; + +// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol) + +// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol) + +/** + * @dev Interface of the ERC20 standard as defined in the EIP. + */ +interface IERC20 { + /** + * @dev Emitted when `value` tokens are moved from one account (`from`) to + * another (`to`). + * + * Note that `value` may be zero. + */ + event Transfer(address indexed from, address indexed to, uint256 value); + + /** + * @dev Emitted when the allowance of a `spender` for an `owner` is set by + * a call to {approve}. `value` is the new allowance. + */ + event Approval(address indexed owner, address indexed spender, uint256 value); + + /** + * @dev Returns the value of tokens in existence. + */ + function totalSupply() external view returns (uint256); + + /** + * @dev Returns the value of tokens owned by `account`. + */ + function balanceOf(address account) external view returns (uint256); + + /** + * @dev Moves a `value` amount of tokens from the caller's account to `to`. + * + * Returns a boolean value indicating whether the operation succeeded. + * + * Emits a {Transfer} event. + */ + function transfer(address to, uint256 value) external returns (bool); + + /** + * @dev Returns the remaining number of tokens that `spender` will be + * allowed to spend on behalf of `owner` through {transferFrom}. This is + * zero by default. + * + * This value changes when {approve} or {transferFrom} are called. + */ + function allowance(address owner, address spender) external view returns (uint256); + + /** + * @dev Sets a `value` amount of tokens as the allowance of `spender` over the + * caller's tokens. + * + * Returns a boolean value indicating whether the operation succeeded. + * + * IMPORTANT: Beware that changing an allowance with this method brings the risk + * that someone may use both the old and the new allowance by unfortunate + * transaction ordering. One possible solution to mitigate this race + * condition is to first reduce the spender's allowance to 0 and set the + * desired value afterwards: + * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 + * + * Emits an {Approval} event. + */ + function approve(address spender, uint256 value) external returns (bool); + + /** + * @dev Moves a `value` amount of tokens from `from` to `to` using the + * allowance mechanism. `value` is then deducted from the caller's + * allowance. + * + * Returns a boolean value indicating whether the operation succeeded. + * + * Emits a {Transfer} event. + */ + function transferFrom(address from, address to, uint256 value) external returns (bool); +} + +// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol) + +/** + * @dev Interface for the optional metadata functions from the ERC20 standard. + */ +interface IERC20Metadata is IERC20 { + /** + * @dev Returns the name of the token. + */ + function name() external view returns (string memory); + + /** + * @dev Returns the symbol of the token. + */ + function symbol() external view returns (string memory); + + /** + * @dev Returns the decimals places of the token. + */ + function decimals() external view returns (uint8); +} + +// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol) + +/** + * @dev Provides information about the current execution context, including the + * sender of the transaction and its data. While these are generally available + * via msg.sender and msg.data, they should not be accessed in such a direct + * manner, since when dealing with meta-transactions the account sending and + * paying for execution may not be the actual sender (as far as an application + * is concerned). + * + * This contract is only required for intermediate, library-like contracts. + */ +abstract contract Context { + function _msgSender() internal view virtual returns (address) { + return msg.sender; + } + + function _msgData() internal view virtual returns (bytes calldata) { + return msg.data; + } + + function _contextSuffixLength() internal view virtual returns (uint256) { + return 0; + } +} + +// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol) + +/** + * @dev Standard ERC20 Errors + * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens. + */ +interface IERC20Errors { + /** + * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers. + * @param sender Address whose tokens are being transferred. + * @param balance Current balance for the interacting account. + * @param needed Minimum amount required to perform a transfer. + */ + error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed); + + /** + * @dev Indicates a failure with the token `sender`. Used in transfers. + * @param sender Address whose tokens are being transferred. + */ + error ERC20InvalidSender(address sender); + + /** + * @dev Indicates a failure with the token `receiver`. Used in transfers. + * @param receiver Address to which tokens are being transferred. + */ + error ERC20InvalidReceiver(address receiver); + + /** + * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers. + * @param spender Address that may be allowed to operate on tokens without being their owner. + * @param allowance Amount of tokens a `spender` is allowed to operate with. + * @param needed Minimum amount required to perform a transfer. + */ + error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed); + + /** + * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. + * @param approver Address initiating an approval operation. + */ + error ERC20InvalidApprover(address approver); + + /** + * @dev Indicates a failure with the `spender` to be approved. Used in approvals. + * @param spender Address that may be allowed to operate on tokens without being their owner. + */ + error ERC20InvalidSpender(address spender); +} + +/** + * @dev Standard ERC721 Errors + * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens. + */ +interface IERC721Errors { + /** + * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20. + * Used in balance queries. + * @param owner Address of the current owner of a token. + */ + error ERC721InvalidOwner(address owner); + + /** + * @dev Indicates a `tokenId` whose `owner` is the zero address. + * @param tokenId Identifier number of a token. + */ + error ERC721NonexistentToken(uint256 tokenId); + + /** + * @dev Indicates an error related to the ownership over a particular token. Used in transfers. + * @param sender Address whose tokens are being transferred. + * @param tokenId Identifier number of a token. + * @param owner Address of the current owner of a token. + */ + error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner); + + /** + * @dev Indicates a failure with the token `sender`. Used in transfers. + * @param sender Address whose tokens are being transferred. + */ + error ERC721InvalidSender(address sender); + + /** + * @dev Indicates a failure with the token `receiver`. Used in transfers. + * @param receiver Address to which tokens are being transferred. + */ + error ERC721InvalidReceiver(address receiver); + + /** + * @dev Indicates a failure with the `operator`’s approval. Used in transfers. + * @param operator Address that may be allowed to operate on tokens without being their owner. + * @param tokenId Identifier number of a token. + */ + error ERC721InsufficientApproval(address operator, uint256 tokenId); + + /** + * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. + * @param approver Address initiating an approval operation. + */ + error ERC721InvalidApprover(address approver); + + /** + * @dev Indicates a failure with the `operator` to be approved. Used in approvals. + * @param operator Address that may be allowed to operate on tokens without being their owner. + */ + error ERC721InvalidOperator(address operator); +} + +/** + * @dev Standard ERC1155 Errors + * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens. + */ +interface IERC1155Errors { + /** + * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers. + * @param sender Address whose tokens are being transferred. + * @param balance Current balance for the interacting account. + * @param needed Minimum amount required to perform a transfer. + * @param tokenId Identifier number of a token. + */ + error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId); + + /** + * @dev Indicates a failure with the token `sender`. Used in transfers. + * @param sender Address whose tokens are being transferred. + */ + error ERC1155InvalidSender(address sender); + + /** + * @dev Indicates a failure with the token `receiver`. Used in transfers. + * @param receiver Address to which tokens are being transferred. + */ + error ERC1155InvalidReceiver(address receiver); + + /** + * @dev Indicates a failure with the `operator`’s approval. Used in transfers. + * @param operator Address that may be allowed to operate on tokens without being their owner. + * @param owner Address of the current owner of a token. + */ + error ERC1155MissingApprovalForAll(address operator, address owner); + + /** + * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. + * @param approver Address initiating an approval operation. + */ + error ERC1155InvalidApprover(address approver); + + /** + * @dev Indicates a failure with the `operator` to be approved. Used in approvals. + * @param operator Address that may be allowed to operate on tokens without being their owner. + */ + error ERC1155InvalidOperator(address operator); + + /** + * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation. + * Used in batch transfers. + * @param idsLength Length of the array of token identifiers + * @param valuesLength Length of the array of token amounts + */ + error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength); +} + +/** + * @dev Implementation of the {IERC20} interface. + * + * This implementation is agnostic to the way tokens are created. This means + * that a supply mechanism has to be added in a derived contract using {_mint}. + * + * TIP: For a detailed writeup see our guide + * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How + * to implement supply mechanisms]. + * + * The default value of {decimals} is 18. To change this, you should override + * this function so it returns a different value. + * + * We have followed general OpenZeppelin Contracts guidelines: functions revert + * instead returning `false` on failure. This behavior is nonetheless + * conventional and does not conflict with the expectations of ERC20 + * applications. + * + * Additionally, an {Approval} event is emitted on calls to {transferFrom}. + * This allows applications to reconstruct the allowance for all accounts just + * by listening to said events. Other implementations of the EIP may not emit + * these events, as it isn't required by the specification. + */ +abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors { + mapping(address account => uint256) private _balances; + + mapping(address account => mapping(address spender => uint256)) private _allowances; + + uint256 private _totalSupply; + + string private _name; + string private _symbol; + + /** + * @dev Sets the values for {name} and {symbol}. + * + * All two of these values are immutable: they can only be set once during + * construction. + */ + constructor(string memory name_, string memory symbol_) { + _name = name_; + _symbol = symbol_; + } + + /** + * @dev Returns the name of the token. + */ + function name() public view virtual returns (string memory) { + return _name; + } + + /** + * @dev Returns the symbol of the token, usually a shorter version of the + * name. + */ + function symbol() public view virtual returns (string memory) { + return _symbol; + } + + /** + * @dev Returns the number of decimals used to get its user representation. + * For example, if `decimals` equals `2`, a balance of `505` tokens should + * be displayed to a user as `5.05` (`505 / 10 ** 2`). + * + * Tokens usually opt for a value of 18, imitating the relationship between + * Ether and Wei. This is the default value returned by this function, unless + * it's overridden. + * + * NOTE: This information is only used for _display_ purposes: it in + * no way affects any of the arithmetic of the contract, including + * {IERC20-balanceOf} and {IERC20-transfer}. + */ + function decimals() public view virtual returns (uint8) { + return 18; + } + + /** + * @dev See {IERC20-totalSupply}. + */ + function totalSupply() public view virtual returns (uint256) { + return _totalSupply; + } + + /** + * @dev See {IERC20-balanceOf}. + */ + function balanceOf(address account) public view virtual returns (uint256) { + return _balances[account]; + } + + /** + * @dev See {IERC20-transfer}. + * + * Requirements: + * + * - `to` cannot be the zero address. + * - the caller must have a balance of at least `value`. + */ + function transfer(address to, uint256 value) public virtual returns (bool) { + address owner = _msgSender(); + _transfer(owner, to, value); + return true; + } + + /** + * @dev See {IERC20-allowance}. + */ + function allowance(address owner, address spender) public view virtual returns (uint256) { + return _allowances[owner][spender]; + } + + /** + * @dev See {IERC20-approve}. + * + * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on + * `transferFrom`. This is semantically equivalent to an infinite approval. + * + * Requirements: + * + * - `spender` cannot be the zero address. + */ + function approve(address spender, uint256 value) public virtual returns (bool) { + address owner = _msgSender(); + _approve(owner, spender, value); + return true; + } + + /** + * @dev See {IERC20-transferFrom}. + * + * Emits an {Approval} event indicating the updated allowance. This is not + * required by the EIP. See the note at the beginning of {ERC20}. + * + * NOTE: Does not update the allowance if the current allowance + * is the maximum `uint256`. + * + * Requirements: + * + * - `from` and `to` cannot be the zero address. + * - `from` must have a balance of at least `value`. + * - the caller must have allowance for ``from``'s tokens of at least + * `value`. + */ + function transferFrom(address from, address to, uint256 value) public virtual returns (bool) { + address spender = _msgSender(); + _spendAllowance(from, spender, value); + _transfer(from, to, value); + return true; + } + + /** + * @dev Moves a `value` amount of tokens from `from` to `to`. + * + * This internal function is equivalent to {transfer}, and can be used to + * e.g. implement automatic token fees, slashing mechanisms, etc. + * + * Emits a {Transfer} event. + * + * NOTE: This function is not virtual, {_update} should be overridden instead. + */ + function _transfer(address from, address to, uint256 value) internal { + if (from == address(0)) { + revert ERC20InvalidSender(address(0)); + } + if (to == address(0)) { + revert ERC20InvalidReceiver(address(0)); + } + _update(from, to, value); + } + + /** + * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from` + * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding + * this function. + * + * Emits a {Transfer} event. + */ + function _update(address from, address to, uint256 value) internal virtual { + if (from == address(0)) { + // Overflow check required: The rest of the code assumes that totalSupply never overflows + _totalSupply += value; + } else { + uint256 fromBalance = _balances[from]; + if (fromBalance < value) { + revert ERC20InsufficientBalance(from, fromBalance, value); + } + unchecked { + // Overflow not possible: value <= fromBalance <= totalSupply. + _balances[from] = fromBalance - value; + } + } + + if (to == address(0)) { + unchecked { + // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply. + _totalSupply -= value; + } + } else { + unchecked { + // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256. + _balances[to] += value; + } + } + + emit Transfer(from, to, value); + } + + /** + * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0). + * Relies on the `_update` mechanism + * + * Emits a {Transfer} event with `from` set to the zero address. + * + * NOTE: This function is not virtual, {_update} should be overridden instead. + */ + function _mint(address account, uint256 value) internal { + if (account == address(0)) { + revert ERC20InvalidReceiver(address(0)); + } + _update(address(0), account, value); + } + + /** + * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply. + * Relies on the `_update` mechanism. + * + * Emits a {Transfer} event with `to` set to the zero address. + * + * NOTE: This function is not virtual, {_update} should be overridden instead + */ + function _burn(address account, uint256 value) internal { + if (account == address(0)) { + revert ERC20InvalidSender(address(0)); + } + _update(account, address(0), value); + } + + /** + * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens. + * + * This internal function is equivalent to `approve`, and can be used to + * e.g. set automatic allowances for certain subsystems, etc. + * + * Emits an {Approval} event. + * + * Requirements: + * + * - `owner` cannot be the zero address. + * - `spender` cannot be the zero address. + * + * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument. + */ + function _approve(address owner, address spender, uint256 value) internal { + _approve(owner, spender, value, true); + } + + /** + * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event. + * + * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by + * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any + * `Approval` event during `transferFrom` operations. + * + * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to + * true using the following override: + * ``` + * function _approve(address owner, address spender, uint256 value, bool) internal virtual override { + * super._approve(owner, spender, value, true); + * } + * ``` + * + * Requirements are the same as {_approve}. + */ + function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual { + if (owner == address(0)) { + revert ERC20InvalidApprover(address(0)); + } + if (spender == address(0)) { + revert ERC20InvalidSpender(address(0)); + } + _allowances[owner][spender] = value; + if (emitEvent) { + emit Approval(owner, spender, value); + } + } + + /** + * @dev Updates `owner` s allowance for `spender` based on spent `value`. + * + * Does not update the allowance value in case of infinite allowance. + * Revert if not enough allowance is available. + * + * Does not emit an {Approval} event. + */ + function _spendAllowance(address owner, address spender, uint256 value) internal virtual { + uint256 currentAllowance = allowance(owner, spender); + if (currentAllowance != type(uint256).max) { + if (currentAllowance < value) { + revert ERC20InsufficientAllowance(spender, currentAllowance, value); + } + unchecked { + _approve(owner, spender, currentAllowance - value, false); + } + } + } +} + +/** + * @notice This interface should be implemented for tokens which are supposed to + * act as fee currencies on the Celo blockchain, meaning that they can be + * used to pay gas fees for CIP-64 transactions (and some older tx types). + * See https://github.com/celo-org/celo-proposals/blob/master/CIPs/cip-0064.md + * + * @notice Before executing a tx with non-empty `feeCurrency` field, the fee + * currency's `debitGasFees` function is called to reserve the maximum + * amount of gas token that tx can spend. After the tx has been executed, the + * `creditGasFees` function is called to refund any unused gas and credit + * the spent fees to the appropriate recipients. Events which are emitted in + * these functions will show up for every tx using the token as a + * fee currency. + * + * @dev Requirements: + * - The functions will be called by the blockchain client with `msg.sender + * == address(0)`. If this condition is not met, the functions must + * revert to prevent malicious users from crediting their accounts directly. + * - `creditGasFees` must credit all specified amounts. If this is not + * possible the functions must revert to prevent inconsistencies between + * the debited and credited amounts. + * + * @dev Notes on compatibility: + * - There are two versions of `creditGasFees`: one for the current + * (2024-01-16) blockchain implementation and a more future-proof version + * that omits deprecated fields and accommodates potential new recipients + * that might become necessary on later blockchain implementations. Both + * versions should be implemented to increase compatibility. + */ +interface IFeeCurrency is IERC20 { + /// @notice Called before transaction execution to reserve the maximum amount of gas + /// that can be used by the transaction. + /// - The implementation must deduct `value` from `from`'s balance. + /// - Must revert if `msg.sender` is not the zero address. + function debitGasFees(address from, uint256 value) external; + + /// @notice New function signature, will be used when all fee currencies have migrated. + /// Credited amounts include gas refund, base fee and tip. Future additions + /// may include L1 gas fee when Celo becomes and L2. + /// - The implementation must increase each `recipient`'s balance by corresponding `amount`. + /// - Must revert if `msg.sender` is not the zero address. + /// - Must revert if `recipients` and `amounts` have different lengths. + function creditGasFees(address[] calldata recipients, uint256[] calldata amounts) external; + + /// @notice Old function signature for backwards compatibility + /// - Must revert if `msg.sender` is not the zero address. + /// - `refundAmount` must be credited to `refundRecipient` + /// - `tipAmount` must be credited to `tipRecipient` + /// - `baseFeeAmount` must be credited to `baseFeeRecipient` + /// - `_gatewayFeeRecipient` and `_gatewayFeeAmount` only exist for backwards + /// compatibility reasons and will always be zero. + function creditGasFees( + address refundRecipient, + address tipRecipient, + address _gatewayFeeRecipient, + address baseFeeRecipient, + uint256 refundAmount, + uint256 tipAmount, + uint256 _gatewayFeeAmount, + uint256 baseFeeAmount + ) external; +} + +contract FeeCurrency is ERC20, IFeeCurrency { + constructor(uint256 initialSupply) ERC20("ExampleFeeCurrency", "EFC") { + _mint(msg.sender, initialSupply); + } + + modifier onlyVm() { + require(msg.sender == address(0), "Only VM can call"); + _; + } + + function debitGasFees(address from, uint256 value) external onlyVm { + _burn(from, value); + } + + // New function signature, will be used when all fee currencies have migrated + function creditGasFees(address[] calldata recipients, uint256[] calldata amounts) public onlyVm { + require(recipients.length == amounts.length, "Recipients and amounts must be the same length."); + + for (uint256 i = 0; i < recipients.length; i++) { + _mint(recipients[i], amounts[i]); + } + } + + // Old function signature for backwards compatibility + function creditGasFees( + address from, + address feeRecipient, + address, // gatewayFeeRecipient, unused + address communityFund, + uint256 refund, + uint256 tipTxFee, + uint256, // gatewayFee, unused + uint256 baseTxFee + ) public onlyVm { + // Calling the new creditGasFees would make sense here, but that is not + // possible due to its calldata arguments. + _mint(from, refund); + _mint(feeRecipient, tipTxFee); + _mint(communityFund, baseTxFee); + } +} + +contract DebugFeeCurrency is ERC20, IFeeCurrency { + bool failOnDebit; + bool failOnCredit; + bool highGasOnCredit; + mapping(uint256 => uint256) private _dummyMap; + + constructor(uint256 initialSupply, bool _failOnDebit, bool _failOnCredit, bool _highGasOnCredit) ERC20("DebugFeeCurrency", "DFC") { + _mint(msg.sender, initialSupply); + failOnDebit = _failOnDebit; + failOnCredit = _failOnCredit; + highGasOnCredit = _highGasOnCredit; + } + + modifier onlyVm() { + require(msg.sender == address(0), "Only VM can call"); + _; + } + + function debitGasFees(address from, uint256 value) external onlyVm { + require(!failOnDebit, "This DebugFeeCurrency always fails in debitGasFees!"); + _burn(from, value); + } + + // New function signature, will be used when all fee currencies have migrated + function creditGasFees(address[] calldata recipients, uint256[] calldata amounts) public onlyVm { + require(!failOnCredit, "This DebugFeeCurrency always fails in (new) creditGasFees!"); + require(recipients.length == amounts.length, "Recipients and amounts must be the same length."); + + for (uint256 i = 0; i < recipients.length; i++) { + _mint(recipients[i], amounts[i]); + } + + if (highGasOnCredit){ + induceHighGasCost(); + } + } + + function induceHighGasCost() internal view { + // SLOAD for non existing touched_storage_slots + // 2100 * 3000 gas = 630.0000 + for (uint256 i = 0; i < 3000; i++) { + _dummyMap[i]; + } + } + + // Old function signature for backwards compatibility + function creditGasFees( + address from, + address feeRecipient, + address, // gatewayFeeRecipient, unused + address communityFund, + uint256 refund, + uint256 tipTxFee, + uint256, // gatewayFee, unused + uint256 baseTxFee + ) public onlyVm { + require(!failOnCredit, "This DebugFeeCurrency always fails in (old) creditGasFees!"); + // Calling the new creditGasFees would make sense here, but that is not + // possible due to its calldata arguments. + _mint(from, refund); + _mint(feeRecipient, tipTxFee); + _mint(communityFund, baseTxFee); + + if (highGasOnCredit){ + induceHighGasCost(); + } + } +} +

diff --git op-geth/e2e_test/debug-fee-currency/deploy_and_send_tx.sh Celo/e2e_test/debug-fee-currency/deploy_and_send_tx.sh new file mode 100755 index 0000000000000000000000000000000000000000..258b3b013c19dfab84dcc239d9b7bf0cf256f402 --- /dev/null +++ Celo/e2e_test/debug-fee-currency/deploy_and_send_tx.sh @@ -0,0 +1,8 @@ +#!/bin/bash +#shellcheck disable=SC2034,SC2155,SC2086 +set -xeo pipefail + +source ./lib.sh + +fee_currency=$(deploy_fee_currency $1 $2 $3) +cip_64_tx $fee_currency

diff --git op-geth/e2e_test/debug-fee-currency/lib.sh Celo/e2e_test/debug-fee-currency/lib.sh new file mode 100755 index 0000000000000000000000000000000000000000..a7077c774e4976801a07ce7e0efd4b17ede0dce9 --- /dev/null +++ Celo/e2e_test/debug-fee-currency/lib.sh @@ -0,0 +1,78 @@ +#!/bin/bash +#shellcheck disable=SC2034,SC2155,SC2086 +set -xeo pipefail + +# args: +# $1: failOnDebit (bool): +# if true, this will make the DebugFeeCurrenc.DebitFees() call fail with a revert +# $2: failOnCredit (bool) +# if true, this will make the DebugFeeCurrenc.CreditFees() call fail with a revert +# $3: highGasOnCredit (bool) +# if true, this will make the DebugFeeCurrenc.CreditFees() call use +# a high amount of gas +# returns: +# deployed fee-currency address +function deploy_fee_currency() { + ( + local fee_currency=$( + forge create --root "$SCRIPT_DIR/debug-fee-currency" --contracts "$SCRIPT_DIR/debug-fee-currency" --private-key $ACC_PRIVKEY DebugFeeCurrency.sol:DebugFeeCurrency --constructor-args '100000000000000000000000000' $1 $2 $3 --json | jq .deployedTo -r + ) + if [ -z "${fee_currency}" ]; then + exit 1 + fi + # this always resets the token address for the predeployed oracle3 + cast send --private-key $ACC_PRIVKEY $ORACLE3 'setExchangeRate(address, uint256, uint256)' $fee_currency 2ether 1ether > /dev/null + cast send --private-key $ACC_PRIVKEY $FEE_CURRENCY_DIRECTORY_ADDR 'setCurrencyConfig(address, address, uint256)' $fee_currency $ORACLE3 60000 > /dev/null + echo "$fee_currency" + ) +} + +# args: +# $1: feeCurrency (address): +# deployed fee-currency address to be cleaned up +function cleanup_fee_currency() { + ( + local fee_currency=$1 + # HACK: this uses a static index 2, which relies on the fact that all non-predeployed currencies will be always cleaned up + # from the directory and the list never has more than 3 elements. Once there is the need for more dynamic removal we + # can parse the following call and find the index ourselves: + # local currencies=$(cast call "$FEE_CURRENCY_DIRECTORY_ADDR" 'getCurrencies() (address[] memory)') + cast send --private-key $ACC_PRIVKEY $FEE_CURRENCY_DIRECTORY_ADDR 'removeCurrencies(address, uint256)' $fee_currency 2 --json | jq 'if .status == "0x1" then 0 else 1 end' -r + ) +} + +# args: +# $1: feeCurrencyAddress (string): +# which fee-currency address to use for the default CIP-64 transaction +# $2: waitBlocks (num): +# how many blocks to wait until the lack of a receipt is considered a failure +# $3: replaceTransaction (bool): +# replace the transaction with a transaction of higher priority-fee when +# there is no receipt after the `waitBlocks` time passed +# $4: value (num): +# value to send in the transaction +function cip_64_tx() { + $SCRIPT_DIR/js-tests/send_tx.mjs "$(cast chain-id)" $ACC_PRIVKEY $1 $2 $3 $4 +} + +# use this function to assert the cip_64_tx return value, by using a pipe like +# `cip_64_tx "$fee-currency" | assert_cip_64_tx true` +# +# args: +# $1: success (string): +# expected success value, "true" for when the cip-64 tx should have succeeded, "false" if not +# $2: error-regex (string): +# expected RPC return-error value regex to grep for, use "null", "" or unset value if no error is assumed. +function assert_cip_64_tx() { + local value + read -r value + local expected_error="$2" + + if [ "$(echo "$value" | jq .success)" != "$1" ]; then + exit 1 + fi + if [ -z "$expected_error" ]; then + expected_error="null" + fi + echo "$value" | jq .error | grep -qE "$expected_error" +}

diff --git op-geth/e2e_test/js-tests/Makefile Celo/e2e_test/js-tests/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..69555e594b4419c7c012ddc56d5403d88f4cd142 --- /dev/null +++ Celo/e2e_test/js-tests/Makefile @@ -0,0 +1,2 @@ +format: + npx @biomejs/biome format --write .

diff --git op-geth/e2e_test/js-tests/package-lock.json Celo/e2e_test/js-tests/package-lock.json new file mode 100644 index 0000000000000000000000000000000000000000..6c7d7ab2e55228f86c952d6804c40abe28fdb456 --- /dev/null +++ Celo/e2e_test/js-tests/package-lock.json @@ -0,0 +1,1232 @@ +{ + "name": "js-tests", + "version": "1.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "js-tests", + "version": "1.0.0", + "license": "MIT", + "dependencies": { + "chai": "^5.1.2", + "ethers": "^6.10.0", + "mocha": "^10.2.0", + "viem": "^2.21.18" + } + }, + "node_modules/@adraffy/ens-normalize": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/@adraffy/ens-normalize/-/ens-normalize-1.10.0.tgz", + "integrity": "sha512-nA9XHtlAkYfJxY7bce8DcN7eKxWWCWkU+1GR9d+U6MbNpfwQp8TI7vqOsBsMcHoT4mBu2kypKoSKnghEzOOq5Q==" + }, + "node_modules/@noble/curves": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@noble/curves/-/curves-1.2.0.tgz", + "integrity": "sha512-oYclrNgRaM9SsBUBVbb8M6DTV7ZHRTKugureoYEncY5c65HOmRzvSiTE3y5CYaPYJA/GVkrhXEoF0M3Ya9PMnw==", + "dependencies": { + "@noble/hashes": "1.3.2" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/@noble/hashes": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.3.2.tgz", + "integrity": "sha512-MVC8EAQp7MvEcm30KWENFjgR+Mkmf+D189XJTkFIlwohU5hcBbn1ZkKq7KVTi2Hme3PMGF390DaL52beVrIihQ==", + "engines": { + "node": ">= 16" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/@scure/base": { + "version": "1.1.9", + "resolved": "https://registry.npmjs.org/@scure/base/-/base-1.1.9.tgz", + "integrity": "sha512-8YKhl8GHiNI/pU2VMaofa2Tor7PJRAjwQLBBuilkJ9L5+13yVbC7JO/wS7piioAvPSwR3JKM1IJ/u4xQzbcXKg==", + "license": "MIT", + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/@scure/bip32": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/@scure/bip32/-/bip32-1.5.0.tgz", + "integrity": "sha512-8EnFYkqEQdnkuGBVpCzKxyIwDCBLDVj3oiX0EKUFre/tOjL/Hqba1D6n/8RcmaQy4f95qQFrO2A8Sr6ybh4NRw==", + "license": "MIT", + "dependencies": { + "@noble/curves": "~1.6.0", + "@noble/hashes": "~1.5.0", + "@scure/base": "~1.1.7" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/@scure/bip32/node_modules/@noble/curves": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/@noble/curves/-/curves-1.6.0.tgz", + "integrity": "sha512-TlaHRXDehJuRNR9TfZDNQ45mMEd5dwUwmicsafcIX4SsNiqnCHKjE/1alYPd/lDRVhxdhUAlv8uEhMCI5zjIJQ==", + "license": "MIT", + "dependencies": { + "@noble/hashes": "1.5.0" + }, + "engines": { + "node": "^14.21.3 || >=16" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/@scure/bip32/node_modules/@noble/hashes": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.5.0.tgz", + "integrity": "sha512-1j6kQFb7QRru7eKN3ZDvRcP13rugwdxZqCjbiAVZfIJwgj2A65UmT4TgARXGlXgnRkORLTDTrO19ZErt7+QXgA==", + "license": "MIT", + "engines": { + "node": "^14.21.3 || >=16" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/@scure/bip39": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/@scure/bip39/-/bip39-1.4.0.tgz", + "integrity": "sha512-BEEm6p8IueV/ZTfQLp/0vhw4NPnT9oWf5+28nvmeUICjP99f4vr2d+qc7AVGDDtwRep6ifR43Yed9ERVmiITzw==", + "license": "MIT", + "dependencies": { + "@noble/hashes": "~1.5.0", + "@scure/base": "~1.1.8" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/@scure/bip39/node_modules/@noble/hashes": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.5.0.tgz", + "integrity": "sha512-1j6kQFb7QRru7eKN3ZDvRcP13rugwdxZqCjbiAVZfIJwgj2A65UmT4TgARXGlXgnRkORLTDTrO19ZErt7+QXgA==", + "license": "MIT", + "engines": { + "node": "^14.21.3 || >=16" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/@types/node": { + "version": "18.15.13", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.15.13.tgz", + "integrity": "sha512-N+0kuo9KgrUQ1Sn/ifDXsvg0TTleP7rIy4zOBGECxAljqvqfqpTfzx0Q1NUedOixRMBfe2Whhb056a42cWs26Q==" + }, + "node_modules/abitype": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/abitype/-/abitype-1.0.6.tgz", + "integrity": "sha512-MMSqYh4+C/aVqI2RQaWqbvI4Kxo5cQV40WQ4QFtDnNzCkqChm8MuENhElmynZlO0qUy/ObkEUaXtKqYnx1Kp3A==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/wevm" + }, + "peerDependencies": { + "typescript": ">=5.0.4", + "zod": "^3 >=3.22.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + }, + "zod": { + "optional": true + } + } + }, + "node_modules/aes-js": { + "version": "4.0.0-beta.5", + "resolved": "https://registry.npmjs.org/aes-js/-/aes-js-4.0.0-beta.5.tgz", + "integrity": "sha512-G965FqalsNyrPqgEGON7nIx1e/OVENSgiEIzyC63haUMuvNnwIgIjMs52hlTCKhkBny7A2ORNlfY9Zu+jmGk1Q==" + }, + "node_modules/ansi-colors": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.1.tgz", + "integrity": "sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==", + "engines": { + "node": ">=6" + } + }, + "node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/anymatch": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", + "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", + "dependencies": { + "normalize-path": "^3.0.0", + "picomatch": "^2.0.4" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==" + }, + "node_modules/assertion-error": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz", + "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==", + "engines": { + "node": ">=12" + } + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==" + }, + "node_modules/binary-extensions": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz", + "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==", + "engines": { + "node": ">=8" + } + }, + "node_modules/brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/braces": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", + "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", + "dependencies": { + "fill-range": "^7.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/browser-stdout": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz", + "integrity": "sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==" + }, + "node_modules/camelcase": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz", + "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/chai": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/chai/-/chai-5.1.2.tgz", + "integrity": "sha512-aGtmf24DW6MLHHG5gCx4zaI3uBq3KRtxeVs0DjFH6Z0rDNbsvTxFASFvdj79pxjxZ8/5u3PIiN3IwEIQkiiuPw==", + "dependencies": { + "assertion-error": "^2.0.1", + "check-error": "^2.1.1", + "deep-eql": "^5.0.1", + "loupe": "^3.1.0", + "pathval": "^2.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/chalk/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/check-error": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.1.tgz", + "integrity": "sha512-OAlb+T7V4Op9OwdkjmguYRqncdlx5JiofwOAUkmTF+jNdHwzTaTs4sRAGpzLF3oOz5xAyDGrPgeIDFQmDOTiJw==", + "engines": { + "node": ">= 16" + } + }, + "node_modules/chokidar": { + "version": "3.5.3", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz", + "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "dependencies": { + "anymatch": "~3.1.2", + "braces": "~3.0.2", + "glob-parent": "~5.1.2", + "is-binary-path": "~2.1.0", + "is-glob": "~4.0.1", + "normalize-path": "~3.0.0", + "readdirp": "~3.6.0" + }, + "engines": { + "node": ">= 8.10.0" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + } + }, + "node_modules/cliui": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz", + "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==", + "dependencies": { + "string-width": "^4.2.0", + "strip-ansi": "^6.0.0", + "wrap-ansi": "^7.0.0" + } + }, + "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==" + }, + "node_modules/debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "dependencies": { + "ms": "2.1.2" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/debug/node_modules/ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" + }, + "node_modules/decamelize": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-4.0.0.tgz", + "integrity": "sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/deep-eql": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.1.tgz", + "integrity": "sha512-nwQCf6ne2gez3o1MxWifqkciwt0zhl0LO1/UwVu4uMBuPmflWM4oQ70XMqHqnBJA+nhzncaqL9HVL6KkHJ28lw==", + "engines": { + "node": ">=6" + } + }, + "node_modules/diff": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/diff/-/diff-5.0.0.tgz", + "integrity": "sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w==", + "engines": { + "node": ">=0.3.1" + } + }, + "node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==" + }, + "node_modules/escalade": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", + "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==", + "engines": { + "node": ">=6" + } + }, + "node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/ethers": { + "version": "6.10.0", + "resolved": "https://registry.npmjs.org/ethers/-/ethers-6.10.0.tgz", + "integrity": "sha512-nMNwYHzs6V1FR3Y4cdfxSQmNgZsRj1RiTU25JwvnJLmyzw9z3SKxNc2XKDuiXXo/v9ds5Mp9m6HBabgYQQ26tA==", + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/ethers-io/" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@adraffy/ens-normalize": "1.10.0", + "@noble/curves": "1.2.0", + "@noble/hashes": "1.3.2", + "@types/node": "18.15.13", + "aes-js": "4.0.0-beta.5", + "tslib": "2.4.0", + "ws": "8.5.0" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/fill-range": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", + "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/flat": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz", + "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==", + "bin": { + "flat": "cli.js" + } + }, + "node_modules/fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==" + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "hasInstallScript": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/get-caller-file": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "engines": { + "node": "6.* || 8.* || >= 10.*" + } + }, + "node_modules/get-func-name": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/get-func-name/-/get-func-name-2.0.2.tgz", + "integrity": "sha512-8vXOvuE167CtIc3OyItco7N/dpRtBbYOsPsXCz7X/PMnlGjYjSGuZJgM1Y7mmew7BKf9BqvLX2tnOVy1BBUsxQ==", + "engines": { + "node": "*" + } + }, + "node_modules/glob": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz", + "integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/glob/node_modules/brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/glob/node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/he": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz", + "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==", + "bin": { + "he": "bin/he" + } + }, + "node_modules/inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "dependencies": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==" + }, + "node_modules/is-binary-path": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", + "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", + "dependencies": { + "binary-extensions": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/is-plain-obj": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz", + "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-unicode-supported": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz", + "integrity": "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/isows": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/isows/-/isows-1.0.6.tgz", + "integrity": "sha512-lPHCayd40oW98/I0uvgaHKWCSvkzY27LjWLbtzOm64yQ+G3Q5npjjbdppU65iZXkK1Zt+kH9pfegli0AYfwYYw==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/wevm" + } + ], + "license": "MIT", + "peerDependencies": { + "ws": "*" + } + }, + "node_modules/js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/log-symbols": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz", + "integrity": "sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==", + "dependencies": { + "chalk": "^4.1.0", + "is-unicode-supported": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/loupe": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.1.0.tgz", + "integrity": "sha512-qKl+FrLXUhFuHUoDJG7f8P8gEMHq9NFS0c6ghXG1J0rldmZFQZoNVv/vyirE9qwCIhWZDsvEFd1sbFu3GvRQFg==", + "dependencies": { + "get-func-name": "^2.0.1" + } + }, + "node_modules/minimatch": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.0.1.tgz", + "integrity": "sha512-nLDxIFRyhDblz3qMuq+SoRZED4+miJ/G+tdDrjkkkRnjAsBexeGpgjLEQ0blJy7rHhR2b93rhQY4SvyWu9v03g==", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/mocha": { + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/mocha/-/mocha-10.2.0.tgz", + "integrity": "sha512-IDY7fl/BecMwFHzoqF2sg/SHHANeBoMMXFlS9r0OXKDssYE1M5O43wUY/9BVPeIvfH2zmEbBfseqN9gBQZzXkg==", + "dependencies": { + "ansi-colors": "4.1.1", + "browser-stdout": "1.3.1", + "chokidar": "3.5.3", + "debug": "4.3.4", + "diff": "5.0.0", + "escape-string-regexp": "4.0.0", + "find-up": "5.0.0", + "glob": "7.2.0", + "he": "1.2.0", + "js-yaml": "4.1.0", + "log-symbols": "4.1.0", + "minimatch": "5.0.1", + "ms": "2.1.3", + "nanoid": "3.3.3", + "serialize-javascript": "6.0.0", + "strip-json-comments": "3.1.1", + "supports-color": "8.1.1", + "workerpool": "6.2.1", + "yargs": "16.2.0", + "yargs-parser": "20.2.4", + "yargs-unparser": "2.0.0" + }, + "bin": { + "_mocha": "bin/_mocha", + "mocha": "bin/mocha.js" + }, + "engines": { + "node": ">= 14.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/mochajs" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==" + }, + "node_modules/nanoid": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.3.tgz", + "integrity": "sha512-p1sjXuopFs0xg+fPASzQ28agW1oHD7xDsd9Xkf3T15H3c/cifrFHVwrh74PdoklAPi+i7MdRsE47vm2r6JoB+w==", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/normalize-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", + "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/pathval": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.0.tgz", + "integrity": "sha512-vE7JKRyES09KiunauX7nd2Q9/L7lhok4smP9RZTDeD4MVs72Dp2qNFVz39Nz5a0FVEW0BJR6C0DYrq6unoziZA==", + "engines": { + "node": ">= 14.16" + } + }, + "node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/randombytes": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz", + "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==", + "dependencies": { + "safe-buffer": "^5.1.0" + } + }, + "node_modules/readdirp": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", + "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", + "dependencies": { + "picomatch": "^2.2.1" + }, + "engines": { + "node": ">=8.10.0" + } + }, + "node_modules/require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/serialize-javascript": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.0.tgz", + "integrity": "sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==", + "dependencies": { + "randombytes": "^2.1.0" + } + }, + "node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/supports-color": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/supports-color?sponsor=1" + } + }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/tslib": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.4.0.tgz", + "integrity": "sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ==" + }, + "node_modules/viem": { + "version": "2.21.27", + "resolved": "https://registry.npmjs.org/viem/-/viem-2.21.27.tgz", + "integrity": "sha512-lBpldSmwmKZ8jIiVLqoplPnuMs2Cza8tK0/G9m+ZjqfbgEp4+BPviFBJWCDNFxSp8H3gPzAuqj8o1WKQyq3wlg==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/wevm" + } + ], + "license": "MIT", + "dependencies": { + "@adraffy/ens-normalize": "1.11.0", + "@noble/curves": "1.6.0", + "@noble/hashes": "1.5.0", + "@scure/bip32": "1.5.0", + "@scure/bip39": "1.4.0", + "abitype": "1.0.6", + "isows": "1.0.6", + "webauthn-p256": "0.0.10", + "ws": "8.18.0" + }, + "peerDependencies": { + "typescript": ">=5.0.4" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/viem/node_modules/@adraffy/ens-normalize": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/@adraffy/ens-normalize/-/ens-normalize-1.11.0.tgz", + "integrity": "sha512-/3DDPKHqqIqxUULp8yP4zODUY1i+2xvVWsv8A79xGWdCAG+8sb0hRh0Rk2QyOJUnnbyPUAZYcpBuRe3nS2OIUg==", + "license": "MIT" + }, + "node_modules/viem/node_modules/@noble/curves": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/@noble/curves/-/curves-1.6.0.tgz", + "integrity": "sha512-TlaHRXDehJuRNR9TfZDNQ45mMEd5dwUwmicsafcIX4SsNiqnCHKjE/1alYPd/lDRVhxdhUAlv8uEhMCI5zjIJQ==", + "license": "MIT", + "dependencies": { + "@noble/hashes": "1.5.0" + }, + "engines": { + "node": "^14.21.3 || >=16" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/viem/node_modules/@noble/hashes": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.5.0.tgz", + "integrity": "sha512-1j6kQFb7QRru7eKN3ZDvRcP13rugwdxZqCjbiAVZfIJwgj2A65UmT4TgARXGlXgnRkORLTDTrO19ZErt7+QXgA==", + "license": "MIT", + "engines": { + "node": "^14.21.3 || >=16" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/viem/node_modules/ws": { + "version": "8.18.0", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.0.tgz", + "integrity": "sha512-8VbfWfHLbbwu3+N6OKsOMpBdT4kXPDDB9cJk2bJ6mh9ucxdlnNvH1e+roYkKmN9Nxw2yjz7VzeO9oOz2zJ04Pw==", + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/webauthn-p256": { + "version": "0.0.10", + "resolved": "https://registry.npmjs.org/webauthn-p256/-/webauthn-p256-0.0.10.tgz", + "integrity": "sha512-EeYD+gmIT80YkSIDb2iWq0lq2zbHo1CxHlQTeJ+KkCILWpVy3zASH3ByD4bopzfk0uCwXxLqKGLqp2W4O28VFA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/wevm" + } + ], + "license": "MIT", + "dependencies": { + "@noble/curves": "^1.4.0", + "@noble/hashes": "^1.4.0" + } + }, + "node_modules/webauthn-p256/node_modules/@noble/curves": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/@noble/curves/-/curves-1.6.0.tgz", + "integrity": "sha512-TlaHRXDehJuRNR9TfZDNQ45mMEd5dwUwmicsafcIX4SsNiqnCHKjE/1alYPd/lDRVhxdhUAlv8uEhMCI5zjIJQ==", + "license": "MIT", + "dependencies": { + "@noble/hashes": "1.5.0" + }, + "engines": { + "node": "^14.21.3 || >=16" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/webauthn-p256/node_modules/@noble/hashes": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.5.0.tgz", + "integrity": "sha512-1j6kQFb7QRru7eKN3ZDvRcP13rugwdxZqCjbiAVZfIJwgj2A65UmT4TgARXGlXgnRkORLTDTrO19ZErt7+QXgA==", + "license": "MIT", + "engines": { + "node": "^14.21.3 || >=16" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/workerpool": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.2.1.tgz", + "integrity": "sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw==" + }, + "node_modules/wrap-ansi": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==" + }, + "node_modules/ws": { + "version": "8.5.0", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.5.0.tgz", + "integrity": "sha512-BWX0SWVgLPzYwF8lTzEy1egjhS4S4OEAHfsO8o65WOVsrnSRGaSiUaa9e0ggGlkMTtBlmOpEXiie9RUcBO86qg==", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": "^5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/y18n": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", + "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", + "engines": { + "node": ">=10" + } + }, + "node_modules/yargs": { + "version": "16.2.0", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz", + "integrity": "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==", + "dependencies": { + "cliui": "^7.0.2", + "escalade": "^3.1.1", + "get-caller-file": "^2.0.5", + "require-directory": "^2.1.1", + "string-width": "^4.2.0", + "y18n": "^5.0.5", + "yargs-parser": "^20.2.2" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/yargs-parser": { + "version": "20.2.4", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.4.tgz", + "integrity": "sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA==", + "engines": { + "node": ">=10" + } + }, + "node_modules/yargs-unparser": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-2.0.0.tgz", + "integrity": "sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==", + "dependencies": { + "camelcase": "^6.0.0", + "decamelize": "^4.0.0", + "flat": "^5.0.2", + "is-plain-obj": "^2.1.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + } + } +}