From 1ff3a5554b8a13048f9029822bd7867d05f6ea98 Mon Sep 17 00:00:00 2001 From: Geoff Stuart Date: Fri, 16 Dec 2022 16:35:43 -0500 Subject: [PATCH] Fixes --- .circleci/config.yml | 14 +- api/api_full.go | 2 +- api/docgen/docgen.go | 12 +- api/mocks/mock_full.go | 32 +-- api/proxy_gen.go | 280 ++++++++++---------- build/openrpc/full.json.gz | Bin 32167 -> 32232 bytes chain/types/ethtypes/eth_types.go | 19 +- chain/types/message_receipt.go | 2 +- cli/chain.go | 3 + documentation/en/api-v1-unstable-methods.md | 1 + extern/filecoin-ffi | 2 +- itests/eth_filter_test.go | 86 +++--- 12 files changed, 221 insertions(+), 232 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index ce4a4f3bb33..5b3a56c7c03 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -764,21 +764,21 @@ workflows: suite: itest-dup_mpool_messages target: "./itests/dup_mpool_messages_test.go" + - test: + name: test-itest-eth_account_abstraction + suite: itest-eth_account_abstraction + target: "./itests/eth_account_abstraction_test.go" + - test: name: test-itest-eth_filter suite: itest-eth_filter target: "./itests/eth_filter_test.go" - + - test: name: test-itest-fevm_events suite: itest-fevm_events target: "./itests/fevm_events_test.go" - - - test: - name: test-itest-eth_account_abstraction - suite: itest-eth_account_abstraction - target: "./itests/eth_account_abstraction_test.go" - + - test: name: test-itest-fevm suite: itest-fevm diff --git a/api/api_full.go b/api/api_full.go index 409f617f9da..3d4812a2fcb 100644 --- a/api/api_full.go +++ b/api/api_full.go @@ -1344,6 +1344,6 @@ type EthTxReceipt struct { GasUsed ethtypes.EthUint64 `json:"gasUsed"` EffectiveGasPrice ethtypes.EthBigInt `json:"effectiveGasPrice"` LogsBloom ethtypes.EthBytes `json:"logsBloom"` - Logs []string `json:"logs"` + Logs []ethtypes.EthLog `json:"logs"` Type ethtypes.EthUint64 `json:"type"` } diff --git a/api/docgen/docgen.go b/api/docgen/docgen.go index 755dee1f8ec..cb20015d65d 100644 --- a/api/docgen/docgen.go +++ b/api/docgen/docgen.go @@ -387,16 +387,16 @@ func init() { addExample(&uuid.UUID{}) - filterid, _ := api.EthHashFromHex("0x5CbEeC012345673f25E309Cc264f240bb0664031") - addExample(api.EthFilterID(filterid)) + filterid, _ := ethtypes.EthHashFromHex("0x5CbEeC012345673f25E309Cc264f240bb0664031") + addExample(ethtypes.EthFilterID(filterid)) - subid, _ := api.EthHashFromHex("0x5CbEeCF99d3fDB301234567c264f240bb0664031") - addExample(api.EthSubscriptionID(subid)) + subid, _ := ethtypes.EthHashFromHex("0x5CbEeCF99d3fDB301234567c264f240bb0664031") + addExample(ethtypes.EthSubscriptionID(subid)) pstring := func(s string) *string { return &s } - addExample(&api.EthFilterSpec{ + addExample(ðtypes.EthFilterSpec{ FromBlock: pstring("2301220"), - Address: []api.EthAddress{ethaddr}, + Address: []ethtypes.EthAddress{ethaddr}, }) } diff --git a/api/mocks/mock_full.go b/api/mocks/mock_full.go index ad8540bdf66..10ff250e6da 100644 --- a/api/mocks/mock_full.go +++ b/api/mocks/mock_full.go @@ -1133,10 +1133,10 @@ func (mr *MockFullNodeMockRecorder) EthGetCode(arg0, arg1, arg2 interface{}) *go } // EthGetFilterChanges mocks base method. -func (m *MockFullNode) EthGetFilterChanges(arg0 context.Context, arg1 api.EthFilterID) (*api.EthFilterResult, error) { +func (m *MockFullNode) EthGetFilterChanges(arg0 context.Context, arg1 ethtypes.EthFilterID) (*ethtypes.EthFilterResult, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "EthGetFilterChanges", arg0, arg1) - ret0, _ := ret[0].(*api.EthFilterResult) + ret0, _ := ret[0].(*ethtypes.EthFilterResult) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1148,10 +1148,10 @@ func (mr *MockFullNodeMockRecorder) EthGetFilterChanges(arg0, arg1 interface{}) } // EthGetFilterLogs mocks base method. -func (m *MockFullNode) EthGetFilterLogs(arg0 context.Context, arg1 api.EthFilterID) (*api.EthFilterResult, error) { +func (m *MockFullNode) EthGetFilterLogs(arg0 context.Context, arg1 ethtypes.EthFilterID) (*ethtypes.EthFilterResult, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "EthGetFilterLogs", arg0, arg1) - ret0, _ := ret[0].(*api.EthFilterResult) + ret0, _ := ret[0].(*ethtypes.EthFilterResult) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1163,10 +1163,10 @@ func (mr *MockFullNodeMockRecorder) EthGetFilterLogs(arg0, arg1 interface{}) *go } // EthGetLogs mocks base method. -func (m *MockFullNode) EthGetLogs(arg0 context.Context, arg1 *api.EthFilterSpec) (*api.EthFilterResult, error) { +func (m *MockFullNode) EthGetLogs(arg0 context.Context, arg1 *ethtypes.EthFilterSpec) (*ethtypes.EthFilterResult, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "EthGetLogs", arg0, arg1) - ret0, _ := ret[0].(*api.EthFilterResult) + ret0, _ := ret[0].(*ethtypes.EthFilterResult) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1283,10 +1283,10 @@ func (mr *MockFullNodeMockRecorder) EthMaxPriorityFeePerGas(arg0 interface{}) *g } // EthNewBlockFilter mocks base method. -func (m *MockFullNode) EthNewBlockFilter(arg0 context.Context) (api.EthFilterID, error) { +func (m *MockFullNode) EthNewBlockFilter(arg0 context.Context) (ethtypes.EthFilterID, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "EthNewBlockFilter", arg0) - ret0, _ := ret[0].(api.EthFilterID) + ret0, _ := ret[0].(ethtypes.EthFilterID) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1298,10 +1298,10 @@ func (mr *MockFullNodeMockRecorder) EthNewBlockFilter(arg0 interface{}) *gomock. } // EthNewFilter mocks base method. -func (m *MockFullNode) EthNewFilter(arg0 context.Context, arg1 *api.EthFilterSpec) (api.EthFilterID, error) { +func (m *MockFullNode) EthNewFilter(arg0 context.Context, arg1 *ethtypes.EthFilterSpec) (ethtypes.EthFilterID, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "EthNewFilter", arg0, arg1) - ret0, _ := ret[0].(api.EthFilterID) + ret0, _ := ret[0].(ethtypes.EthFilterID) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1313,10 +1313,10 @@ func (mr *MockFullNodeMockRecorder) EthNewFilter(arg0, arg1 interface{}) *gomock } // EthNewPendingTransactionFilter mocks base method. -func (m *MockFullNode) EthNewPendingTransactionFilter(arg0 context.Context) (api.EthFilterID, error) { +func (m *MockFullNode) EthNewPendingTransactionFilter(arg0 context.Context) (ethtypes.EthFilterID, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "EthNewPendingTransactionFilter", arg0) - ret0, _ := ret[0].(api.EthFilterID) + ret0, _ := ret[0].(ethtypes.EthFilterID) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1358,10 +1358,10 @@ func (mr *MockFullNodeMockRecorder) EthSendRawTransaction(arg0, arg1 interface{} } // EthSubscribe mocks base method. -func (m *MockFullNode) EthSubscribe(arg0 context.Context, arg1 string, arg2 *api.EthSubscriptionParams) (<-chan api.EthSubscriptionResponse, error) { +func (m *MockFullNode) EthSubscribe(arg0 context.Context, arg1 string, arg2 *ethtypes.EthSubscriptionParams) (<-chan ethtypes.EthSubscriptionResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "EthSubscribe", arg0, arg1, arg2) - ret0, _ := ret[0].(<-chan api.EthSubscriptionResponse) + ret0, _ := ret[0].(<-chan ethtypes.EthSubscriptionResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1373,7 +1373,7 @@ func (mr *MockFullNodeMockRecorder) EthSubscribe(arg0, arg1, arg2 interface{}) * } // EthUninstallFilter mocks base method. -func (m *MockFullNode) EthUninstallFilter(arg0 context.Context, arg1 api.EthFilterID) (bool, error) { +func (m *MockFullNode) EthUninstallFilter(arg0 context.Context, arg1 ethtypes.EthFilterID) (bool, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "EthUninstallFilter", arg0, arg1) ret0, _ := ret[0].(bool) @@ -1388,7 +1388,7 @@ func (mr *MockFullNodeMockRecorder) EthUninstallFilter(arg0, arg1 interface{}) * } // EthUnsubscribe mocks base method. -func (m *MockFullNode) EthUnsubscribe(arg0 context.Context, arg1 api.EthSubscriptionID) (bool, error) { +func (m *MockFullNode) EthUnsubscribe(arg0 context.Context, arg1 ethtypes.EthSubscriptionID) (bool, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "EthUnsubscribe", arg0, arg1) ret0, _ := ret[0].(bool) diff --git a/api/proxy_gen.go b/api/proxy_gen.go index 8552b17460c..d308533e947 100644 --- a/api/proxy_gen.go +++ b/api/proxy_gen.go @@ -36,8 +36,8 @@ import ( builtinactors "github.com/filecoin-project/lotus/chain/actors/builtin" lminer "github.com/filecoin-project/lotus/chain/actors/builtin/miner" "github.com/filecoin-project/lotus/chain/types" + "github.com/filecoin-project/lotus/chain/types/ethtypes" "github.com/filecoin-project/lotus/journal/alerting" - _ "github.com/filecoin-project/lotus/lib/sigs/delegated" "github.com/filecoin-project/lotus/node/modules/dtypes" "github.com/filecoin-project/lotus/node/repo/imports" "github.com/filecoin-project/lotus/storage/pipeline/sealiface" @@ -221,67 +221,67 @@ type FullNodeStruct struct { CreateBackup func(p0 context.Context, p1 string) error `perm:"admin"` - EthAccounts func(p0 context.Context) ([]EthAddress, error) `perm:"read"` + EthAccounts func(p0 context.Context) ([]ethtypes.EthAddress, error) `perm:"read"` - EthBlockNumber func(p0 context.Context) (EthUint64, error) `perm:"read"` + EthBlockNumber func(p0 context.Context) (ethtypes.EthUint64, error) `perm:"read"` - EthCall func(p0 context.Context, p1 EthCall, p2 string) (EthBytes, error) `perm:"read"` + EthCall func(p0 context.Context, p1 ethtypes.EthCall, p2 string) (ethtypes.EthBytes, error) `perm:"read"` - EthChainId func(p0 context.Context) (EthUint64, error) `perm:"read"` + EthChainId func(p0 context.Context) (ethtypes.EthUint64, error) `perm:"read"` - EthEstimateGas func(p0 context.Context, p1 EthCall) (EthUint64, error) `perm:"read"` + EthEstimateGas func(p0 context.Context, p1 ethtypes.EthCall) (ethtypes.EthUint64, error) `perm:"read"` - EthFeeHistory func(p0 context.Context, p1 EthUint64, p2 string, p3 []float64) (EthFeeHistory, error) `perm:"read"` + EthFeeHistory func(p0 context.Context, p1 ethtypes.EthUint64, p2 string, p3 []float64) (ethtypes.EthFeeHistory, error) `perm:"read"` - EthGasPrice func(p0 context.Context) (EthBigInt, error) `perm:"read"` + EthGasPrice func(p0 context.Context) (ethtypes.EthBigInt, error) `perm:"read"` - EthGetBalance func(p0 context.Context, p1 EthAddress, p2 string) (EthBigInt, error) `perm:"read"` + EthGetBalance func(p0 context.Context, p1 ethtypes.EthAddress, p2 string) (ethtypes.EthBigInt, error) `perm:"read"` - EthGetBlockByHash func(p0 context.Context, p1 EthHash, p2 bool) (EthBlock, error) `perm:"read"` + EthGetBlockByHash func(p0 context.Context, p1 ethtypes.EthHash, p2 bool) (ethtypes.EthBlock, error) `perm:"read"` - EthGetBlockByNumber func(p0 context.Context, p1 string, p2 bool) (EthBlock, error) `perm:"read"` + EthGetBlockByNumber func(p0 context.Context, p1 string, p2 bool) (ethtypes.EthBlock, error) `perm:"read"` - EthGetBlockTransactionCountByHash func(p0 context.Context, p1 EthHash) (EthUint64, error) `perm:"read"` + EthGetBlockTransactionCountByHash func(p0 context.Context, p1 ethtypes.EthHash) (ethtypes.EthUint64, error) `perm:"read"` - EthGetBlockTransactionCountByNumber func(p0 context.Context, p1 EthUint64) (EthUint64, error) `perm:"read"` + EthGetBlockTransactionCountByNumber func(p0 context.Context, p1 ethtypes.EthUint64) (ethtypes.EthUint64, error) `perm:"read"` - EthGetCode func(p0 context.Context, p1 EthAddress, p2 string) (EthBytes, error) `perm:"read"` + EthGetCode func(p0 context.Context, p1 ethtypes.EthAddress, p2 string) (ethtypes.EthBytes, error) `perm:"read"` - EthGetFilterChanges func(p0 context.Context, p1 EthFilterID) (*EthFilterResult, error) `perm:"write"` + EthGetFilterChanges func(p0 context.Context, p1 ethtypes.EthFilterID) (*ethtypes.EthFilterResult, error) `perm:"write"` - EthGetFilterLogs func(p0 context.Context, p1 EthFilterID) (*EthFilterResult, error) `perm:"write"` + EthGetFilterLogs func(p0 context.Context, p1 ethtypes.EthFilterID) (*ethtypes.EthFilterResult, error) `perm:"write"` - EthGetLogs func(p0 context.Context, p1 *EthFilterSpec) (*EthFilterResult, error) `perm:"read"` + EthGetLogs func(p0 context.Context, p1 *ethtypes.EthFilterSpec) (*ethtypes.EthFilterResult, error) `perm:"read"` - EthGetStorageAt func(p0 context.Context, p1 EthAddress, p2 EthBytes, p3 string) (EthBytes, error) `perm:"read"` + EthGetStorageAt func(p0 context.Context, p1 ethtypes.EthAddress, p2 ethtypes.EthBytes, p3 string) (ethtypes.EthBytes, error) `perm:"read"` - EthGetTransactionByBlockHashAndIndex func(p0 context.Context, p1 EthHash, p2 EthUint64) (EthTx, error) `perm:"read"` + EthGetTransactionByBlockHashAndIndex func(p0 context.Context, p1 ethtypes.EthHash, p2 ethtypes.EthUint64) (ethtypes.EthTx, error) `perm:"read"` - EthGetTransactionByBlockNumberAndIndex func(p0 context.Context, p1 EthUint64, p2 EthUint64) (EthTx, error) `perm:"read"` + EthGetTransactionByBlockNumberAndIndex func(p0 context.Context, p1 ethtypes.EthUint64, p2 ethtypes.EthUint64) (ethtypes.EthTx, error) `perm:"read"` - EthGetTransactionByHash func(p0 context.Context, p1 *EthHash) (*EthTx, error) `perm:"read"` + EthGetTransactionByHash func(p0 context.Context, p1 *ethtypes.EthHash) (*ethtypes.EthTx, error) `perm:"read"` - EthGetTransactionCount func(p0 context.Context, p1 EthAddress, p2 string) (EthUint64, error) `perm:"read"` + EthGetTransactionCount func(p0 context.Context, p1 ethtypes.EthAddress, p2 string) (ethtypes.EthUint64, error) `perm:"read"` - EthGetTransactionReceipt func(p0 context.Context, p1 EthHash) (*EthTxReceipt, error) `perm:"read"` + EthGetTransactionReceipt func(p0 context.Context, p1 ethtypes.EthHash) (*EthTxReceipt, error) `perm:"read"` - EthMaxPriorityFeePerGas func(p0 context.Context) (EthBigInt, error) `perm:"read"` + EthMaxPriorityFeePerGas func(p0 context.Context) (ethtypes.EthBigInt, error) `perm:"read"` - EthNewBlockFilter func(p0 context.Context) (EthFilterID, error) `perm:"write"` + EthNewBlockFilter func(p0 context.Context) (ethtypes.EthFilterID, error) `perm:"write"` - EthNewFilter func(p0 context.Context, p1 *EthFilterSpec) (EthFilterID, error) `perm:"write"` + EthNewFilter func(p0 context.Context, p1 *ethtypes.EthFilterSpec) (ethtypes.EthFilterID, error) `perm:"write"` - EthNewPendingTransactionFilter func(p0 context.Context) (EthFilterID, error) `perm:"write"` + EthNewPendingTransactionFilter func(p0 context.Context) (ethtypes.EthFilterID, error) `perm:"write"` - EthProtocolVersion func(p0 context.Context) (EthUint64, error) `perm:"read"` + EthProtocolVersion func(p0 context.Context) (ethtypes.EthUint64, error) `perm:"read"` - EthSendRawTransaction func(p0 context.Context, p1 EthBytes) (EthHash, error) `perm:"read"` + EthSendRawTransaction func(p0 context.Context, p1 ethtypes.EthBytes) (ethtypes.EthHash, error) `perm:"read"` - EthSubscribe func(p0 context.Context, p1 string, p2 *EthSubscriptionParams) (<-chan EthSubscriptionResponse, error) `perm:"write"` + EthSubscribe func(p0 context.Context, p1 string, p2 *ethtypes.EthSubscriptionParams) (<-chan ethtypes.EthSubscriptionResponse, error) `perm:"write"` - EthUninstallFilter func(p0 context.Context, p1 EthFilterID) (bool, error) `perm:"write"` + EthUninstallFilter func(p0 context.Context, p1 ethtypes.EthFilterID) (bool, error) `perm:"write"` - EthUnsubscribe func(p0 context.Context, p1 EthSubscriptionID) (bool, error) `perm:"write"` + EthUnsubscribe func(p0 context.Context, p1 ethtypes.EthSubscriptionID) (bool, error) `perm:"write"` GasEstimateFeeCap func(p0 context.Context, p1 *types.Message, p2 int64, p3 types.TipSetKey) (types.BigInt, error) `perm:"read"` @@ -1875,344 +1875,344 @@ func (s *FullNodeStub) CreateBackup(p0 context.Context, p1 string) error { return ErrNotSupported } -func (s *FullNodeStruct) EthAccounts(p0 context.Context) ([]EthAddress, error) { +func (s *FullNodeStruct) EthAccounts(p0 context.Context) ([]ethtypes.EthAddress, error) { if s.Internal.EthAccounts == nil { - return *new([]EthAddress), ErrNotSupported + return *new([]ethtypes.EthAddress), ErrNotSupported } return s.Internal.EthAccounts(p0) } -func (s *FullNodeStub) EthAccounts(p0 context.Context) ([]EthAddress, error) { - return *new([]EthAddress), ErrNotSupported +func (s *FullNodeStub) EthAccounts(p0 context.Context) ([]ethtypes.EthAddress, error) { + return *new([]ethtypes.EthAddress), ErrNotSupported } -func (s *FullNodeStruct) EthBlockNumber(p0 context.Context) (EthUint64, error) { +func (s *FullNodeStruct) EthBlockNumber(p0 context.Context) (ethtypes.EthUint64, error) { if s.Internal.EthBlockNumber == nil { - return *new(EthUint64), ErrNotSupported + return *new(ethtypes.EthUint64), ErrNotSupported } return s.Internal.EthBlockNumber(p0) } -func (s *FullNodeStub) EthBlockNumber(p0 context.Context) (EthUint64, error) { - return *new(EthUint64), ErrNotSupported +func (s *FullNodeStub) EthBlockNumber(p0 context.Context) (ethtypes.EthUint64, error) { + return *new(ethtypes.EthUint64), ErrNotSupported } -func (s *FullNodeStruct) EthCall(p0 context.Context, p1 EthCall, p2 string) (EthBytes, error) { +func (s *FullNodeStruct) EthCall(p0 context.Context, p1 ethtypes.EthCall, p2 string) (ethtypes.EthBytes, error) { if s.Internal.EthCall == nil { - return *new(EthBytes), ErrNotSupported + return *new(ethtypes.EthBytes), ErrNotSupported } return s.Internal.EthCall(p0, p1, p2) } -func (s *FullNodeStub) EthCall(p0 context.Context, p1 EthCall, p2 string) (EthBytes, error) { - return *new(EthBytes), ErrNotSupported +func (s *FullNodeStub) EthCall(p0 context.Context, p1 ethtypes.EthCall, p2 string) (ethtypes.EthBytes, error) { + return *new(ethtypes.EthBytes), ErrNotSupported } -func (s *FullNodeStruct) EthChainId(p0 context.Context) (EthUint64, error) { +func (s *FullNodeStruct) EthChainId(p0 context.Context) (ethtypes.EthUint64, error) { if s.Internal.EthChainId == nil { - return *new(EthUint64), ErrNotSupported + return *new(ethtypes.EthUint64), ErrNotSupported } return s.Internal.EthChainId(p0) } -func (s *FullNodeStub) EthChainId(p0 context.Context) (EthUint64, error) { - return *new(EthUint64), ErrNotSupported +func (s *FullNodeStub) EthChainId(p0 context.Context) (ethtypes.EthUint64, error) { + return *new(ethtypes.EthUint64), ErrNotSupported } -func (s *FullNodeStruct) EthEstimateGas(p0 context.Context, p1 EthCall) (EthUint64, error) { +func (s *FullNodeStruct) EthEstimateGas(p0 context.Context, p1 ethtypes.EthCall) (ethtypes.EthUint64, error) { if s.Internal.EthEstimateGas == nil { - return *new(EthUint64), ErrNotSupported + return *new(ethtypes.EthUint64), ErrNotSupported } return s.Internal.EthEstimateGas(p0, p1) } -func (s *FullNodeStub) EthEstimateGas(p0 context.Context, p1 EthCall) (EthUint64, error) { - return *new(EthUint64), ErrNotSupported +func (s *FullNodeStub) EthEstimateGas(p0 context.Context, p1 ethtypes.EthCall) (ethtypes.EthUint64, error) { + return *new(ethtypes.EthUint64), ErrNotSupported } -func (s *FullNodeStruct) EthFeeHistory(p0 context.Context, p1 EthUint64, p2 string, p3 []float64) (EthFeeHistory, error) { +func (s *FullNodeStruct) EthFeeHistory(p0 context.Context, p1 ethtypes.EthUint64, p2 string, p3 []float64) (ethtypes.EthFeeHistory, error) { if s.Internal.EthFeeHistory == nil { - return *new(EthFeeHistory), ErrNotSupported + return *new(ethtypes.EthFeeHistory), ErrNotSupported } return s.Internal.EthFeeHistory(p0, p1, p2, p3) } -func (s *FullNodeStub) EthFeeHistory(p0 context.Context, p1 EthUint64, p2 string, p3 []float64) (EthFeeHistory, error) { - return *new(EthFeeHistory), ErrNotSupported +func (s *FullNodeStub) EthFeeHistory(p0 context.Context, p1 ethtypes.EthUint64, p2 string, p3 []float64) (ethtypes.EthFeeHistory, error) { + return *new(ethtypes.EthFeeHistory), ErrNotSupported } -func (s *FullNodeStruct) EthGasPrice(p0 context.Context) (EthBigInt, error) { +func (s *FullNodeStruct) EthGasPrice(p0 context.Context) (ethtypes.EthBigInt, error) { if s.Internal.EthGasPrice == nil { - return *new(EthBigInt), ErrNotSupported + return *new(ethtypes.EthBigInt), ErrNotSupported } return s.Internal.EthGasPrice(p0) } -func (s *FullNodeStub) EthGasPrice(p0 context.Context) (EthBigInt, error) { - return *new(EthBigInt), ErrNotSupported +func (s *FullNodeStub) EthGasPrice(p0 context.Context) (ethtypes.EthBigInt, error) { + return *new(ethtypes.EthBigInt), ErrNotSupported } -func (s *FullNodeStruct) EthGetBalance(p0 context.Context, p1 EthAddress, p2 string) (EthBigInt, error) { +func (s *FullNodeStruct) EthGetBalance(p0 context.Context, p1 ethtypes.EthAddress, p2 string) (ethtypes.EthBigInt, error) { if s.Internal.EthGetBalance == nil { - return *new(EthBigInt), ErrNotSupported + return *new(ethtypes.EthBigInt), ErrNotSupported } return s.Internal.EthGetBalance(p0, p1, p2) } -func (s *FullNodeStub) EthGetBalance(p0 context.Context, p1 EthAddress, p2 string) (EthBigInt, error) { - return *new(EthBigInt), ErrNotSupported +func (s *FullNodeStub) EthGetBalance(p0 context.Context, p1 ethtypes.EthAddress, p2 string) (ethtypes.EthBigInt, error) { + return *new(ethtypes.EthBigInt), ErrNotSupported } -func (s *FullNodeStruct) EthGetBlockByHash(p0 context.Context, p1 EthHash, p2 bool) (EthBlock, error) { +func (s *FullNodeStruct) EthGetBlockByHash(p0 context.Context, p1 ethtypes.EthHash, p2 bool) (ethtypes.EthBlock, error) { if s.Internal.EthGetBlockByHash == nil { - return *new(EthBlock), ErrNotSupported + return *new(ethtypes.EthBlock), ErrNotSupported } return s.Internal.EthGetBlockByHash(p0, p1, p2) } -func (s *FullNodeStub) EthGetBlockByHash(p0 context.Context, p1 EthHash, p2 bool) (EthBlock, error) { - return *new(EthBlock), ErrNotSupported +func (s *FullNodeStub) EthGetBlockByHash(p0 context.Context, p1 ethtypes.EthHash, p2 bool) (ethtypes.EthBlock, error) { + return *new(ethtypes.EthBlock), ErrNotSupported } -func (s *FullNodeStruct) EthGetBlockByNumber(p0 context.Context, p1 string, p2 bool) (EthBlock, error) { +func (s *FullNodeStruct) EthGetBlockByNumber(p0 context.Context, p1 string, p2 bool) (ethtypes.EthBlock, error) { if s.Internal.EthGetBlockByNumber == nil { - return *new(EthBlock), ErrNotSupported + return *new(ethtypes.EthBlock), ErrNotSupported } return s.Internal.EthGetBlockByNumber(p0, p1, p2) } -func (s *FullNodeStub) EthGetBlockByNumber(p0 context.Context, p1 string, p2 bool) (EthBlock, error) { - return *new(EthBlock), ErrNotSupported +func (s *FullNodeStub) EthGetBlockByNumber(p0 context.Context, p1 string, p2 bool) (ethtypes.EthBlock, error) { + return *new(ethtypes.EthBlock), ErrNotSupported } -func (s *FullNodeStruct) EthGetBlockTransactionCountByHash(p0 context.Context, p1 EthHash) (EthUint64, error) { +func (s *FullNodeStruct) EthGetBlockTransactionCountByHash(p0 context.Context, p1 ethtypes.EthHash) (ethtypes.EthUint64, error) { if s.Internal.EthGetBlockTransactionCountByHash == nil { - return *new(EthUint64), ErrNotSupported + return *new(ethtypes.EthUint64), ErrNotSupported } return s.Internal.EthGetBlockTransactionCountByHash(p0, p1) } -func (s *FullNodeStub) EthGetBlockTransactionCountByHash(p0 context.Context, p1 EthHash) (EthUint64, error) { - return *new(EthUint64), ErrNotSupported +func (s *FullNodeStub) EthGetBlockTransactionCountByHash(p0 context.Context, p1 ethtypes.EthHash) (ethtypes.EthUint64, error) { + return *new(ethtypes.EthUint64), ErrNotSupported } -func (s *FullNodeStruct) EthGetBlockTransactionCountByNumber(p0 context.Context, p1 EthUint64) (EthUint64, error) { +func (s *FullNodeStruct) EthGetBlockTransactionCountByNumber(p0 context.Context, p1 ethtypes.EthUint64) (ethtypes.EthUint64, error) { if s.Internal.EthGetBlockTransactionCountByNumber == nil { - return *new(EthUint64), ErrNotSupported + return *new(ethtypes.EthUint64), ErrNotSupported } return s.Internal.EthGetBlockTransactionCountByNumber(p0, p1) } -func (s *FullNodeStub) EthGetBlockTransactionCountByNumber(p0 context.Context, p1 EthUint64) (EthUint64, error) { - return *new(EthUint64), ErrNotSupported +func (s *FullNodeStub) EthGetBlockTransactionCountByNumber(p0 context.Context, p1 ethtypes.EthUint64) (ethtypes.EthUint64, error) { + return *new(ethtypes.EthUint64), ErrNotSupported } -func (s *FullNodeStruct) EthGetCode(p0 context.Context, p1 EthAddress, p2 string) (EthBytes, error) { +func (s *FullNodeStruct) EthGetCode(p0 context.Context, p1 ethtypes.EthAddress, p2 string) (ethtypes.EthBytes, error) { if s.Internal.EthGetCode == nil { - return *new(EthBytes), ErrNotSupported + return *new(ethtypes.EthBytes), ErrNotSupported } return s.Internal.EthGetCode(p0, p1, p2) } -func (s *FullNodeStub) EthGetCode(p0 context.Context, p1 EthAddress, p2 string) (EthBytes, error) { - return *new(EthBytes), ErrNotSupported +func (s *FullNodeStub) EthGetCode(p0 context.Context, p1 ethtypes.EthAddress, p2 string) (ethtypes.EthBytes, error) { + return *new(ethtypes.EthBytes), ErrNotSupported } -func (s *FullNodeStruct) EthGetFilterChanges(p0 context.Context, p1 EthFilterID) (*EthFilterResult, error) { +func (s *FullNodeStruct) EthGetFilterChanges(p0 context.Context, p1 ethtypes.EthFilterID) (*ethtypes.EthFilterResult, error) { if s.Internal.EthGetFilterChanges == nil { return nil, ErrNotSupported } return s.Internal.EthGetFilterChanges(p0, p1) } -func (s *FullNodeStub) EthGetFilterChanges(p0 context.Context, p1 EthFilterID) (*EthFilterResult, error) { +func (s *FullNodeStub) EthGetFilterChanges(p0 context.Context, p1 ethtypes.EthFilterID) (*ethtypes.EthFilterResult, error) { return nil, ErrNotSupported } -func (s *FullNodeStruct) EthGetFilterLogs(p0 context.Context, p1 EthFilterID) (*EthFilterResult, error) { +func (s *FullNodeStruct) EthGetFilterLogs(p0 context.Context, p1 ethtypes.EthFilterID) (*ethtypes.EthFilterResult, error) { if s.Internal.EthGetFilterLogs == nil { return nil, ErrNotSupported } return s.Internal.EthGetFilterLogs(p0, p1) } -func (s *FullNodeStub) EthGetFilterLogs(p0 context.Context, p1 EthFilterID) (*EthFilterResult, error) { +func (s *FullNodeStub) EthGetFilterLogs(p0 context.Context, p1 ethtypes.EthFilterID) (*ethtypes.EthFilterResult, error) { return nil, ErrNotSupported } -func (s *FullNodeStruct) EthGetLogs(p0 context.Context, p1 *EthFilterSpec) (*EthFilterResult, error) { +func (s *FullNodeStruct) EthGetLogs(p0 context.Context, p1 *ethtypes.EthFilterSpec) (*ethtypes.EthFilterResult, error) { if s.Internal.EthGetLogs == nil { return nil, ErrNotSupported } return s.Internal.EthGetLogs(p0, p1) } -func (s *FullNodeStub) EthGetLogs(p0 context.Context, p1 *EthFilterSpec) (*EthFilterResult, error) { +func (s *FullNodeStub) EthGetLogs(p0 context.Context, p1 *ethtypes.EthFilterSpec) (*ethtypes.EthFilterResult, error) { return nil, ErrNotSupported } -func (s *FullNodeStruct) EthGetStorageAt(p0 context.Context, p1 EthAddress, p2 EthBytes, p3 string) (EthBytes, error) { +func (s *FullNodeStruct) EthGetStorageAt(p0 context.Context, p1 ethtypes.EthAddress, p2 ethtypes.EthBytes, p3 string) (ethtypes.EthBytes, error) { if s.Internal.EthGetStorageAt == nil { - return *new(EthBytes), ErrNotSupported + return *new(ethtypes.EthBytes), ErrNotSupported } return s.Internal.EthGetStorageAt(p0, p1, p2, p3) } -func (s *FullNodeStub) EthGetStorageAt(p0 context.Context, p1 EthAddress, p2 EthBytes, p3 string) (EthBytes, error) { - return *new(EthBytes), ErrNotSupported +func (s *FullNodeStub) EthGetStorageAt(p0 context.Context, p1 ethtypes.EthAddress, p2 ethtypes.EthBytes, p3 string) (ethtypes.EthBytes, error) { + return *new(ethtypes.EthBytes), ErrNotSupported } -func (s *FullNodeStruct) EthGetTransactionByBlockHashAndIndex(p0 context.Context, p1 EthHash, p2 EthUint64) (EthTx, error) { +func (s *FullNodeStruct) EthGetTransactionByBlockHashAndIndex(p0 context.Context, p1 ethtypes.EthHash, p2 ethtypes.EthUint64) (ethtypes.EthTx, error) { if s.Internal.EthGetTransactionByBlockHashAndIndex == nil { - return *new(EthTx), ErrNotSupported + return *new(ethtypes.EthTx), ErrNotSupported } return s.Internal.EthGetTransactionByBlockHashAndIndex(p0, p1, p2) } -func (s *FullNodeStub) EthGetTransactionByBlockHashAndIndex(p0 context.Context, p1 EthHash, p2 EthUint64) (EthTx, error) { - return *new(EthTx), ErrNotSupported +func (s *FullNodeStub) EthGetTransactionByBlockHashAndIndex(p0 context.Context, p1 ethtypes.EthHash, p2 ethtypes.EthUint64) (ethtypes.EthTx, error) { + return *new(ethtypes.EthTx), ErrNotSupported } -func (s *FullNodeStruct) EthGetTransactionByBlockNumberAndIndex(p0 context.Context, p1 EthUint64, p2 EthUint64) (EthTx, error) { +func (s *FullNodeStruct) EthGetTransactionByBlockNumberAndIndex(p0 context.Context, p1 ethtypes.EthUint64, p2 ethtypes.EthUint64) (ethtypes.EthTx, error) { if s.Internal.EthGetTransactionByBlockNumberAndIndex == nil { - return *new(EthTx), ErrNotSupported + return *new(ethtypes.EthTx), ErrNotSupported } return s.Internal.EthGetTransactionByBlockNumberAndIndex(p0, p1, p2) } -func (s *FullNodeStub) EthGetTransactionByBlockNumberAndIndex(p0 context.Context, p1 EthUint64, p2 EthUint64) (EthTx, error) { - return *new(EthTx), ErrNotSupported +func (s *FullNodeStub) EthGetTransactionByBlockNumberAndIndex(p0 context.Context, p1 ethtypes.EthUint64, p2 ethtypes.EthUint64) (ethtypes.EthTx, error) { + return *new(ethtypes.EthTx), ErrNotSupported } -func (s *FullNodeStruct) EthGetTransactionByHash(p0 context.Context, p1 *EthHash) (*EthTx, error) { +func (s *FullNodeStruct) EthGetTransactionByHash(p0 context.Context, p1 *ethtypes.EthHash) (*ethtypes.EthTx, error) { if s.Internal.EthGetTransactionByHash == nil { return nil, ErrNotSupported } return s.Internal.EthGetTransactionByHash(p0, p1) } -func (s *FullNodeStub) EthGetTransactionByHash(p0 context.Context, p1 *EthHash) (*EthTx, error) { +func (s *FullNodeStub) EthGetTransactionByHash(p0 context.Context, p1 *ethtypes.EthHash) (*ethtypes.EthTx, error) { return nil, ErrNotSupported } -func (s *FullNodeStruct) EthGetTransactionCount(p0 context.Context, p1 EthAddress, p2 string) (EthUint64, error) { +func (s *FullNodeStruct) EthGetTransactionCount(p0 context.Context, p1 ethtypes.EthAddress, p2 string) (ethtypes.EthUint64, error) { if s.Internal.EthGetTransactionCount == nil { - return *new(EthUint64), ErrNotSupported + return *new(ethtypes.EthUint64), ErrNotSupported } return s.Internal.EthGetTransactionCount(p0, p1, p2) } -func (s *FullNodeStub) EthGetTransactionCount(p0 context.Context, p1 EthAddress, p2 string) (EthUint64, error) { - return *new(EthUint64), ErrNotSupported +func (s *FullNodeStub) EthGetTransactionCount(p0 context.Context, p1 ethtypes.EthAddress, p2 string) (ethtypes.EthUint64, error) { + return *new(ethtypes.EthUint64), ErrNotSupported } -func (s *FullNodeStruct) EthGetTransactionReceipt(p0 context.Context, p1 EthHash) (*EthTxReceipt, error) { +func (s *FullNodeStruct) EthGetTransactionReceipt(p0 context.Context, p1 ethtypes.EthHash) (*EthTxReceipt, error) { if s.Internal.EthGetTransactionReceipt == nil { return nil, ErrNotSupported } return s.Internal.EthGetTransactionReceipt(p0, p1) } -func (s *FullNodeStub) EthGetTransactionReceipt(p0 context.Context, p1 EthHash) (*EthTxReceipt, error) { +func (s *FullNodeStub) EthGetTransactionReceipt(p0 context.Context, p1 ethtypes.EthHash) (*EthTxReceipt, error) { return nil, ErrNotSupported } -func (s *FullNodeStruct) EthMaxPriorityFeePerGas(p0 context.Context) (EthBigInt, error) { +func (s *FullNodeStruct) EthMaxPriorityFeePerGas(p0 context.Context) (ethtypes.EthBigInt, error) { if s.Internal.EthMaxPriorityFeePerGas == nil { - return *new(EthBigInt), ErrNotSupported + return *new(ethtypes.EthBigInt), ErrNotSupported } return s.Internal.EthMaxPriorityFeePerGas(p0) } -func (s *FullNodeStub) EthMaxPriorityFeePerGas(p0 context.Context) (EthBigInt, error) { - return *new(EthBigInt), ErrNotSupported +func (s *FullNodeStub) EthMaxPriorityFeePerGas(p0 context.Context) (ethtypes.EthBigInt, error) { + return *new(ethtypes.EthBigInt), ErrNotSupported } -func (s *FullNodeStruct) EthNewBlockFilter(p0 context.Context) (EthFilterID, error) { +func (s *FullNodeStruct) EthNewBlockFilter(p0 context.Context) (ethtypes.EthFilterID, error) { if s.Internal.EthNewBlockFilter == nil { - return *new(EthFilterID), ErrNotSupported + return *new(ethtypes.EthFilterID), ErrNotSupported } return s.Internal.EthNewBlockFilter(p0) } -func (s *FullNodeStub) EthNewBlockFilter(p0 context.Context) (EthFilterID, error) { - return *new(EthFilterID), ErrNotSupported +func (s *FullNodeStub) EthNewBlockFilter(p0 context.Context) (ethtypes.EthFilterID, error) { + return *new(ethtypes.EthFilterID), ErrNotSupported } -func (s *FullNodeStruct) EthNewFilter(p0 context.Context, p1 *EthFilterSpec) (EthFilterID, error) { +func (s *FullNodeStruct) EthNewFilter(p0 context.Context, p1 *ethtypes.EthFilterSpec) (ethtypes.EthFilterID, error) { if s.Internal.EthNewFilter == nil { - return *new(EthFilterID), ErrNotSupported + return *new(ethtypes.EthFilterID), ErrNotSupported } return s.Internal.EthNewFilter(p0, p1) } -func (s *FullNodeStub) EthNewFilter(p0 context.Context, p1 *EthFilterSpec) (EthFilterID, error) { - return *new(EthFilterID), ErrNotSupported +func (s *FullNodeStub) EthNewFilter(p0 context.Context, p1 *ethtypes.EthFilterSpec) (ethtypes.EthFilterID, error) { + return *new(ethtypes.EthFilterID), ErrNotSupported } -func (s *FullNodeStruct) EthNewPendingTransactionFilter(p0 context.Context) (EthFilterID, error) { +func (s *FullNodeStruct) EthNewPendingTransactionFilter(p0 context.Context) (ethtypes.EthFilterID, error) { if s.Internal.EthNewPendingTransactionFilter == nil { - return *new(EthFilterID), ErrNotSupported + return *new(ethtypes.EthFilterID), ErrNotSupported } return s.Internal.EthNewPendingTransactionFilter(p0) } -func (s *FullNodeStub) EthNewPendingTransactionFilter(p0 context.Context) (EthFilterID, error) { - return *new(EthFilterID), ErrNotSupported +func (s *FullNodeStub) EthNewPendingTransactionFilter(p0 context.Context) (ethtypes.EthFilterID, error) { + return *new(ethtypes.EthFilterID), ErrNotSupported } -func (s *FullNodeStruct) EthProtocolVersion(p0 context.Context) (EthUint64, error) { +func (s *FullNodeStruct) EthProtocolVersion(p0 context.Context) (ethtypes.EthUint64, error) { if s.Internal.EthProtocolVersion == nil { - return *new(EthUint64), ErrNotSupported + return *new(ethtypes.EthUint64), ErrNotSupported } return s.Internal.EthProtocolVersion(p0) } -func (s *FullNodeStub) EthProtocolVersion(p0 context.Context) (EthUint64, error) { - return *new(EthUint64), ErrNotSupported +func (s *FullNodeStub) EthProtocolVersion(p0 context.Context) (ethtypes.EthUint64, error) { + return *new(ethtypes.EthUint64), ErrNotSupported } -func (s *FullNodeStruct) EthSendRawTransaction(p0 context.Context, p1 EthBytes) (EthHash, error) { +func (s *FullNodeStruct) EthSendRawTransaction(p0 context.Context, p1 ethtypes.EthBytes) (ethtypes.EthHash, error) { if s.Internal.EthSendRawTransaction == nil { - return *new(EthHash), ErrNotSupported + return *new(ethtypes.EthHash), ErrNotSupported } return s.Internal.EthSendRawTransaction(p0, p1) } -func (s *FullNodeStub) EthSendRawTransaction(p0 context.Context, p1 EthBytes) (EthHash, error) { - return *new(EthHash), ErrNotSupported +func (s *FullNodeStub) EthSendRawTransaction(p0 context.Context, p1 ethtypes.EthBytes) (ethtypes.EthHash, error) { + return *new(ethtypes.EthHash), ErrNotSupported } -func (s *FullNodeStruct) EthSubscribe(p0 context.Context, p1 string, p2 *EthSubscriptionParams) (<-chan EthSubscriptionResponse, error) { +func (s *FullNodeStruct) EthSubscribe(p0 context.Context, p1 string, p2 *ethtypes.EthSubscriptionParams) (<-chan ethtypes.EthSubscriptionResponse, error) { if s.Internal.EthSubscribe == nil { return nil, ErrNotSupported } return s.Internal.EthSubscribe(p0, p1, p2) } -func (s *FullNodeStub) EthSubscribe(p0 context.Context, p1 string, p2 *EthSubscriptionParams) (<-chan EthSubscriptionResponse, error) { +func (s *FullNodeStub) EthSubscribe(p0 context.Context, p1 string, p2 *ethtypes.EthSubscriptionParams) (<-chan ethtypes.EthSubscriptionResponse, error) { return nil, ErrNotSupported } -func (s *FullNodeStruct) EthUninstallFilter(p0 context.Context, p1 EthFilterID) (bool, error) { +func (s *FullNodeStruct) EthUninstallFilter(p0 context.Context, p1 ethtypes.EthFilterID) (bool, error) { if s.Internal.EthUninstallFilter == nil { return false, ErrNotSupported } return s.Internal.EthUninstallFilter(p0, p1) } -func (s *FullNodeStub) EthUninstallFilter(p0 context.Context, p1 EthFilterID) (bool, error) { +func (s *FullNodeStub) EthUninstallFilter(p0 context.Context, p1 ethtypes.EthFilterID) (bool, error) { return false, ErrNotSupported } -func (s *FullNodeStruct) EthUnsubscribe(p0 context.Context, p1 EthSubscriptionID) (bool, error) { +func (s *FullNodeStruct) EthUnsubscribe(p0 context.Context, p1 ethtypes.EthSubscriptionID) (bool, error) { if s.Internal.EthUnsubscribe == nil { return false, ErrNotSupported } return s.Internal.EthUnsubscribe(p0, p1) } -func (s *FullNodeStub) EthUnsubscribe(p0 context.Context, p1 EthSubscriptionID) (bool, error) { +func (s *FullNodeStub) EthUnsubscribe(p0 context.Context, p1 ethtypes.EthSubscriptionID) (bool, error) { return false, ErrNotSupported } diff --git a/build/openrpc/full.json.gz b/build/openrpc/full.json.gz index 850d11dd02753d20c78bb6f25ec2ca8c5543fece..df5b7dd956b7f47c829a59696ed0c3fa3e7e778e 100644 GIT binary patch delta 31950 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 delta 31892 zcmV)-K!?BR`vIr>0e>Hh2mk;800030?7e$)+c>fZ`c+W6e{7OcJhJ3Rl3QE1{7T|8 zd3bGSa?Zv%XCV@jFs1+w0ovB2^4)LY!S_QTMLDvK*{vCi1R4zx=>B!1(fHA$J|cnd z^xpKgw}xALy?zgq3GKc4(c_qVsQ0G#f%1@n^RpvxaCX}3_kV6sz%V7U#`f#2?UydP z>HX~Y=7`Uz%X)9V{pb-m7ggV44>=T*t)m&l|NQ4a zQ+h=vA#uPn241`kJ?|5B(FG4ehd&1;G@khb;84QR9p5@q|9uXg&7uE|@c@(QcT6}6 zCeT4Ye)a(h0)HAj2S2XJ6~`06wob)c0=+W!z(4;92=-LzD;^*o1_Zny=(d9X^FBBU zf=`rRguYJ$j$Bdmr}&qyT;Jd`fAIW@{JbLn`OklP{T>VFa~LdoZ+d0SDT)j*I!9m( z8Fqm9Y{49g!31zjLk{>1fpJ{#iuC$D9|mx)1~d%B7k?TrUiy?_`3dxE@ddy4djVph z$Hhd@AG5sMh0j=7Ea{Q>;mpt+3hL+%&V3K5c>~8z@6Gmb^z*x5hKtcU3#g9*jzx(d zy{#AG-_Ug>%g{@|>07CG)ut{B7W1 zck2j~?E)fy4I<#^^tjOkj7QzyE)1|9nrayyK?OOUgo9HT5soJq1qE71*ad-@eGC!K z00azqlb5Q@SgayP(}1oUAjXgja7=9roN|B}5Q|xL7=k|(9O(lHj;M=-CusVpmYDv@qB_7lhMuukHW=X7^0ow%}!5fv}ma+^=P$fxzKMC~2+<7yIcs_&-y+ug&Rt!P8L8axtpRvHQTvXX& zrB#n1ms4ksTrB?>V*-Q432~?^`Rk1#LwmBb+Kkh){%5~;DIX+agM{<3oS(X+{+$?n zu?bjzm|Z`5n4>wnPwvlYNZhvU>jy9h;6ipM{>l$y_;V}15z~qIXvz3jOpa(scw6Rk zOK3TfM0%K%O^b47EAokQ^ah+xM1cSS z7$7Bdd@pi!irNrx>@&ps0P}w^;NffJ2}2Qbx#Ms};udeQ=YcT-Zs>bbjJZPg{euC2 z=rIa>$`~GdNC?6b@_yI{K%P7zlsIS$e4Qbp zSerrLM}+mS2qm7fYbQ8hF-`DHwyjLyTg+#`qqm50z@-#?9(Tr}gkcv2;v)*q(H(L^ zF)if?e!e_;11{g6UVx7$m+wCxgNyfnpTB%K2A@BD_#be10=`_F9D}!?&%wKs%gfVG z@4&~Ci;IJICl}!K6F2}DXD3IeZ%>cF;fK#hzYB`TpTVckm!e*V?B!=cAzl0E!gEtvc$x9rW@`6R@xAy(2dqOGY(oA=}o=!Gq;nLnafhHeaVHPxTEO_37B3Qn<{>!Eo}RUTIDA!aEuP#+k4;-MQB_}VAAb9;_CREL6Z23Jt_c^* zP;4G0mgarAfvCAjZ}}nhC{zX%QNO{#$4d}U%I&7#qXzz&$yXTS{M+TQ|J#q=$sBWz zg5I0$!C=tu#k(rse)QgYaLRgb_WQlx(IS?F;6_UPSn~J&hj@d3UmVVV9P(c?^sj&Z zQ^NZ1{Rk+0Yb2m!c1+aWid#Use$sJlD~I)KO6dEt%t^XXoAP*yx7||($VacTuR`z zsl1M*J@_^oQ8LyPE|! z&g=&Dq`loehAwwORH@YT8>8_Pc&W2++SC@q6HwFb9V~j#8wMw~+P_(`sX9OU<8_Ga z59@W0P$RANjd)h2W7H=QhT*C2xu50mnkW}Rvs05$Gg+;FI69L0dd`^$tE}s@Q!^zQ z?4pg5d1vTt=}w}49{(vi4kqgQnY!3)7)tpz}qjLH641DKg5zBZ6q z=)-b|nd7V`($a@1fC=bC`HhOPm)33cINe4T-dcET;qChL-0Qle5V53=Pa>_R=OQvD zdM@h_)-}z4wO-Uzt=21TV+9?U>Yu3&jQNaoU=Tf+&>&HWC7SSxl$}BVmot>m&_@+K z%pxz2P%;cqf?jg^k`kmM^`%msXVr0}bsXqwCZeUuq2bo8RWASlo+2G?g;dOKP=rPc<~-V_h<%*sR_qt^(ri(*HUrGK8ZdE zo|maCK8qEVke<>a3(yS;_;1kny#)|!NS=0LfFR@|SE!CD;&RjfiU^I9oKAy;@)-*H zKpg{rlgs~&Z2pP>^$(}^VUYPX8oZZwAIve zA`;4!a^|hkI9{gJNIKk9TU|>7%G#^pIK;nyB+#?z7WxxVf7^TY>aQY@&{P4c>gJo` zjpI30$xe4KVxE^nNj1L)A(ZW$8RRbV>UqfF z?EeKaoo90M5}tqs4X=nWIzlGYkFqvA%$whIR;NPau{6B}f!<&;eRmX3!gItSCNj&l z$?VUiK#QrxyGxPO|CuAbz5|zk_V$?%+dHr8Lha8&-WuZYAp+a>V$I{g-DRr}) zBc_(EXVs)1N<^ptu9{l_6He3D&2+jd)5Bu6Fsm1yn2B~B7_NieL0u^BIf8EMg`g{& zgx!u8e0gA!rdJ!7BnUN+NJ=6F1!VT zeP+$YM{6#s30e{#qaPcbK`g|gw&ibA1=4n1Fy#f}?M+Bs**KDM3)!37N%NVvhs*77xaOvv` zp)P3(=Hbxl$swMe8st7tH&LSs(=?mw!(2a>K;8^X4xRgbQ8AG5O9NAP(0fW-OS?N&(Q+O}gdaiAIimCVS##Nut-n0;lPq?=WG^*Kw3{8( z0;4seA=kbGJty>kBm@xhKs{6eZ;5OWAEq{e)BB#KVBOeLdLv$a1MEy^aRH%Kl`1$FvG(zMl zWH~CG$)t+mUt4tSXf2VkdZL(#*6rc(=yyuLzWe*`@8AFZKR4+8e{=uc-T@1~{MVuL z_3r)Q+l%3Qc0%7>-US~&-2DFEeA3=$p0GXoMPXmo$M|7;cfTseEVV?>5f3oBf!;BK z#nEXZ_%f7#sw7_!6`I4~8u2Yr_Vn0L#${UQQpn|5Uk<2>?8M@Y07|A*0GYV6z!fFN zkRcaP0#v6v6KCaPx;AOH+g6&{HThwC_f=J7oSazV)16`DpdS|;u5o*$Xg2eDl<~i!Z6gqbgc}V1jiNYz(oE2Sb=E&tmvCwx76v%`&cyON zgA0#BSJ_a5eoxNP>@S(sQKhzOWX)wr8(oYMx7O4IOmY3>?7+Q2RWM^LcuMDrx!e`i z&19~*z!fEz2-_7Tt>$={l#Lll3E2Qez$O;3R+c_ySz0MbJCdUJA~m0??AxviV3q6p zg_q2Nbi&P$|Luf+RNW-Z@J0F%!@oil zEIv;rC|Hhvqef~EGb99CVBl0YOteGHP>c|n+?rs3&madgc!K~04hlHLMCyWm=JY~; z!Yc#MC_%v2dmGPf(BPxM&b8wAh5a-eX4a&oN6C4U%uBP(=s{3ancc!NX~uLNgRnE~ z_da5B7GObJUS;xyFeH?E@J9XiO_zOkN}K>ertH0sn4lni z>xz7EhLFT_2WqPJ-t?}*!C>T|xz87W@=u98j@8)bd~GY_kq^pIWHJzqFTz#bYgH{8 zga#dm$E#_B8rqh62V3|R%Mf*8W|-ahTQPNv?fVuk(afxFI+E*+#L2Bfn^QRlaYt3B zXe3&DhsY6Z8_lCCSHW9tNlADcg#<2fX()o-xHMwsOhBt{c!~%Lv>rb?I9HB;jbdc5 zc-$QreKHnjE%4ijAjl_Y|L#;e%NRlH5z)>$C^na>idvuL8|Mb@aBNu@U1J90iF zH=54P46)<1G%D%O2Rd!d*atc-rTN8o+cIpj3H1ri%fH-O+bt_0By(tZtTh!-->7_G zde7b;G<0UAv$k~6HrUC3ODmVhGVf3BeB^NCCR)udj&2u6W@MMnu{w#oLR?=K$26Tp z88Fto?FfK1ZPr}J8)thg#aoT$v#GEs)61znf5d#6)5~>YDnX4k0Sk{L7HPNk2(LCh zwaQt^G*>jLjPno^zPIxnJX7Dr*f3XA%T4pE-c_%)Z6330Xq{_+M$$QOLZ_TyinO64C{o->3oF%V^w*{R@`&& z?1d_Lj@WXsqKbBZ=wFYSTqaO-%XqFLjO8|5D3D@qBhH6>rqW5rk;ZmkuA6(3;(1c^ zVy9o-f5^3Jy-iqkQgdA{(?@27>~Ghe2K#^+Py2h@S|SBH<+rnZ`<^bOP1og8tU$ds zQnsXt79q1`J*ty;qI|+%dNWZQEOY{(=f$Vyd0duGuzf3@k8@#pKskht*mgV@8F7rB+&Vkuv~U^C-W-5I96`O#nBerOk3afhvF zG{rA7uF9$%u#5+;s*rLye$)QLd^-jtet!S?eTCpZyCd_fJ=50d{DgL79&HTb{;>9B zrPP)PdMn|72T{KgHyFni#iZ&%f~MCN8E9UYAp*rnga(T7L;@eUvdkR1D7r30oxF4; zmDMkTOFCNy2AYJk*m#zTc$T)>*@m{*&=w1%EReE5%7(Vs&=wooVnbV=PH4*`vkynL zX&8hpqV|gY)Re3RYP} zq)ZuC9Hvg#D0wNzX?=!JG&E1qEwxj7G*&FHIDhdfk|!ZjC4Ax%=3c6VXssB^P;M!W zGW;)p6G$n(sy$ahQmD#x)q$YO^u0u0<=>n6uvALD^mf&8NqW=LOc2F%5s_szsBwR# zoL#L_)c1RW1$K@cgm1(G9Ox%!5W8;$fEo0Amy|%e)qhOD(wpQZyx%N8S(%#h=MS{pni-dnl4SF+#RFxz=lt z^hy~Ni=8yRBP!2e1gT*vO=3PljRWSQmbCu6%~X^73TDSd^akyEE?~6x4{zv+fZF?i zt!$FVO*^bnBgY#icziVZ9aVZog1tDoV%B^wzRy|wB?UGi6J(>1d7J*RBaCm;KR%T7 zj}IBK@710fmy-N|UAKhlQS~Z}p4`eh%;WXv;Mt1{P6Iea2kd$|E{~e(@a$QNdy|Ba zF$W3aW_U`F3zB|-NkHeh6KN89cZaxtAH)TwMd-b8hC=BPx8zF}5o+e0(IGeKdQgHm z?ctAh_S4UV_RL(3_7UFY9^^IuC7vV3;oR@N*&b{Uwq;}w7Ch;n7wE4~wD)G9O-+x23Nv=rpa}a zR5!=qvU9u{1_Jp*pXOD)=uA!~gR;ImT?h73*A>>z>)MN!&xLRccn3Gkmr%NwE9Ohu z?P|%Db;#6#SjHCQT-b^Xa0&wT-rhKGZ=AO`&fkY1d^M=O-CD<_w7p?9s$M1X;*gim zfr|oRmI(o&9vS5Xi5lq8GE4D)yc|#H*0I_K)c05?m&ntJzK*aDAWNBL`c^_JdflCM zmL1Jsk`1F{PiXe`!2HQMxj$SQ%e1<$Q+?oqv$Mkc*(MXTZlG~s%CZX;tw;0Wc{IY~YiXs4o=CjZ(* z{dKlk z>60lAs$;jz%3~aQ9&*$1*ObKflK4sx14qShT@khK4Fd!i51nh^hVmk3oN5b9L}QOP z!o->^AGTi&Ytw*5lkqEm#O?i_35lvD9naZ046YI1Qu5e%Wed{XE@92A=~|Tx+(OJ{ zv`NZl;S`J!aHyEiyt{P7<>R$J_o(%buCT&JwFz=AqzezV&Nm#_uUcC#;u2?aYCQ+f zUc}**%Ul9+-41;MX^xjIu%vxoo@15)TCVslotUueJ=y$Vnc_}=$mPRq=8@idVxv+S zcCs6b+59SlpZ(rf0SW32Z+Wadw}C0Cu;lRjAc;diqMipi3SwV@POK1ceLj8A@4bbo zqhd)?KfPHh=X$HGsnICg+&0Z}+vL8G33KUL(bT@oeg4v;PsKTAbhx9PH>PavHl>lB zy=8rh*4i($sFTotTN{(RIWf7Lic5BC6En!P93En9HEfd5SQkD?TId#|WH>j#DJecC zI6yBUabHeoFh%@jf?WuplZl6kO717j0}Wv$o}nQJEF3fRS16};0G(@0rWW2 zg*O)7Sa@UMjVZj@tx5nRGZ`F0=Q{M8c}4q z5b7c@R?le39V{}OQw-o1xSXLYGDmzy#rlwwf&o5*TxWOTApYamtQXa@9^O0_b+GvcX)7d@_%Osm+t{0H#nd~?oHgl0K>6|07G0rBSz;)UIWwD z*{&eJBBC{ac{NPJRgqbvwgT_kN|Cb*O&WezjL|cKw9U z4jhMuq(v^dRNbmXPNGP3M7`QBNfD||-jq;lbm%j$nzRHJI_DUKLo>ujRRf2sny4D^s8?SpcG9{mhqCnofMpZv9Eh zjsR3LswRG@NkHelH)7g3V}zW^>(}mR;*Lj?;Vv2tUOUckZ)Y;x8H~q+y}g~mNVLak z(;8FAR2B7i>^!;~^!hyo-=bfxblFIi)obW~?QylYr`zzvdsJVC;pXP)N|sVj;Gh1P}vB3B$7L2i#>W_z@J=H8GzRntb0T_?e(DI=$#O( zGl2}4rs1rUrVI0pPNAF-Oqdir93B+oD zFmqEx*D-suJXgEyEXJ}J%VMlwfU&GjxCfmutT=gc!e?(0dXE{W!J>^yNNU$;gh&s> zX1B}+@a_A=qfm%+sVovoOB6;@uwGvz<(le@OsAG72+ z!>v))yWN!`Qz6@GmR$a=35uYeix`)GzEK%7GlmSkMd%C#0_W-Qo+)Hs7;?`c$258t zpj#NY0+%<`^|=;IlgSqqT~W8Dm@H;Xs>TJGF)-22QQuRIbkvFL??-lq@%54 zIP)Vu8sdl0gQVr8jBD3`n{+1i%%+0TgpFHR%al#?e_vY+jZU04*?(S#ce2T*^TPv4 zR?KuMW_Bw=`1L{)(Bp9N9oeQCVUzeaPnpvfSN53#JcV^;)zv<#@%1MR@e;-p^@gKqT z4354KM>5+D#koFa(Lh)BdyGSl)UkkWxR4nIp(8#S>ymDO9E5$|DNT<~*`Y_ZZ(Ync zJego8^!OrngmcQFcbt7L>gt7=@|S3aI&GQdo()^=$=I z>6^rvky=XY-rAW*Cvtv&-Nr|}Hh<-i>lM8|7G9+}cvZrH7J()+G_62?<)CHN$gkui z4FG;AAI7H#Q&{0wGMv(+CR`U3xKX8ywp;4*Rq%GX$G3oue&slZ#mV;zKkB1)hVNAz zd&}6v?W6beH0lq*t>hIj3GH9eFA(?PUOWT8a!1ly-PY>1R=2f(x~1R=2gft<~L$)xBSxk|MG;FO#`(L_@+?-{%bvlc8h`+@iN5Rnyl4;5JFcV4{8a2{Ml{-Ct4xYV;f1b<9v0OG~ z8tEi0c{%gdh~tc^beKA0=Y$68@>Gt3ehf9x4I&(PbjpB#%1KKdCkz7Q0)~l$fCm`| zKJ~nvBY%cL`vkFJ*SJ za?mgT-|Jz2`}Lqd9PRbD`=j0d-s}GMVAS6m^+)^t;c&nIx<4H3^hdAy`>*?=&~|@& zf3Lqi820yncKSQ7zdu;ZD?h!9`IUf>B}LoaCJ{Pag{T%vJ%>+y@GyK|o@sH}su%0c>| zU66Hu>9VZn_o;b)cWX1|q;^dY7l#ozIw0;TanW5%@mx>TB;iGF^ZN2`xs0xFv|eyu z-nEe0OM7XvV*D!S#4_2w$-CJV0`s!C7^9~q_MxM5mdA%M;zJF)y?&<$eo_`zH|H^Q-Ugb5ocL$z;W{|%h^QA8p*4Fp~S=wd6ZT;n~!-8?}|r7=J4(;z%;;o zQG9um5DJn%S<9@=8)ExrzNbk@aXfcT3O}Hv(ZBxeiJq)$KX;Ou_)X6nm9LPdRN^xq z2I)fAKO$>z*A!eZzc{gYQA8UZACM1BO5Uu02=Dj)nGLlc_G(k%6+y5X`_3(hELpRE z1mvAq5!r_C#f~WS^}Z~LO~%C*(_2h$F}=m~7SmfyZ!x{a^cK^%$MpNPxvVmPbcM6D z1v+)HLHY>oi#9mD`qXTzz@Rd|*M6DYi-wN;(f;1+fipqQp0hok>^P(G>*1?c&OY3A z_g{_B>sR}uZS;CD9>5)Edw<^_K<8Jr32E|42v$eVl1z)k-lq8;@=dKN#Y0Jt>@o0P9p$(w!GJdH zM3)lkb!~o{)IvO08U0q5QJT>51X;>P)5ROfCS7MeR(`_&ecTyu!}ZLq{HiH`nty9z z^QRD4m-cw2?R_tn|NR*Fj6)tKmb+Nw0d#nzS@jjePB;%e$ngz&mrLQCPw9*%6XfWE z`rdr~rjS@#JdmF+K3CSPv#v@Lt$hX2>8T`mT*%^^WO90Rn*EBEpLb2u=^kcH65%et z=TmW;b>{&p)MC!Cv0D@OCb@r zX7{*jSskB?jqc1?axiv19;Ipz&#(X9ZQM;iOT3T{Shn^<{v5x|V8Al{eIK?R-l;g<) z+|CdYvKrk238DZD0(^s5vxF}d6F!x3%4VZl<-q5LuFO$&Zn;nBcBMsGxgN{YEj3!A zYhIl(>(%bo+Qm7B47q@R5}Sp|W?@GPMS5-8t)?%l15p7(QL_w zF(2h*X}qd)Bq~?3QJ_+e*gArgiu|t2%VEP^x}3#()%mS15OL3c;cZG1x0%RADm8&F zDg~gN*eaP-?X)hEuAkX5jHcndE@l5d;#?kVCbx=ZTY3`8#`8QNQL$g0%Hj*b3Wc?Y zu{jcE+5X3rdP{^vj&8YxP=nk|G87rE77KA%7GHN#NbGMD@o!4-oS0Pw4)w$311efd ziOy(`{b8^D*VS=<`(FqP$AY18s|(pu)oa%Lg(@TIny>tra+j+<&2HU_Pa2;DbPgc6 zMPo*tYs3Ld^`^^(pB<&nmj7_)b$@$zUo8FM_Ur!6tN!+@{_e2 zA};_pjrszyM)Q}>Ymjuy|sGxcP7 zKtQ4W8Y?1AvymxL*2(3`%8RTa{gZ(yWMG02aG>AawoPV)4YzF~FUOmmVZV1tdvAJ^ z!S-+@4Dq)rzB>N>Nu8S%1^e z{_?{Go%?@|=M%J;jCLk?6fX9{5bX?a#AGQ50Dr`0JRm!x>;35{Bmr{&-k;o&o#~&u zqmes*qB|r07a96P?BCtZf*WUcgL=zvH|cC^Fs)!J2C`8w*OLn68g5raBc}9dEGt)l zDG`kZK&1#zmOAcB8Z1X9gO)%f)s6bo#ATdhfk?=Z3&xAgP8uX`e5EVqTUX?ig9*eQ z1311wUO(Ve-%*G<3_-D2#$p+ZWi}YgSX^L#jtj~+JvS8%ZYVq$RYZDc^;;xRRs#r{ zN)<#1lRVox*l;V!MKX&08av(iH4=W-?Ayq6Jni2QeK7$S5t|9TxSc^RF@_&t2LU#t zq341zQkX;DAb&+7IKe5H!5ai-csc_fzD6FNQR)IZ0hl;mD8nBx0skQ~h?0qi{{hH< zr_QWlNO~Rg2-mwVcZO@p0-l?PW(J0aL+i0J>Ws=w6@3ZMMR9Evo;8H;N7L<8oSaAr zTWuJ%Ih0pQrGYX0LjSlx#J%v5Q{lkR*ECXf2}7M^yQ%7GBj0_Br>xm5^FcAG#6rRl zkIiD~+{egsnYD+lJ#6jaCt(lg#iHSV8vQ5}qDBjdO}~U#<_gmPye#=woZzP6?2npi zJhdXO)_1;VdoLXfAbxdoe#h=?bOh)M`p2p#tDdZS+AQ_7q2|nP#c8^aFt|qiz;zFy z2gN6EYRTjYR2eZvA6>cMF5^Q3&m8P-9bvc5bjfp2j8u{i*I=I|)Dewe;U6+AL zNL;y9CpY{x=W>r6f{&uq46@l))(hDUQf!-UdQ+9b zUd6#nCAHomevTLlZcuSLnQ4O*1w(bvU{j{h#5y))%KA|qs$OJiia3)}9?oS_dpe1P z{|s^f0|cBf2oT}k0t8W|2@O;oH71W&DOhiH*DHFz;t;BunditukfFDKVg|Nc(rFS+ zAYK;E$yHswsMC#yXi%f!m3 z&?}xp(GOD~DBh^_yaz4`UR9hiEl$_gk{}`RtBk!g4{I^^a-B3a_%eKHVG+p=8D{}p z1idFJCpMW|YwcNU@3C5cd#@`l+f^d#E9NsdfVVBRK~()$X@aQzwP=A<=S(#~%+Ia< zgMpBER8D2B2Ld{`4#3Ul)~W=n5+12a7!4|tQGCP%1xEpb9I4!+jg>-pp8pS<0F%}dAn@}O1$3FkB3al!T{TAw0JRPVdPru3O+Ae; z-wELXPC(yROmeWId*u5)BKZ~J>5OZb_g??dkVloc;E$fzxma@^4({T{-dMf#6WVU;BSoOmj`$dF9nBzrCemG4b(sGn7Upe4f9V!UikI%T zNU|MVzAJt?LjjTj&xCTYKpa4_01lnc<&se$&zOO^^m=VQ&0X-!*I!#k7HPoR^rXM~ z5N~!BmmFcwzc=0$JfpYL^D^l5d!G=$rNMRj(FJli4OICHBzr0J@F04l=1=N@_>{2= z0D8!ie=-JIl?K;HmFZoDgTcr_bDuBdpD1qb0{@Mavmrn?iAA^&J<#UaAlkpm?D^&V zKPMiZ;<1O`(m)MRYK$9iE z21|z(d6z%>lzNAdJF~N}NuATlDcuJ6~EuZJ$*|+bLFf%BBE3Lzw zhWRfZzWA(*aEi^NI+Uwc@V^nA$?>rzH@ zKrJNq3Dp{cv?qYfT0 zxOOXUPRL^aFN6mn<85-xmD9No=XTuKn!ViVPMNy96W&by-YOMA7}sMo3>?(qEk0JE zTZL{Fx>e{_p<8#jb%$>RINPhr11|u<(F{3B+;b~jmLX9C$#jvkfO4vTKE|_e-@kp= zk0q504tdCyg0oDEwYaQ|d~=YN@8J@BmSxXJftbV$cyx*#=mAH(W`Gg^HEyHv)y~}| z6fGHWi^9rL*dNftu4Z40WebfgG};Jgl%AW#IM1~skuv#NB5Ep%8AzLNKLk!FF6OqU zqy;dLqUQ7O@i#dM0>#3AdrWu~&7580trojxyje)4V$di#Oc12Lc|t+;;z!SiTqvot z3{P7xs;8*>^i^OsHR;6IwVrH`3_a~vU7QeW`ZGj?#OVM; z6I7LFwhCOy%*&n!d{sV%SIYkd!4%&h@-%NUsc_Ioe>L~bL4x_K^+M7 z93|68u@$9yuGRaJ>c!5QNcB9kH70XGpxiw z)`4(dSKSFDm9B?ialgh4(uk^67)FeF-Hl%{ft7FiO0%*IVaNs@@o!dP56Y_3 zgBS@TNh0P|YU)LQv)0~zWjfP$232>Rh!6S>@gqtmxR~?OXtu}IOJ;nM!Cp->S#Bvf zk12MOpC!*^%{oY0R&*G627yEU1)!7XatY}BDb-RC-JRfRqZLtigMBhamABYuikO6T zp9Po(m@f`oH%L-f;=hr^eDCperczr(Pd?CF`9Rwnhl{s=2%STYsZLiB5_CkV=h9me zVQ*RQ^9>3R<9H4g$AgA3;Z<~gl;FK=mrQdD6m(%Wvb)eZ6GdJ!N+k^EhTABYLFRir zxr^C%wyUn<(92Yr2W=Jax0g=C> zyK|Y39D!SZUBD1=QLuGIK8dd<@7+yhngVmUkSVFg2tZEf*x3SK7*Ye5KAVOK;|RLl z1w}pxzp$DJ1>WPw>&Z~HGi;rnYC~7|uqxY}oMsAtwp-k~a@E@Ah4gVPPnGI+?%^@f114RD86Mym*xguXhrGy$oTtK!# zzvwl-#hwSIAz}v9O#a0ztRcuwUb$eU4_sW=QzbFu6)6!N{D z_7RP$$$JQBjQeKb_0~*9A&n4tm~lWSC5Mz~05Ea9P%H$1i41#|k?|WF;4NXtInrz40qpkL6YnMCB z_T>ME;m+%-EM5#x4_x=a_XB#jGCKQz9sDj-Xq${}E)L-_8)9A$3|=t$e{swD5El2H1>-o(slE82bT& z47rNV<2{I6YgunHx1$GiP&(ndc)WX)$9VTaal5xcNr1{y|CdLhHM<<(={bW+?gp^i zm)0%w>)bNUF9dkN5Px^OD!G>=0+&aSIH+j!7$SUCd(8lU1u(Dp>k`YyJuZXtwJ=`u z;>iDOlW#gD4rdDFv<1Gp`l`sc_-tpBqB<;p8_jJIzFI(N0igwi77$uM*cuRys|c=H|rc(cgKA}5QSEOL63$Z4l4U2&rPFYm~E*d}jrfkZcd zII40pSw)i{;^`^jGE}r!Xg{I*3Vi!MUU0MmEYscU8l5GhRTWbzdLp{86u3nkHpFlJ zbeg}A37j^je3rvq`rz-VT7(8R!)HfJumXZ=DU#NUk-+-BhS#fsJ@zo(iTdu$q%~8 z+!nX-)5^w-)xj?avfbn{-G7j)>{ZG6aRDRDhPGf%watrRjZ$lrTBFn&rH|5oDBY{d zDbMh9g`no<5zXB?^E-}ME)7?%wg_utl&cLv>$bPH#sjrAEJCsf$s#0+kRByM+OJC4 z94q=&y!IIi9XjoE4*K%^4l#}W6&&=L9(0Vj%-r)24v4MQWnFb1&3ddYihL+zT=ZCP zq7V3?r-gV3^S0=@wmx8M;aCfQ$67en!s*Jwc~zBQT_ETHLEbK+TUD*HX=2-B2)=zU zJ=8bGTSqg9$%#*$nYmGuF4W4Nk!*Ko$V8*iJZYWg#F77rZx;|I$1U_c#0?FV_{3du z2v1oKIdenBy2#^&`bLCYfslCAxdv_+$lRI{=2tHF;3ai5`U3v^F&GUE{gj(CQ#kFQfW?8T8V{8w$2it2&fnhC??k$mx z8B>e%EzY+%-{Sm7iSu7qrR`^U`VR4f8;CtP_Ryh%aIHXp37sap8a#XP&vWoBi}~xJ zdr9LpS1n}>g{H8+yq`;dE?cT#F}iq3I@W0*w+iSah4=r#B3KRh4Du*|{}%I^8^Buv zXaJax2!Emucy6zYGDb5wsI{RuY(qup-k>Ja|2xFb)P-qnC8w^wn!x<_{e>WRne00n zh)vyc{l#=SvTbB$(nBLr8L<^f$ml}4)TXMslun4wDZW7@l?q9JIZ3v_XCXIBYr+75 zN$4eKp4`5mv;eo*^8lg1qhyMLD*}BV!2ryVJnLj-td+6LZo|v1m9m@gibae@R9Iw# zyp5PP1Px6)eQeQ9&#Lyfz9rN;yG}=$p3AM3CPvUhv1}gyC1QKqyS1wH57h1!{B-RV z6sg>TSlJp;Y^>3L28sJ=7MPx}l(sqGoQ6bR`1Bm;}TGea1&tM15+JyI`$c8mnLui4E$@IdRAvg3|d)0De zRbQD-T-ZM9jpk49Evp1-tiyHW3ei#Wu89#ej`tfgozIx8WUNyya1 zE{tRLoyor6sfv||{OoUfI*~H=6wc}Odlv!{sV#D0?R}A<7sopCqWSHp`4*cRF==*8 z?5sS$>$`w-Q?IS<^d8nVt)!D$nv1$7t=Xa6Y8#Z0gmi)R#w874xaD=k&)~ z4t5kXu-lVL9X1#HMk4jclY8hP#0(bWsq7gE8#`rVr)=z$jh*TW&hONuy+22DdV|!3 zldUj)n!qOAg_P#2GyIvl71QvCt#e@ zD09;cxFVRi*n!e972T3V13)O3G(-<%timinY(_md zbw`p%Z&83;FkS#k&=r9m6+|$fWt!I`@>E@0o6PM)KZ$McP_kgsf=LS|EtqT#CUD5dJJ`9k@!!?zuzZcKHcGt8MCl;(cpG*6}Z{S&vTD5@~(8ZYClOiRD~ z()s!%`VwrG+~t|SHb-6HmfjMyy(wiwuA zV2gntB?f*~lRaM`tW`pxQ}x#oHPI3D?K=LAol|#aQM+xEif!9YDz15-*Zvt9Cg;Hh9J5K{)_u zhHcHG{td{&9sr-E8&%LK^TpntxuwYHr|{-JC|{N(XvH10YhO5XH0n6Cv#Y} zGFlsNITy7m+u5-^^8-#YU+fHrsR|mf{P$${2o_9&e2XMG2y7oH5zOJ#Cl)g9{?!nC z(Q~;vR;E)QqgLnPj=5IG;cYmOqhlb8pqrGjk0{e{|9Kl0R7{9c;%~VAWnxZ%?ELhsAc{sp7+8zPCVs5{(HC+JVA%t)VQRoD)ZmZB3 zIZPn>p)uirZDgTA)dwE2b~hLgD*G8d`=C}oJfhtu!0su{x?5*&kFBO zN|h1iwd7)?JZE?AyYx1>sC$YF0v zJ^T%f7*~2(;?(nV`=>Tg67eA@Y#tiu9IO+pB*OyXX$6$ovCzYJ8DJ(@d&|glYC+C1&NXECYC}XkiN8@h2CZf%2eJ`wL!;Qu{Bvtgb zCnWPEy&e)6Wl>#MzMXO(rJ}D(SkDw9) zp5hFOu1#^RtEsc}V*fQ@8ObfpN?*3kEJ{Gxs);}TU@bE{(4IFQ?D!{>{opS)B9y*> z>?B0o{M|nI3s`vju$Y>8#H7MZKCuL~9cXm1rH=|i<9cFJb%Y4=kQ;==rZ%1i|NCa*HIvv_3R%1i zHz%=`TZSYD*gyI4V0tw6g3s%`?(3=hN`=Ih(r{*hphdh3KAp*79ak0hKFmAqUJL6Kc-HnfcnL>Y1HQk3M7cbWo&XRr$Q^BICNhh&#d3(m;U ziV#9(2b%108*p-fMs0Jrh$D4Nkh8QY+T7JVs!Y5WQ<StVKk$J-K1;NBV2QAzA!W`THH8Pv<~ABU1K? zd5-{(n6MtGaL+`Ai=3v51Oya)Inm>luFk8qB9K^y;~VG!xQO&m+r5BA67ZdF`DvFh z0SOcGwu7s{#!iyf*7hIv1rP}{X^AUGAnPzeT^NamL3xN#`V*BpkJXcS#*9eD5|$jY z57%qFo4oU!b0SXY_dvj-g8UZi6Au8-ZB3uC7%QGeZ9^M@C?HaFro;wbE6M~K+xnF| zgq*CNnU5m^=&L?$y(CPz5PIbLk~pimph+FYPl0sn3ZDt5h-MNv(#()yuqR6OYSIm}}r{BwviKwwW&g{_i31WlWA5i`iK<+U&}kUDzsr z*b*l$LCol4$Q2tuD92iFWJ4nJRJ~!o|L%)8ccvN>gFQ>xl~^)sC!JaO@p~E`^VR%o z)VEdtW0OemhSI^SY-ZI-mA$CHgm-(@xsBCzn?N!NkX;%3kY7EWhKWC0chawKUS^Bl zC}>XQ%P=y#KNPg6|b3TPAI4f4A=jD<+t4;ZwJ zZ=qHaUyUOQGlf_MeAy&viA#$9;soBmA<7bkt7>U^=k+WRBQKCRDjKVL^2q5D_ux`) zr{XIxsDLO4_J0NXi30PGzxln=?n&USG2VRJQ4$&MNfN1Fl1{}5v1v6W@Jc@VC<;1o*A&8ZWKnJz@OJPhDe zLOF?`o{BF|&I~a!98w+v7nAkIxP;=Ybz6&kk|_4k{Yh>cSknleS2v5vej>pY3_fCd+*a4Xl*DuFu?l{;#4okRMMdb{bv|uaYsRYKI`l!U z|M&3{YzTl7XLIfaAVF?bPUIwtDc=8#E5K!>jnuC`H3%e`ebQ?NoJ~5w%3@n}XOpzC zO&s(45>X^{u|6Ig4Ub$gvouDepTE)c3bRm{o&!koK0Au!6Q>wXbQXGkwlqKJTP?+%v0U^IkzrdB`%qK4b(Po1fLC19an;`W7<|ZA?*V&wzKD`)RA&y(WWxciK&le6_ZUv0{uU zD+2lw&-xI6yB5M#@}fY7bk8GJ9fU1%XuV)h1|iw3O>?w;-pAdR@XuCX6HYq%j0TVK z-K5z*77k=@zl;{>K#BrrRRC zh_3?REsMQu<*sm3nzHVJvRM|Wz-Ocd`dP_%-~ICroAP-c?zw3 z7A6g_YQ!2szfODz0e&W%^SA)hX19d}3e5XvyS`EwiR-RZhR*>H2lb7|+8aos-s|bV zNA}DRU$%bf6syx|-H}2%@5qc)bR$`Z*~9%84qo4a z!TpIw)1C)bje)2WFC(^TQnIK@xVv>Vls|bg>iLbB@#C}Sp1xdA6M@BpI^ zxiP%CY^3if*iWM8n`^WF80Jnv-u8Mge(%#~{DfH2V>wYS{_YV@xF6w9tXy1{`4fO9 zu`D^uSmr-FkEc{I$eI2|&c|LVx{ob`pwd;1m^#`-I}(OQyvkTxDnmLt#v>3e;Ms@6 z8^>_oSSbI3(8R=u*Tq3lyT#wG6jU(!2DW$O8?_zL^7MXxe+d_h!phLhD@>H1T{Kuy{Otlp7T(UwaVqJAR&9 z%#2iwj^5A9=zN13vcFa*O-%?qgG|L`Vo$s-FiVjExu)i3#A;ud zeA7>L2JEI@f#-{rNo|v>1MWKONk^3`qH2cRUxXWgdivO+VY--tOd?m8f8tUo)6;+W zVv!yqsmgE4l21QooIwE~JaTH=fC;P)VnxMCpnM%=M_@7r&L@4VqdXW!|A_kzA>a`` zBPUVRtLy9I89)04-x6r~Pk*IMToN9e)eeRq^gpG@wO4Q$;K&ia zLsMcPJ?0h$_3}yZbBQPn;1ExW7fEKI3d`BgXIF4M9)kj#ngF8CC*ha>C|26ch4e4z zd2qxOV8vS;BbdsAo>3!X7^nx~mH+|qy#`m zf!x8QOCXqbO1#KBfu+T}m6%QDcb=oCz*2>~#c|oLp=op_Z?zIh(j)%u{qUa}c#}1H z%-CylSa1q8*dKWe+Dv!yFdiwG>jzsZ39&=(sK$>&w@fgzi^CD&;4V#Oc$!WNcbbeV zvwp=hTC!Gp)zRvtB8t=0r@&72Q+P+#z(3SXX2O4IdLi`N$1&LB)P(>YMJK@&*%ScCFG#6mV*xmfs zoHCNIJzFs}86n$Jp9hn~FDl+C_CdR%`(HyeY+EOBT5cSFFE9o(wio>_^CVE%N`f`M zP9Ydb`tR7hf8Vah(yjH_y-aF_(_vPLZ$RA%-WMfo)ZuogL8WFdQjCW zRup`9+uopC*JZ^zLqF*HeHh@;L#+PFlvBa)heWVV^d_+?p(2lJxBa6>3gIxBr^s?X zWmO%IcHl_#XU;$&;XujK2$v%tf|Fc1|F%2TybRi;B3^F1zMOHpqi7|(tcrDFPqwGL zV?kMSovuz+vNv^T0{u-IVzPky)M1y@6i7Mb6jVeXTtE*JZKH!Y?H6G3^fo}j0z(45 zl^HdULyIu)57#0{I?U2y+FxL1fr!?4!?rmSRQ=Ep=eLl~D9XBjDR9%ArW9tD0{YM0 z-M`ovR$6EhH_KHePW)DhLj*gVf^JvrcVO<63maakWHnpvIS>6T2yawU;7Q8&x9NKA zhzA3rVX{3=;p2Egak&7wFu)`v`U`@J8R0ZUzJEhBsn?;vAwh|N6%h0GT*$3I?vOU2 z&q|8(31)FFi7_Tktf;Y4o?JsA9r8|yT65oAcG11JvuN&-ee!0fmeqM4f#HHNQ*QqJ zjtAC`eXTGE&4alWfnG05B}AK(6Y6d{Dlcqxq8rOm=J(5rgz5wk19gGUK&C93Krn(t zljwuh#LNYQLvBv0>K~0=_%q^Jg%(WhoJ6Ls!!92)L4H~S>5_5*j|;&S#$(x?LUreZ zqn58pgXHu7%%y?IK>t~Xz=os6>E!1nURRXF5_4}smGNB@bx>2%)_$m!5uHw|j7vC^ zk%?r0lp`+GI{-4P=%;)RA$Lzk(CiF%ts;Sy_|cv8L}*V-6W7l5M8s7K&IrXNeBKr$ zTlOZ?GWO13BO>EbtzVA9w8Liz*U2Cwpc3DtXx~e`tVBTKZ5i=nZ48?ejogX~#Bjm< ziKd5;BPpaN5gY?RpfE{7h&jMuXTY!}MXAV}e*@F!$N=Imm98J*H!AQmXoxpxa0s6Q zkFCWnlqOd%fpin%9jf@$H&yEgL@7`!nUa~X(k;No`!SLTv3qC|Svb^;ahXshEbpnB zaly(4aD^E<=kch1gSy3_k&oMtvjgNRJ8jhv6$zt^9I; zfii!mi2zvc6&1ysROCiODcjXDCLVHh6HAY3KYtj5DN7<86CD_U+c$L;3Hsy0hu1Zv zXDTa?)r3bU8RjiWEI|O;h!Egq67EpK*{yxY`t075C2{VoN&K=zKiHz*Y%$OfUjVJLc@=QXErug(ldGXv+Iby{0!yJ- z8^4Wl%xngus|f)rft#UNwN#UB$kDtlzq1X8Ws%Nor;Nu8FL2#7v1Og`1{t@x#Fc41 z#IL~;8brWX+b(P~zv(A-xf*uRLi;YsTbZsO*n}hLcG+`=yS^D;reXB713)fG5C%? zKxLP{u~c^?5Zjzg&WBRB-l%p=DuZ=pdlJ1WGWm@^3I^&$`T~&L0b%`aBu6~Zq(=B* z!_lqQ=nT{l5ayS*DNUzfl9?*C)aUs^1DGD>Y^0Ew(PN)}e*l*$Wbj+q@Uy+v1z(*!7&*|^-KbyY5a!-y?U z)^aJ$ipjj)`c;pbedfhfvH|sf;@>@6%84Ls{0O7<>P|FCt_pP}8B1vLa{Nf>GkLM` zWzMc8oFJx{9wkL-RE3VSb=3DjEoU0)6=vZ|szDVk7$T)bp@Iu7G*NThMexAKs&yT> zxB<-v4KypetxQWb&I1q+oNNHpnQin$+s8U^3>F)(lueo6T4iU%Io|%!IDNE>w2F5# zx73p$YNLpdV$v2COSv4T2~^~UJohTGVj052XHdDY#Cd~aO2&S<7Ad+gJ4aEUb;Hb| zUgm2izJ5uDSq)Q`tXXpu5SvQ=)ru|$`C;RUB7{}Kx>DsZX=WK)I~@QyuUxO3F-EzS z`bkI?j)WC6?OF|^q|?qq*|c5KS}dI>XBJ2x+llC^O&X1p*RR5=!Rx$g>J+nT__Xf5 zC!nYH{ao}&UwIx9$^#Q=+q;n$6ZXB^Vu9n`7nbuDRgDg?rq& zmHYB_IypE+Ozl~#P5_w2y&EHgVn5Ybs#p!=E9yA%l#mxMVP+&pi%+%v*1Ne9z=4L= zTiTLKo0GSEQ^2q6HM$ zxrKKtJMQ<;IaZoQ#qSOyMeLQ6UG$Qnej-9!|Gy2GlW5INuz(F6ah*ujMKwijQCqYp zUz+n3*Y+!Bu7aab^VAWmnzNs~xN4T!PUqa}#Qk2YLEf90mEmHhl}oDnKBwt4)B0wD z(_XpOKeZP&>FI4Fuw*lPd-2iV2E|#hr)q|7CBF%*DKDPgbnhSC!wHB_6`X`TW|^G5 zQbRTW?wOFVs{)opkV+!mt*Xtu>qrH?V&j^qaVAcH#xWGx)QX1-Zb}<8?E)4e zrt_G%Fv5cvg+O0{U4@NvCQB~5Fq)(ES! zc8WzOo!Z7h5xEB?YS2l9Gq=kthn*`$Kr*u_%n57|E&xnry}}=3K_1&$RpaYdFOMd! z3s*dvt0KSt24?^5Da$(k=N=i>wCQ}9RH4iLv~0I(dK|J<>D^=|v9_*v{22wEQI^|P z$#4PL1sKhJ{TDbWKnB$EqYT9fm1uG*?+6dI0yggd0&s4 zoG^ddM{$C@UOaO3411+;6`iIYg?vzvdMv5)XEv2V)hiJyWpl{c@?uRr5>}3}lZ~vw zRDv!~IHztVJMR_WYmWHLyC{p^FWCHvvM-De`vJpX$SBIIsL8)YG{#J7mg3U?%xM!5 znQZ#h1C2KYcak84Ru$0* zj!9{Ji3Dl0(An-X!H$r@cI&@VI)L~nFF!|fEe3TRE}g7_1^C^)4L=c6dU6HzyMDZy z3kx&xXUQguEVG!&wYSJGIi~uFVJmd zs82-YgDN=Z=JL$sDp<=jHTL1o&D3p^BC*aE^Ni%SS<5xaeQ_3Nr~|;!msKvHL?pek=Rz})RCR(c%!zIAGq|X9@I#yrfx-RKE*lw6z zMEn6j&Y`d^EEl>)nUP6*`aL{a2La-IJSzDv%}Bl0RJPjG)5tEI!G0kM(GhBOCIE^nx3ZiX z5UZq=Mzkc==Jo=y6&aNFczA(XwwDRhiK;F=WxbQj{RCQ(oJhXZb=NEypAdb$E0LVc z{?&kChW(CgEul2CB2B86zF_J_iQ%G0C_~)5HTcMEd+Od^LQ!B2hAFb?F8TwOzX3fs zbW*v%3d^i}vgof&$Mb(oo&XSeyrvAvQfGG!?uRK@_tlGH2d_OzrWs_7W)ALkqKve--Y=Ks$ zpKL;#I3PHJ4^2a2=}}5Q3Z=9YWz%prrvQ0-MH{X$4lF`jcxwR-5Wqeo4&tDoE>|W( zvR;_qMrTandL|@DI#UJowlPu#8D+pS&(|ei5C{F9^(SynNIXbBVrsH@FYF%1Bd}LOPyhOOiPSc9QHe8)N|(ft`6zQ@#pfHA)H;>Z z8D5@5`%OqcznW6}&T{w!`A)O9?!jJ`jeK!(Y4mk*6JYCH?;=ui)*`aFpVXu0)ux>W`TO1$Rt6 z!Hv5RZ!KOriP5V^WIL?aXaYa{rj*&7-;^Ffco?*|ZDCKE6IG)C&ilqL2G7OC8ym+Q zwL=}%56Ij32Lk31m_V};(SdhlF7fQ0U!?*l%zcOv;mfPJJ{`y$RZ2b4$|c0uE5;7m4)IbK#2W1z)|2{Cw+Hj< zTVrPv`kA7A3S8lyt#yc?l@!sN9Qnz_xr#xz|~J_ZJ<*&*!>9r zZYSFxidZ{;c?Cc7L7enD_jk9uW8uh(>$G|E%c|v9#xq6(D_f>=wOiWXiYnoenrRmC zC3NR!cxOY-4Vw9?UlyqZ?IUIOcH`O)Tbn-i$4AZN9jtTJ5np+-kK(_;UoPgU#te=@ z!VYkX_!P8*x&+LdV{Ywt^v5hR=tQpo%n4y!azA^quy8OntAo+XbxXstw3q;>z#oxA zXgoGI)2CEuvbbfBYI3`PO+!bkLPYQQ;_+vTf|KW~_tGXqL{Kf270WvubfImwnDqm}N@3r{j;PYL@#Uo?G;NZ9E$gha0rzYe0?c)C{k1FbJB}u;Lr(BUhlOyMZ!J%P(cq95y*1xq^`oVunwdo#-bLK#4wUB z|NDNkT6l6Nk{{O4WYH(gZp5cG8p&u<+UJx&WGhh^gfRi)omW0cl&%&l{l~}G4%Bd( zV{!NkH-FR)C0(QKRb$V{5e^M6-c%G;%%!eG1{jB$OMit-S<#xe<3}Xb-1o?&R0*Z@ zbciS~55>OVhZzG;r&h2z-x+f@fDu@ZTANd5{} z5erdWX0ZL4m4fVw#M`f})B(Qh!t$b(KPet~F0@ILj2r-A17c|U{p^ZKM>(3u>REQA z_lay+I$zk%&nt=}Q_Pt2#F()V-Hs)5dRoyZw75=jlSz>xN=^4kUg`y<-{)WHk)q?W z<6^#SV+((IXX;%v0UfvPVNs-_84@i0|Q-8wDDJtf$;( zQH2H9@e8CBp>iIt38tXHf6Tz#6YO;lhs-p9s0@hY&i3+&2=v4~j{F%DnjUQzCX^T8 z*tg2)e$QTliVnt{0YX%^+_s~~8DQJ1D^iE?)c`(%gEZ#OC@g5bvsKb>0wIqdvPjt^ z7!!JN|1H{asL0?@8Dsuv2@<5-N*|h(FKVc=yj0m^&6cbiFQLaGBX(%Fhkgjqpv^&1 zyL$}xrKEz~vf0S8u2l+`&Uvo)V7n~(Q2EoAM#*e+BXZjn$@b7E6hkYO`XdqAIbb+I zfeisv%XYaeRWYg?^*sfebPx0aw=Q-1~+U7R8H)$?2ASG@422b#+WZeu`jmJ?Drkb)fY@-5b2^_|G7KqQ z1oo#;I&sjJTHVdI5oOkSGrFKpd3`4!t*w_l!8_w-v8o-O{*-c?)o@C?bI_OH!MK&} zECaEg(L=}dg@kAxR3$k5wmTad^zO=AW)W6^lxNY-V{}+cC{#v0D=!!oaOP{z?}@tw zg8>p?LGTeF1jNd}>_+Wd8pV93)>hl1NKhM@nEn39UC79D+qDXs+W9!o-!ul`;}(bS z78L3<&jmpWa9iJHs51R4E#r@s|!$z-=szGLQA`F&0mR@ zUEy$+6qyB|9pubKJ!0p}S?O{Eu@0acn z&1@l9hT+jFupMAJL!;u>Gx+`o!VtkFJMQGH5e0@Vz3<>L1$*Mt$oRRWj#jIJZKEVU zAR)MZUqf#QySZh|+}-MHJrgta_Lb8=5fp#{*5KB<`!2={PY4k`jU*5lDwPj3Qf~r- zYIKeOMd~M&{yPQ%AcQJ`=MNl9WvGi>729UF2u4~;TMHx6?Tpk;U-(-jc%!G@XyII-JI{u)|q4P%jhpMr$ti%EGa)(LqtL*$sCER8`GgP4M}JI;?XqF9MD#BhQ)Hl zo1{@jjUyJd+x^V>HApY!H>u}0U{7F`K;=zeS*#iCm?ZmBKqhplyz;`;JTYtBG#oT} zKi$719h)@yB{PRelqUD&q(c31=oNeGmKf)WO>kHHjP3q^Cx)+X#$IH`$!pXVyukN_ zf^m{By@a=ntZM3e!vhY^Kqi}T3*{F;^fG#_wHTe3Y-<_H zOB>Ur=lPmI#cu{kpAHXIKQ03@mX@tj*@-x|V^1Y>VKUvd)L3asy5LspxNE4Ls_71R#QhW?qKOo)ZhT^mZun>TH4lNo(X4>& ze^Ec1tNtfC5gwZ$&Lr4KBuhS`|F^5cAKsNn-aNHK6( zB~4lnWm|MzawmV+6(w^1JZGXnATR1CLjQFywF;B%>+{}SNDTnK;lN8XhsBL5^p>YhZ(RU)WzFxb}s zCbbF$4zfP_S017dVh@JpnZIXQ1W7k6)f5clSR+iEp8EyQjHtjR%omOh?aBjSqa5Dy zhcba6(h6Q>&ZFdvf2GKUS`?R<;k@q$?h_G6G`+x_@2NDh7=u_A!``eLCtEhgKw$~n z%=$YsY&@>>bUVb101gb@4~;wxR0@QI9@4>s-w}q7u-sAEOEP3K0&h)titmXe-jn&v z+V=K!CFdDR1qtS12tK=m1SNha&$S zj+8mrtbq(F473(sH}-&Nd_W1g%vf+I^3rb=*cJzHpEr`GPB1iI3yc>u6CXeZOFVRFhnaZD97+KS4O|955JOrq2n15# z6V2D67*ZwExRw=tVZe$JLiijNk2WTLs`w-#O7i7i8hNPd~+4d;gUg(AuBu|uGYQ?EQ^%a2tfZWe3UYLp3J>XPRG|wga z7d%U*L(0$_Y7tx5?&m<_sdKZX*!!YNaO86q>LE`3ttWr1c zXT$;H34T4if#S)+3)^;TPpAF(XFLMJLi9a$NnljfiqB5+4ZB8W>QrKn%G$K;la>NZ zT7eOtFAu3JLNq7;rBQH8a^OK%N&_N-?jZaD_ zj;b9dAG!YMeuxHOYWS@f4q}zfFES!iZ1&{@Jt(Ope4x#O?4$Jk#co;QR#I?F_4_33 z4&d5IBjQSHhMf?o1pF4^0YrLP?o$06KO%BI6D8n{!hWd2q90Q!-;1G8OVzP&q!@l( z8t!oyZKkhhtTf|TRe%oe{0HOuJ==I}f8JFvwFZ-ZOTh(@fht>YL0d$+=E`u2K4&+p zf&xfuuWuLJ%7Hy_pl%dwE*KyhQ)SK%byWu)t>Q+W;<09D{?oB`%%oGKSD#xPzhg&r z^n}JiaKkuL;YZy%;(k)V(|QlS<}e3sT|QLBM3mPKqPaMmNM=<&Pdi@FpTNwl`T}Zc zSb8m0Qk(@?-x>*2xRMe9+gI~l!6b8EvNeye*r0&8g!B|2+aNuJbFy}Y%?kwPVejnE zswhg^L4@rtCzOnlfpB~PUk1S%2NL%n{*Z{N}D;(Wl84)tDB2fk~JdB;(qf`7xiWW(&hKd%(z#Ec5 z1vbl~Xz8(%3Ob=)4Rh=E=UeFn+WI(N`L85fo6&wZeQqF!%*i40)|BVE=?Gk!O@E`1Bc1DVlNjM_A0* z0RIqhi+4Hc@H-B(6%OK!imDlBOz|ZEUM>0HodEV%2UAbiw{-GZK|LuwNIW}B*%ryu zEf$b4v7j>HxVm}#DJ*ifU;(p46Ow<5*2WEJ7o=|frp5oAkalh zk|0IuylmbHGd zhd63u(?id)?4yA)ubT<&LUXsi+@zW=Tj$$1rQB1}T`h%K6_`_{(G=R+%#w^(6!}h9 zS16WLgM00825zf&B zmyG+;#i9I_ALZ}>(LU%*=I0Y^SZ7C0c3L7A;piIXod$JuSw{_0rPVVNj&TfI)*s9g zuIrFj;;En%-aO@(c(=UI3y#B0PxjoHQZCPiR*&Vcy`?6x36wPSq{d7O1-=nGC>4b1 zeH@7Zj*jtXu=(*X9uW{P12mENuNoOZ0fT=dUpOW;Iww%6L7>N`gM`ApT*FfAPoLo- zgIRV3msZ=<;0(ELQKnCc|641~wHQ?-&2<>=j{ZXGLQ_4b;nr6rgan8?F~5MN zW`=r7SAk~M)<*4hRKb9gtYR1laFHTZ5zjtwl(Hpd6?0TIRmC@!=n3b=f+#7iw3^)0 zqK?`Bgm5)c#c+d#V0bGqzq_6M+3>72Z?~);H z#1ITd+8am)2+sFN4~>}r9?{@6mxE0EV=q2kq@P^8=5gb1tcHv6Ow7Hw)JlGi6h%Ww z9>Tv&m69aXXK|%fk>JWDeKIrBWNS&p`)X7V=K zT%Nnr=+%Xj=&NRkhtW$)tvc5o`_1f>k=6t%!-i%*d5%s7fd?CbN>`s4S4_eQnSf1! zX&Lt&?!Y4s1j92jD=Y+{4VJooDBCeY?vo34z#wwkDC%qE{tk%>zlDO}H$fG-(Y43K z!_V;mg}6spyohRLPfzac3Ktrf(9=`4SKD3`YP(F*9#Uu%A^43WN<;&ys_Z18P%|Ok zfXQxQe_SZ2+zkn*b$n6>jMymrydmPKmIAh|;X)4*4T%v~5Q+v!iX^nnNK(^dYt~Jy zQE1D^M&F&ySuZsShHr<3xob$_<2yw3_zkt83_ClitTkG=$dx}W_G9SSTMs@M_UFI_ z8}r9W1fAEbpyMjhJ=o6Wb$j#n>&Jkv1hf@~0E%2*x+4@{1K>>htCHT?O)ue+))ZIG!kRlOWdFXQ z814Twh_lld7E3zi7$X`E%*by{EEIOy#l@2wmnRgC8q5J$gl7a!mR9zdeEr)i5c&i} zIN+7A-V8DK$&A!G@FaYG3sUbz7u85+W5p#hJ|o>B-p&QeL+Enl(r3%3O`jx`KAbTv z@Wf8Cc=pTQ)n>n;X5-%sm6uJFE*veK-JiLa9irxx?-qTDD!s$bO9h-I7y1?k zDi!w&fnt$eS%!1vpC>F4%mXzz=jW@@iY?eorIa5bxtyBE6CiZWc`7PwYjzl zR0hUT1r;BlA?Jh(kLjNd*er_$vos7{{VizJ^-2b~|HpJoLhndP2~WnrAs~$!nZyC& z0JdU)JI~qI_s*y8m%N~i6Vy*>Z zc_2XXs*-EAVERQVZJECh8n^6U9YHae)5BbiFZ9AA!W0z0`083P)QCp*9P9Kad3e4i zVx?8}IGQjrDAfISXAS}< z*RDrwWHN=Ut5CZGHGFpCfdi(KJM4`CM|mya_4LJW-XV0r#bTAM_`RyS&OJcwq|`J( zZ9iPJkn}%cr69nGl!+l$eOY0Xp3W zjF8X*tttS6*b-kY63f&E7Zys;hpa}(2YcRvN!3hP=<|6V-u!qzf$b|cul5(2X+1lj z)8ZEI+3ei^tL?MsfLE4t9cX;NV0pps=9gexVq9?8{YOO@KjWKJ@7-dUe*P{|btE^m z33ZUJRH0o@yba0R->lKhUsibT(OrI%>&!GdIsk9}j9?4mHgy~D^dIN9Prg#g7}!VX z0ro(y1*IP{rbPE+e!r$VF^g+B!>?38p0!Xx_b}~e9eJ%ZFddw*AGMPk?}KovJSj!- zG-%0kr`{|3VO@Sm!A@rqLMG$bB&QwuzD>v{-BJj_#_r9yrx*4@Zhm!hyd0#f@DRYr zNs?rrlmne8mq?A?$QVR2Wr>~K>ROE(m0#8>i*?2^tz+!OL!B8&mN{nR!)pe>DL{<) z*+HV|GDaKFe>7VpT4#311J*}`mG$~)G^MyuQIiGbZAf?8)YrJO(R?P`ya241`zJRo zM7B2KC4174!`*X`U zH@cGQh>^$`u5>7kHHpQ#6h26QgMLFHMXI7$6k*_yr#C@dUS1z8rhETiYjXJJy#(Gf){W2<;>K1%;zm zeTbs@F>xk{jkaOLH$T%<&VzPk%e0ME`Hm{cKb^vEtGe&uBDg6Ev7lFm42{uySrE@` z{`zDXfzZ94MKFsg2Fw7MDA;pLUJ!`f(zH5EqWaZQ$iqbTs-Aret0&57oOn@L%g2`A zL<42$&7MyGCMg|uP&Rb1LF?*|&Ed8dlf9;W=KJ%M!Idj#&>HzjG56CEKQ*9odvD&l z^DNfy9@cWFCZsk_db4DS?ahOMO>fY+0J~EVi*_>xJCG$8cfDqY z7=_3{ByJFDve@OC*J6Mu|HV<9)-)MJ<$1N==TZu@1SVs4mbO4o-zU4NdwIN}^(B3& zITM_nlbqb646*ONs?zs?*KrKztbjgDs6CIgMrl_7Rj^_dqwo$M{*p!PQjxwn$3+*x zuki2Oss{{4E#{|qeqeRKaY$aed-Dj6fnc}*yx0~zCd^cd0$NXMIEkf)_;w#NTZI;1DD?%` zOM87PQ~eH9gNy6KXsT#&{KBZdDKhNhQ~nH8<31{bev!RYF~}FvPKS1->X{{9N=Zqd zxD|=^{!Mz5h6ur=T-}B;q3H=B27Cb$+BJN)_I5e;{vfa%iV!9eCwweGI)@vw8WdpZ z2MT|=Jh}@2`uSs^Fu68-YPHmzhqxFs2guk;Rge1{$q0?($Z zaRjW!nsJ2el{DJB*8C}lhRwJKWTa{VBqgIu9JsXC~9|7UlGrAgDBqS_hU~W zcvH<2|a^x7A!|=?|tigAj2lZ^QbSLdn$q0*8W>Bi_ev3IG8;=O?Tc< zVx|hz)LCYzLRgojY=T`z`Uoh;;l-$3^0djIUD__0u~V@(cpUB9Pj8$1mqrndj9V^@ z@Z(h#J|84t+RKH`|CzK|bByT=r}>4Sq4K5MB=r2?=5WQG zKX=7S>TkN0`=6blA{!3RE2gp16q&L%y)PPvy`JAcOzQQr!A5ORZxQ#CdMR#g+;F`n zj*J>^Z{n~JW`jSR*Z;NJk;!tNcg)2tw*hcimL5*h``L14J9snN-Ot1sT9k2f^+rp4 zOq|CbHYFavDz_$Wp0^yUp`+X)k<+rbFU46Ov~KzxuV0Ys&$6Rr9^)5>v@&DCU0KSA z;2H|kuDZW1L_be513#t|i~lu2J+DmzxIl_8k@HeZBkBnk`sIE`y?z@dQnPyId_ZbM z5G;!uNQ$pk>H2+wxbKlUTt75ee?YAIVvxm^+U*32iM!SpUe4)(RIa^dVZGm+Zl|L! zUNP-V>H-qyzlL%B4io J<21p6{s%Pu=r{lX diff --git a/chain/types/ethtypes/eth_types.go b/chain/types/ethtypes/eth_types.go index 69546844b65..cb629f8d54e 100644 --- a/chain/types/ethtypes/eth_types.go +++ b/chain/types/ethtypes/eth_types.go @@ -19,6 +19,7 @@ import ( "github.com/filecoin-project/go-address" "github.com/filecoin-project/go-state-types/big" builtintypes "github.com/filecoin-project/go-state-types/builtin" + "github.com/filecoin-project/lotus/build" ) @@ -191,24 +192,6 @@ func (c *EthCall) UnmarshalJSON(b []byte) error { return nil } -type EthTxReceipt struct { - TransactionHash EthHash `json:"transactionHash"` - TransactionIndex EthUint64 `json:"transactionIndex"` - BlockHash EthHash `json:"blockHash"` - BlockNumber EthUint64 `json:"blockNumber"` - From EthAddress `json:"from"` - To *EthAddress `json:"to"` - StateRoot EthHash `json:"root"` - Status EthUint64 `json:"status"` - ContractAddress *EthAddress `json:"contractAddress"` - CumulativeGasUsed EthUint64 `json:"cumulativeGasUsed"` - GasUsed EthUint64 `json:"gasUsed"` - EffectiveGasPrice EthBigInt `json:"effectiveGasPrice"` - LogsBloom EthBytes `json:"logsBloom"` - Logs []EthLog `json:"logs"` - Type EthUint64 `json:"type"` -} - const ( EthAddressLength = 20 EthHashLength = 32 diff --git a/chain/types/message_receipt.go b/chain/types/message_receipt.go index d133c84ce47..0507ac576f3 100644 --- a/chain/types/message_receipt.go +++ b/chain/types/message_receipt.go @@ -54,6 +54,6 @@ func (mr *MessageReceipt) Version() MessageReceiptVersion { } func (mr *MessageReceipt) Equals(o *MessageReceipt) bool { - return mr.version == mr.version && mr.ExitCode == o.ExitCode && bytes.Equal(mr.Return, o.Return) && mr.GasUsed == o.GasUsed && + return mr.version == o.version && mr.ExitCode == o.ExitCode && bytes.Equal(mr.Return, o.Return) && mr.GasUsed == o.GasUsed && (mr.EventsRoot == o.EventsRoot || (mr.EventsRoot != nil && o.EventsRoot != nil && *mr.EventsRoot == *o.EventsRoot)) } diff --git a/cli/chain.go b/cli/chain.go index 4da3273d5ac..dced1a1f8a8 100644 --- a/cli/chain.go +++ b/cli/chain.go @@ -1784,6 +1784,9 @@ var ChainInvokeEVMCmd = &cli.Command{ if err := evt.UnmarshalCBOR(bytes.NewReader(deferred.Raw)); err != nil { return err } + if err != nil { + return err + } fmt.Printf("\tEmitter ID: %s\n", evt.Emitter) for _, e := range evt.Entries { value, err := cbg.ReadByteArray(bytes.NewBuffer(e.Value), uint64(len(e.Value))) diff --git a/documentation/en/api-v1-unstable-methods.md b/documentation/en/api-v1-unstable-methods.md index ce6e4eca157..2f9ccf0d017 100644 --- a/documentation/en/api-v1-unstable-methods.md +++ b/documentation/en/api-v1-unstable-methods.md @@ -2443,6 +2443,7 @@ Response: "blockNumber": "0x0", "from": "0x0707070707070707070707070707070707070707", "to": "0x5cbeecf99d3fdb3f25e309cc264f240bb0664031", + "root": "0x0000000000000000000000000000000000000000000000000000000000000000", "status": "0x5", "contractAddress": null, "cumulativeGasUsed": "0x0", diff --git a/extern/filecoin-ffi b/extern/filecoin-ffi index 02ebb2d6169..21217875e44 160000 --- a/extern/filecoin-ffi +++ b/extern/filecoin-ffi @@ -1 +1 @@ -Subproject commit 02ebb2d6169131cfe489e1063e896f14982c463d +Subproject commit 21217875e44f50c3851615de3ced674a6fdc386c diff --git a/itests/eth_filter_test.go b/itests/eth_filter_test.go index edb7c6a87fe..afc3c97ccf0 100644 --- a/itests/eth_filter_test.go +++ b/itests/eth_filter_test.go @@ -12,6 +12,8 @@ import ( "testing" "time" + "github.com/filecoin-project/lotus/chain/types/ethtypes" + "github.com/stretchr/testify/require" "golang.org/x/xerrors" @@ -211,7 +213,7 @@ func TestEthNewFilterCatchAll(t *testing.T) { t.Logf("actor ID address is %s", idAddr) // install filter - filterID, err := client.EthNewFilter(ctx, &api.EthFilterSpec{}) + filterID, err := client.EthNewFilter(ctx, ðtypes.EthFilterSpec{}) require.NoError(err) const iterations = 10 @@ -271,9 +273,9 @@ func TestEthNewFilterCatchAll(t *testing.T) { t.Errorf("timeout to wait for pack messages") } - received := make(map[api.EthHash]msgInTipset) + received := make(map[ethtypes.EthHash]msgInTipset) for m := range msgChan { - eh, err := api.NewEthHashFromCid(m.msg.Cid) + eh, err := ethtypes.NewEthHashFromCid(m.msg.Cid) require.NoError(err) received[eh] = m } @@ -285,7 +287,7 @@ func TestEthNewFilterCatchAll(t *testing.T) { actor, err := client.StateGetActor(ctx, idAddr, ts.Key()) require.NoError(err) require.NotNil(actor.Address) - ethContractAddr, err := api.EthAddressFromFilecoinAddress(*actor.Address) + ethContractAddr, err := ethtypes.EthAddressFromFilecoinAddress(*actor.Address) require.NoError(err) // collect filter results @@ -295,11 +297,11 @@ func TestEthNewFilterCatchAll(t *testing.T) { // expect to have seen iteration number of events require.Equal(iterations, len(res.Results)) - topic1 := api.EthBytes(leftpad32([]byte{0x11, 0x11})) - topic2 := api.EthBytes(leftpad32([]byte{0x22, 0x22})) - topic3 := api.EthBytes(leftpad32([]byte{0x33, 0x33})) - topic4 := api.EthBytes(leftpad32([]byte{0x44, 0x44})) - data1 := api.EthBytes(leftpad32([]byte{0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})) + topic1 := ethtypes.EthBytes(leftpad32([]byte{0x11, 0x11})) + topic2 := ethtypes.EthBytes(leftpad32([]byte{0x22, 0x22})) + topic3 := ethtypes.EthBytes(leftpad32([]byte{0x33, 0x33})) + topic4 := ethtypes.EthBytes(leftpad32([]byte{0x44, 0x44})) + data1 := ethtypes.EthBytes(leftpad32([]byte{0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})) for _, r := range res.Results { // since response is a union and Go doesn't support them well, go-jsonrpc won't give us typed results @@ -310,7 +312,7 @@ func TestEthNewFilterCatchAll(t *testing.T) { require.NoError(err) require.Equal(ethContractAddr, elog.Address, "event address") - require.Equal(api.EthUint64(0), elog.TransactionIndex, "transaction index") // only one message per tipset + require.Equal(ethtypes.EthUint64(0), elog.TransactionIndex, "transaction index") // only one message per tipset msg, exists := received[elog.TransactionHash] require.True(exists, "message seen on chain") @@ -318,7 +320,7 @@ func TestEthNewFilterCatchAll(t *testing.T) { tsCid, err := msg.ts.Key().Cid() require.NoError(err) - tsCidHash, err := api.NewEthHashFromCid(tsCid) + tsCidHash, err := ethtypes.NewEthHashFromCid(tsCid) require.NoError(err) require.Equal(tsCidHash, elog.BlockHash, "block hash") @@ -334,18 +336,18 @@ func TestEthNewFilterCatchAll(t *testing.T) { } } -func ParseEthLog(in map[string]interface{}) (*api.EthLog, error) { - el := &api.EthLog{} +func ParseEthLog(in map[string]interface{}) (*ethtypes.EthLog, error) { + el := ðtypes.EthLog{} - ethHash := func(k string, v interface{}) (api.EthHash, error) { + ethHash := func(k string, v interface{}) (ethtypes.EthHash, error) { s, ok := v.(string) if !ok { - return api.EthHash{}, xerrors.Errorf(k + " not a string") + return ethtypes.EthHash{}, xerrors.Errorf(k + " not a string") } - return api.EthHashFromHex(s) + return ethtypes.EthHashFromHex(s) } - ethUint64 := func(k string, v interface{}) (api.EthUint64, error) { + ethUint64 := func(k string, v interface{}) (ethtypes.EthUint64, error) { s, ok := v.(string) if !ok { return 0, xerrors.Errorf(k + " not a string") @@ -354,7 +356,7 @@ func ParseEthLog(in map[string]interface{}) (*api.EthLog, error) { if err != nil { return 0, err } - return api.EthUint64(parsedInt), nil + return ethtypes.EthUint64(parsedInt), nil } var err error @@ -379,7 +381,7 @@ func ParseEthLog(in map[string]interface{}) (*api.EthLog, error) { if !ok { return nil, xerrors.Errorf(k + ": not a string") } - el.Address, err = api.EthAddressFromHex(s) + el.Address, err = ethtypes.EthAddressFromHex(s) if err != nil { return nil, xerrors.Errorf("%s: %w", k, err) } @@ -453,7 +455,7 @@ type msgInTipset struct { reverted bool } -func invokeContractAndWaitUntilAllOnChain(t *testing.T, client *kit.TestFullNode, iterations int) (api.EthAddress, map[api.EthHash]msgInTipset) { +func invokeContractAndWaitUntilAllOnChain(t *testing.T, client *kit.TestFullNode, iterations int) (ethtypes.EthAddress, map[ethtypes.EthHash]msgInTipset) { require := require.New(t) ctx, cancel := context.WithTimeout(context.Background(), time.Minute) @@ -525,9 +527,9 @@ func invokeContractAndWaitUntilAllOnChain(t *testing.T, client *kit.TestFullNode t.Errorf("timeout to wait for pack messages") } - received := make(map[api.EthHash]msgInTipset) + received := make(map[ethtypes.EthHash]msgInTipset) for m := range msgChan { - eh, err := api.NewEthHashFromCid(m.msg.Cid) + eh, err := ethtypes.NewEthHashFromCid(m.msg.Cid) require.NoError(err) received[eh] = m } @@ -539,7 +541,7 @@ func invokeContractAndWaitUntilAllOnChain(t *testing.T, client *kit.TestFullNode actor, err := client.StateGetActor(ctx, idAddr, head.Key()) require.NoError(err) require.NotNil(actor.Address) - ethContractAddr, err := api.EthAddressFromFilecoinAddress(*actor.Address) + ethContractAddr, err := ethtypes.EthAddressFromFilecoinAddress(*actor.Address) require.NoError(err) return ethContractAddr, received @@ -558,16 +560,16 @@ func TestEthGetLogsAll(t *testing.T) { ethContractAddr, received := invokeContractAndWaitUntilAllOnChain(t, client, 10) - topic1 := api.EthBytes(leftpad32([]byte{0x11, 0x11})) - topic2 := api.EthBytes(leftpad32([]byte{0x22, 0x22})) - topic3 := api.EthBytes(leftpad32([]byte{0x33, 0x33})) - topic4 := api.EthBytes(leftpad32([]byte{0x44, 0x44})) - data1 := api.EthBytes(leftpad32([]byte{0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})) + topic1 := ethtypes.EthBytes(leftpad32([]byte{0x11, 0x11})) + topic2 := ethtypes.EthBytes(leftpad32([]byte{0x22, 0x22})) + topic3 := ethtypes.EthBytes(leftpad32([]byte{0x33, 0x33})) + topic4 := ethtypes.EthBytes(leftpad32([]byte{0x44, 0x44})) + data1 := ethtypes.EthBytes(leftpad32([]byte{0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})) pstring := func(s string) *string { return &s } // get all logs - res, err := client.EthGetLogs(context.Background(), &api.EthFilterSpec{ + res, err := client.EthGetLogs(context.Background(), ðtypes.EthFilterSpec{ FromBlock: pstring("0x0"), }) require.NoError(err) @@ -584,7 +586,7 @@ func TestEthGetLogsAll(t *testing.T) { require.NoError(err) require.Equal(ethContractAddr, elog.Address, "event address") - require.Equal(api.EthUint64(0), elog.TransactionIndex, "transaction index") // only one message per tipset + require.Equal(ethtypes.EthUint64(0), elog.TransactionIndex, "transaction index") // only one message per tipset msg, exists := received[elog.TransactionHash] require.True(exists, "message seen on chain") @@ -592,7 +594,7 @@ func TestEthGetLogsAll(t *testing.T) { tsCid, err := msg.ts.Key().Cid() require.NoError(err) - tsCidHash, err := api.NewEthHashFromCid(tsCid) + tsCidHash, err := ethtypes.NewEthHashFromCid(tsCid) require.NoError(err) require.Equal(tsCidHash, elog.BlockHash, "block hash") @@ -623,14 +625,14 @@ func TestEthGetLogsByTopic(t *testing.T) { ethContractAddr, received := invokeContractAndWaitUntilAllOnChain(t, client, invocations) - topic1 := api.EthBytes(leftpad32([]byte{0x11, 0x11})) - topic2 := api.EthBytes(leftpad32([]byte{0x22, 0x22})) - topic3 := api.EthBytes(leftpad32([]byte{0x33, 0x33})) - topic4 := api.EthBytes(leftpad32([]byte{0x44, 0x44})) - data1 := api.EthBytes(leftpad32([]byte{0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})) + topic1 := ethtypes.EthBytes(leftpad32([]byte{0x11, 0x11})) + topic2 := ethtypes.EthBytes(leftpad32([]byte{0x22, 0x22})) + topic3 := ethtypes.EthBytes(leftpad32([]byte{0x33, 0x33})) + topic4 := ethtypes.EthBytes(leftpad32([]byte{0x44, 0x44})) + data1 := ethtypes.EthBytes(leftpad32([]byte{0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})) // find log by known topic1 - var spec api.EthFilterSpec + var spec ethtypes.EthFilterSpec err := json.Unmarshal([]byte(`{"fromBlock":"0x0","topics":["0x0000000000000000000000000000000000000000000000000000000000001111"]}`), &spec) require.NoError(err) @@ -648,7 +650,7 @@ func TestEthGetLogsByTopic(t *testing.T) { require.NoError(err) require.Equal(ethContractAddr, elog.Address, "event address") - require.Equal(api.EthUint64(0), elog.TransactionIndex, "transaction index") // only one message per tipset + require.Equal(ethtypes.EthUint64(0), elog.TransactionIndex, "transaction index") // only one message per tipset msg, exists := received[elog.TransactionHash] require.True(exists, "message seen on chain") @@ -656,7 +658,7 @@ func TestEthGetLogsByTopic(t *testing.T) { tsCid, err := msg.ts.Key().Cid() require.NoError(err) - tsCidHash, err := api.NewEthHashFromCid(tsCid) + tsCidHash, err := ethtypes.NewEthHashFromCid(tsCid) require.NoError(err) require.Equal(tsCidHash, elog.BlockHash, "block hash") @@ -704,7 +706,7 @@ func TestEthSubscribeLogs(t *testing.T) { respCh, err := client.EthSubscribe(ctx, "logs", nil) require.NoError(err) - subResponses := []api.EthSubscriptionResponse{} + subResponses := []ethtypes.EthSubscriptionResponse{} go func() { for resp := range respCh { subResponses = append(subResponses, resp) @@ -774,9 +776,9 @@ func TestEthSubscribeLogs(t *testing.T) { require.True(ok, "unsubscribed") } - received := make(map[api.EthHash]msgInTipset) + received := make(map[ethtypes.EthHash]msgInTipset) for m := range msgChan { - eh, err := api.NewEthHashFromCid(m.msg.Cid) + eh, err := ethtypes.NewEthHashFromCid(m.msg.Cid) require.NoError(err) received[eh] = m }