From 88afc69f4b9496d3c7d1c8c8d263d32979ca5ebf Mon Sep 17 00:00:00 2001 From: pkieltyka <18831+pkieltyka@users.noreply.github.com> Date: Thu, 11 Dec 2025 19:10:48 +0000 Subject: [PATCH 1/6] [AUTOMATED] Update: proto/clients/relayer.gen.go --- relayer/proto/relayer.gen.go | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/relayer/proto/relayer.gen.go b/relayer/proto/relayer.gen.go index f925295b..bab9f209 100644 --- a/relayer/proto/relayer.gen.go +++ b/relayer/proto/relayer.gen.go @@ -4238,11 +4238,10 @@ var ( ErrRateLimited = WebRPCError{Code: 1007, Name: "RateLimited", Message: "Rate-limited. Please slow down.", HTTPStatus: 429} ErrProjectNotFound = WebRPCError{Code: 1008, Name: "ProjectNotFound", Message: "Project not found", HTTPStatus: 401} ErrAccessKeyNotFound = WebRPCError{Code: 1101, Name: "AccessKeyNotFound", Message: "Access key not found", HTTPStatus: 401} - ErrAccessKeyMismatch = WebRPCError{Code: 1102, Name: "AccessKeyMismatch", Message: "Access key mismatch", HTTPStatus: 403} + ErrAccessKeyMismatch = WebRPCError{Code: 1102, Name: "AccessKeyMismatch", Message: "Access key mismatch", HTTPStatus: 409} ErrInvalidOrigin = WebRPCError{Code: 1103, Name: "InvalidOrigin", Message: "Invalid origin for Access Key", HTTPStatus: 403} ErrInvalidService = WebRPCError{Code: 1104, Name: "InvalidService", Message: "Service not enabled for Access key", HTTPStatus: 403} ErrUnauthorizedUser = WebRPCError{Code: 1105, Name: "UnauthorizedUser", Message: "Unauthorized user", HTTPStatus: 403} - ErrInvalidChain = WebRPCError{Code: 1106, Name: "InvalidChain", Message: "Network not enabled for Access key", HTTPStatus: 403} ErrQuotaExceeded = WebRPCError{Code: 1200, Name: "QuotaExceeded", Message: "Quota request exceeded", HTTPStatus: 429} ErrQuotaRateLimit = WebRPCError{Code: 1201, Name: "QuotaRateLimit", Message: "Quota rate limit exceeded", HTTPStatus: 429} ErrNoDefaultKey = WebRPCError{Code: 1300, Name: "NoDefaultKey", Message: "No default access key found", HTTPStatus: 403} From 3912c35a7cf45dc40e4e4bd79387b9034805d4cd Mon Sep 17 00:00:00 2001 From: taylanpince <12650+taylanpince@users.noreply.github.com> Date: Fri, 6 Feb 2026 22:50:33 +0000 Subject: [PATCH 2/6] [AUTOMATED] Update: proto/clients/relayer.gen.go --- relayer/proto/relayer.gen.go | 51 ++++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) diff --git a/relayer/proto/relayer.gen.go b/relayer/proto/relayer.gen.go index bab9f209..2a38f153 100644 --- a/relayer/proto/relayer.gen.go +++ b/relayer/proto/relayer.gen.go @@ -1194,6 +1194,57 @@ func (c *relayerClient) RepairSender(ctx context.Context, sender int, nonce uint return err } +func (c *relayerClient) StartSender(ctx context.Context, sender int) error { + in := struct { + Arg0 int `json:"sender"` + }{sender} + + resp, err := doHTTPRequest(ctx, c.client, c.urls[14], in, nil) + if resp != nil { + cerr := resp.Body.Close() + if err == nil && cerr != nil { + err = ErrWebrpcRequestFailed.WithCausef("failed to close response body: %w", cerr) + } + } + + return err +} + +func (c *relayerClient) StopSender(ctx context.Context, sender int) error { + in := struct { + Arg0 int `json:"sender"` + }{sender} + + resp, err := doHTTPRequest(ctx, c.client, c.urls[15], in, nil) + if resp != nil { + cerr := resp.Body.Close() + if err == nil && cerr != nil { + err = ErrWebrpcRequestFailed.WithCausef("failed to close response body: %w", cerr) + } + } + + return err +} + +func (c *relayerClient) ResetSender(ctx context.Context, sender int) (uint64, error) { + in := struct { + Arg0 int `json:"sender"` + }{sender} + out := struct { + Ret0 uint64 `json:"deleted"` + }{} + + resp, err := doHTTPRequest(ctx, c.client, c.urls[16], in, &out) + if resp != nil { + cerr := resp.Body.Close() + if err == nil && cerr != nil { + err = ErrWebrpcRequestFailed.WithCausef("failed to close response body: %w", cerr) + } + } + + return out.Ret0, err +} + func (c *relayerClient) GetMetaTransactions(ctx context.Context, projectId uint64, page *Page) (*Page, []*MetaTxnLog, error) { in := struct { Arg0 uint64 `json:"projectId"` From 38c89421ddf8c4e566ca7c08c414495b01e13122 Mon Sep 17 00:00:00 2001 From: attente <17548+attente@users.noreply.github.com> Date: Fri, 27 Feb 2026 15:48:00 +0000 Subject: [PATCH 3/6] [AUTOMATED] Update: proto/clients/relayer.gen.go --- relayer/proto/relayer.gen.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/relayer/proto/relayer.gen.go b/relayer/proto/relayer.gen.go index 2a38f153..9e33afcd 100644 --- a/relayer/proto/relayer.gen.go +++ b/relayer/proto/relayer.gen.go @@ -1199,7 +1199,7 @@ func (c *relayerClient) StartSender(ctx context.Context, sender int) error { Arg0 int `json:"sender"` }{sender} - resp, err := doHTTPRequest(ctx, c.client, c.urls[14], in, nil) + resp, err := doHTTPRequest(ctx, c.client, c.urls[16], in, nil) if resp != nil { cerr := resp.Body.Close() if err == nil && cerr != nil { @@ -1215,7 +1215,7 @@ func (c *relayerClient) StopSender(ctx context.Context, sender int) error { Arg0 int `json:"sender"` }{sender} - resp, err := doHTTPRequest(ctx, c.client, c.urls[15], in, nil) + resp, err := doHTTPRequest(ctx, c.client, c.urls[17], in, nil) if resp != nil { cerr := resp.Body.Close() if err == nil && cerr != nil { @@ -1234,7 +1234,7 @@ func (c *relayerClient) ResetSender(ctx context.Context, sender int) (uint64, er Ret0 uint64 `json:"deleted"` }{} - resp, err := doHTTPRequest(ctx, c.client, c.urls[16], in, &out) + resp, err := doHTTPRequest(ctx, c.client, c.urls[18], in, &out) if resp != nil { cerr := resp.Body.Close() if err == nil && cerr != nil { From 0498dbc3acaa993513385a71163fca84f7538111 Mon Sep 17 00:00:00 2001 From: attente <17548+attente@users.noreply.github.com> Date: Mon, 2 Mar 2026 16:49:11 +0000 Subject: [PATCH 4/6] [AUTOMATED] Update: proto/clients/relayer.gen.go --- relayer/proto/relayer.gen.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/relayer/proto/relayer.gen.go b/relayer/proto/relayer.gen.go index 9e33afcd..b7f9c8f9 100644 --- a/relayer/proto/relayer.gen.go +++ b/relayer/proto/relayer.gen.go @@ -4289,10 +4289,11 @@ var ( ErrRateLimited = WebRPCError{Code: 1007, Name: "RateLimited", Message: "Rate-limited. Please slow down.", HTTPStatus: 429} ErrProjectNotFound = WebRPCError{Code: 1008, Name: "ProjectNotFound", Message: "Project not found", HTTPStatus: 401} ErrAccessKeyNotFound = WebRPCError{Code: 1101, Name: "AccessKeyNotFound", Message: "Access key not found", HTTPStatus: 401} - ErrAccessKeyMismatch = WebRPCError{Code: 1102, Name: "AccessKeyMismatch", Message: "Access key mismatch", HTTPStatus: 409} + ErrAccessKeyMismatch = WebRPCError{Code: 1102, Name: "AccessKeyMismatch", Message: "Access key mismatch", HTTPStatus: 403} ErrInvalidOrigin = WebRPCError{Code: 1103, Name: "InvalidOrigin", Message: "Invalid origin for Access Key", HTTPStatus: 403} ErrInvalidService = WebRPCError{Code: 1104, Name: "InvalidService", Message: "Service not enabled for Access key", HTTPStatus: 403} ErrUnauthorizedUser = WebRPCError{Code: 1105, Name: "UnauthorizedUser", Message: "Unauthorized user", HTTPStatus: 403} + ErrInvalidChain = WebRPCError{Code: 1106, Name: "InvalidChain", Message: "Network not enabled for Access key", HTTPStatus: 403} ErrQuotaExceeded = WebRPCError{Code: 1200, Name: "QuotaExceeded", Message: "Quota request exceeded", HTTPStatus: 429} ErrQuotaRateLimit = WebRPCError{Code: 1201, Name: "QuotaRateLimit", Message: "Quota rate limit exceeded", HTTPStatus: 429} ErrNoDefaultKey = WebRPCError{Code: 1300, Name: "NoDefaultKey", Message: "No default access key found", HTTPStatus: 403} From d408a569b54c888a7e224858ca6e4f44568a9fce Mon Sep 17 00:00:00 2001 From: attente <17548+attente@users.noreply.github.com> Date: Mon, 23 Mar 2026 14:02:40 +0000 Subject: [PATCH 5/6] [AUTOMATED] Update: proto/clients/relayer.gen.go --- relayer/proto/relayer.gen.go | 35 ----------------------------------- 1 file changed, 35 deletions(-) diff --git a/relayer/proto/relayer.gen.go b/relayer/proto/relayer.gen.go index b7f9c8f9..0b7889f8 100644 --- a/relayer/proto/relayer.gen.go +++ b/relayer/proto/relayer.gen.go @@ -1210,41 +1210,6 @@ func (c *relayerClient) StartSender(ctx context.Context, sender int) error { return err } -func (c *relayerClient) StopSender(ctx context.Context, sender int) error { - in := struct { - Arg0 int `json:"sender"` - }{sender} - - resp, err := doHTTPRequest(ctx, c.client, c.urls[17], in, nil) - if resp != nil { - cerr := resp.Body.Close() - if err == nil && cerr != nil { - err = ErrWebrpcRequestFailed.WithCausef("failed to close response body: %w", cerr) - } - } - - return err -} - -func (c *relayerClient) ResetSender(ctx context.Context, sender int) (uint64, error) { - in := struct { - Arg0 int `json:"sender"` - }{sender} - out := struct { - Ret0 uint64 `json:"deleted"` - }{} - - resp, err := doHTTPRequest(ctx, c.client, c.urls[18], in, &out) - if resp != nil { - cerr := resp.Body.Close() - if err == nil && cerr != nil { - err = ErrWebrpcRequestFailed.WithCausef("failed to close response body: %w", cerr) - } - } - - return out.Ret0, err -} - func (c *relayerClient) GetMetaTransactions(ctx context.Context, projectId uint64, page *Page) (*Page, []*MetaTxnLog, error) { in := struct { Arg0 uint64 `json:"projectId"` From 129b9bb59d29382b54b9d29c3aae0d26b74e5c23 Mon Sep 17 00:00:00 2001 From: taylanpince <12650+taylanpince@users.noreply.github.com> Date: Wed, 20 May 2026 15:23:09 +0000 Subject: [PATCH 6/6] [AUTOMATED] Update: proto/clients/relayer.gen.go --- relayer/proto/relayer.gen.go | 2496 ++-------------------------------- 1 file changed, 96 insertions(+), 2400 deletions(-) diff --git a/relayer/proto/relayer.gen.go b/relayer/proto/relayer.gen.go index 0b7889f8..dc14203e 100644 --- a/relayer/proto/relayer.gen.go +++ b/relayer/proto/relayer.gen.go @@ -1,8 +1,8 @@ -// sequence-relayer v0.4.1 bbe47231e764cdbdf21f7181326c5b1709f630a3 +// sequence-relayer v0.4.1 43ed1a26ed167b22a0b0827a8725a0df6fbe6ab4 // -- // Code generated by webrpc-gen@v0.32.2 with golang generator. DO NOT EDIT. // -// webrpc-gen -schema=relayer.ridl -target=golang -pkg=proto -server -client -out=./relayer.gen.go +// webrpc-gen -schema=relayer.ridl -target=golang -pkg=proto -client -out=./clients/relayer.gen.go package proto import ( @@ -35,7 +35,7 @@ func WebRPCSchemaVersion() string { // Schema hash generated from your RIDL schema func WebRPCSchemaHash() string { - return "bbe47231e764cdbdf21f7181326c5b1709f630a3" + return "43ed1a26ed167b22a0b0827a8725a0df6fbe6ab4" } // @@ -82,81 +82,7 @@ type RelayerClient interface { StartSender(ctx context.Context, sender int) error StopSender(ctx context.Context, sender int) error RepairSender(ctx context.Context, sender int, nonce uint64, operation RepairOperation) error - GetMetaTransactions(ctx context.Context, projectId uint64, page *Page) (*Page, []*MetaTxnLog, error) - GetTransactionCost(ctx context.Context, projectId uint64, from time.Time, to time.Time) (float64, error) - // Legacy Gas Tank - GetGasTank(ctx context.Context, id uint64) (*GasTank, error) - AddGasTank(ctx context.Context, name string, feeMarkupFactor float64, unlimited *bool) (bool, *GasTank, error) - UpdateGasTank(ctx context.Context, id uint64, name *string, feeMarkupFactor *float64, unlimited *bool) (bool, *GasTank, error) - // Legacy Gas Adjustment - NextGasTankBalanceAdjustmentNonce(ctx context.Context, id uint64) (uint64, error) - AdjustGasTankBalance(ctx context.Context, id uint64, nonce uint64, amount float64) (bool, *GasTankBalanceAdjustment, error) - GetGasTankBalanceAdjustment(ctx context.Context, id uint64, nonce uint64) (*GasTankBalanceAdjustment, error) - ListGasTankBalanceAdjustments(ctx context.Context, id uint64, page *Page) (*Page, []*GasTankBalanceAdjustment, error) - // Project-Level Gas Sponsorship - ListGasSponsors(ctx context.Context, projectId uint64, page *Page) (*Page, []*GasSponsor, error) - GetGasSponsor(ctx context.Context, projectId uint64, id uint64) (*GasSponsor, error) - AddGasSponsor(ctx context.Context, projectId uint64, address string, name *string, active *bool) (bool, *GasSponsor, error) - UpdateGasSponsor(ctx context.Context, projectId uint64, id uint64, name *string, active *bool) (bool, *GasSponsor, error) - RemoveGasSponsor(ctx context.Context, projectId uint64, id uint64) (bool, error) - // Ecosystem-level Gas Sponsorship - ListEcosystemGasSponsors(ctx context.Context, ecosystemId uint64, page *Page) (*Page, []*GasSponsor, error) - GetEcosystemGasSponsor(ctx context.Context, ecosystemId uint64, id uint64) (*GasSponsor, error) - AddEcosystemGasSponsor(ctx context.Context, ecosystemId uint64, address string, name *string, active *bool) (bool, *GasSponsor, error) - UpdateEcosystemGasSponsor(ctx context.Context, ecosystemId uint64, id uint64, name *string, active *bool) (bool, *GasSponsor, error) - RemoveEcosystemGasSponsor(ctx context.Context, ecosystemId uint64, id uint64) (bool, error) - // Gas Sponsor Lookup - AddressGasSponsors(ctx context.Context, address string, page *Page) (*Page, []*GasSponsor, error) - // Project Balance - GetProjectBalance(ctx context.Context, projectId uint64) (float64, error) - AdjustProjectBalance(ctx context.Context, projectId uint64, amount float64, identifier string) (float64, error) -} - -// -// Server interface -// - -type RelayerServer interface { - Ping(ctx context.Context) (bool, error) - Version(ctx context.Context) (*Version, error) - RuntimeStatus(ctx context.Context) (*RuntimeStatus, error) - GetSequenceContext(ctx context.Context) (*SequenceContext, error) - GetChainID(ctx context.Context) (uint64, error) - // - // Transactions - // - // TODO (future): rename this to just, 'SendTransaction(txn: MetaTransaction)' or 'SendTransaction(txn: SignedTransaction)', or something.. - // Project ID is only used by service and admin calls. Other clients must have projectID passed via the context - // TODO: rename return txnHash: string to metaTxnID: string - SendMetaTxn(ctx context.Context, call *MetaTxn, quote *string, projectID *uint64, preconditions []*TransactionPrecondition) (bool, string, error) - GetMetaTxnNonce(ctx context.Context, walletContractAddress string, space *string) (string, error) - // TODO: one day, make GetMetaTxnReceipt respond immediately with receipt or not - // and add WaitTransactionReceipt method, which will block and wait, similar to how GetMetaTxnReceipt - // is implemented now. - // For backwards compat, we can leave the current GetMetaTxnReceipt how it is, an deprecate it, and introduce - // new, GetTransactionReceipt and WaitTransactionReceipt methods - // we can also accept metaTxnId and txnHash .. so can take either or.. I wonder if ERC-4337 has any convention on this? - GetMetaTxnReceipt(ctx context.Context, metaTxID string) (*MetaTxnReceipt, bool, error) - Simulate(ctx context.Context, wallet string, transactions string) ([]*SimulateResult, error) - SimulateV3(ctx context.Context, wallet string, calls string) ([]*SimulateV3Result, error) - // TODO: deprecated, to be removed by https://github.com/0xsequence/stack/pull/356 at a later date - UpdateMetaTxnGasLimits(ctx context.Context, walletAddress string, walletConfig interface{}, payload string) (string, error) - FeeTokens(ctx context.Context) (bool, []*FeeToken, string, error) - FeeOptions(ctx context.Context, wallet string, to string, data string, simulate *bool, authorization *EIP7702Authorization) ([]*FeeOption, bool, *string, error) - // Bridge gas endpoints for S2S calls - // Used for bridge fees (e.g., LayerZero messaging fees) that require msg.value to be fronted at runtime. - // bridgeGas will be included in fee calculation so the relayer gets reimbursed. - SendMetaTxnWithBridgeGas(ctx context.Context, call *MetaTxn, quote *string, projectID *uint64, bridgeGas string, preconditions []*TransactionPrecondition) (bool, string, error) - FeeOptionsWithBridgeGas(ctx context.Context, wallet string, to string, data string, simulate *bool, bridgeGas string, authorization *EIP7702Authorization) ([]*FeeOption, bool, *string, error) - // TODO: deprecated, to be removed by https://github.com/0xsequence/stack/pull/356 at a later date - GetMetaTxnNetworkFeeOptions(ctx context.Context, walletConfig interface{}, payload string) ([]*FeeOption, error) - // - // Sender administration - // - StartSender(ctx context.Context, sender int) error - StopSender(ctx context.Context, sender int) error - RepairSender(ctx context.Context, sender int, nonce uint64, operation RepairOperation) error - GetMetaTransactions(ctx context.Context, projectId uint64, page *Page) (*Page, []*MetaTxnLog, error) + GetMetaTransactions(ctx context.Context, projectId uint64, page *Page, includeNonSponsored *bool) (*Page, []*MetaTxnLog, error) GetTransactionCost(ctx context.Context, projectId uint64, from time.Time, to time.Time) (float64, error) // Legacy Gas Tank GetGasTank(ctx context.Context, id uint64) (*GasTank, error) @@ -1194,27 +1120,12 @@ func (c *relayerClient) RepairSender(ctx context.Context, sender int, nonce uint return err } -func (c *relayerClient) StartSender(ctx context.Context, sender int) error { - in := struct { - Arg0 int `json:"sender"` - }{sender} - - resp, err := doHTTPRequest(ctx, c.client, c.urls[16], in, nil) - if resp != nil { - cerr := resp.Body.Close() - if err == nil && cerr != nil { - err = ErrWebrpcRequestFailed.WithCausef("failed to close response body: %w", cerr) - } - } - - return err -} - -func (c *relayerClient) GetMetaTransactions(ctx context.Context, projectId uint64, page *Page) (*Page, []*MetaTxnLog, error) { +func (c *relayerClient) GetMetaTransactions(ctx context.Context, projectId uint64, page *Page, includeNonSponsored *bool) (*Page, []*MetaTxnLog, error) { in := struct { Arg0 uint64 `json:"projectId"` Arg1 *Page `json:"page"` - }{projectId, page} + Arg2 *bool `json:"includeNonSponsored"` + }{projectId, page, includeNonSponsored} out := struct { Ret0 *Page `json:"page"` Ret1 []*MetaTxnLog `json:"transactions"` @@ -1674,2361 +1585,146 @@ func (c *relayerClient) AdjustProjectBalance(ctx context.Context, projectId uint } // -// Server +// Client helpers // -type WebRPCServer interface { - http.Handler -} - -type relayerService struct { - RelayerServer - OnError func(r *http.Request, rpcErr *WebRPCError) - OnRequest func(w http.ResponseWriter, r *http.Request) error -} - -func NewRelayerServer(svc RelayerServer) *relayerService { - return &relayerService{ - RelayerServer: svc, - } +// HTTPClient is the interface used by generated clients to send HTTP requests. +// It is fulfilled by *(net/http).Client, which is sufficient for most users. +// Users can provide their own implementation for special retry policies. +type HTTPClient interface { + Do(req *http.Request) (*http.Response, error) } -func (s *relayerService) ServeHTTP(w http.ResponseWriter, r *http.Request) { - defer func() { - // In case of a panic, serve a HTTP 500 error and then panic. - if rr := recover(); rr != nil { - s.sendErrorJSON(w, r, ErrWebrpcServerPanic.WithCausef("%v", rr)) - panic(rr) - } - }() - - w.Header().Set(WebrpcHeader, WebrpcHeaderValue) - - ctx := r.Context() - ctx = context.WithValue(ctx, HTTPResponseWriterCtxKey, w) - ctx = context.WithValue(ctx, HTTPRequestCtxKey, r) - ctx = context.WithValue(ctx, ServiceNameCtxKey, "Relayer") - - r = r.WithContext(ctx) - - var handler func(ctx context.Context, w http.ResponseWriter, r *http.Request) - switch r.URL.Path { - case "/rpc/Relayer/Ping": - handler = s.servePingJSON - case "/rpc/Relayer/Version": - handler = s.serveVersionJSON - case "/rpc/Relayer/RuntimeStatus": - handler = s.serveRuntimeStatusJSON - case "/rpc/Relayer/GetSequenceContext": - handler = s.serveGetSequenceContextJSON - case "/rpc/Relayer/GetChainID": - handler = s.serveGetChainIDJSON - case "/rpc/Relayer/SendMetaTxn": - handler = s.serveSendMetaTxnJSON - case "/rpc/Relayer/GetMetaTxnNonce": - handler = s.serveGetMetaTxnNonceJSON - case "/rpc/Relayer/GetMetaTxnReceipt": - handler = s.serveGetMetaTxnReceiptJSON - case "/rpc/Relayer/Simulate": - handler = s.serveSimulateJSON - case "/rpc/Relayer/SimulateV3": - handler = s.serveSimulateV3JSON - case "/rpc/Relayer/UpdateMetaTxnGasLimits": - handler = s.serveUpdateMetaTxnGasLimitsJSON - case "/rpc/Relayer/FeeTokens": - handler = s.serveFeeTokensJSON - case "/rpc/Relayer/FeeOptions": - handler = s.serveFeeOptionsJSON - case "/rpc/Relayer/SendMetaTxnWithBridgeGas": - handler = s.serveSendMetaTxnWithBridgeGasJSON - case "/rpc/Relayer/FeeOptionsWithBridgeGas": - handler = s.serveFeeOptionsWithBridgeGasJSON - case "/rpc/Relayer/GetMetaTxnNetworkFeeOptions": - handler = s.serveGetMetaTxnNetworkFeeOptionsJSON - case "/rpc/Relayer/StartSender": - handler = s.serveStartSenderJSON - case "/rpc/Relayer/StopSender": - handler = s.serveStopSenderJSON - case "/rpc/Relayer/RepairSender": - handler = s.serveRepairSenderJSON - case "/rpc/Relayer/GetMetaTransactions": - handler = s.serveGetMetaTransactionsJSON - case "/rpc/Relayer/GetTransactionCost": - handler = s.serveGetTransactionCostJSON - case "/rpc/Relayer/GetGasTank": - handler = s.serveGetGasTankJSON - case "/rpc/Relayer/AddGasTank": - handler = s.serveAddGasTankJSON - case "/rpc/Relayer/UpdateGasTank": - handler = s.serveUpdateGasTankJSON - case "/rpc/Relayer/NextGasTankBalanceAdjustmentNonce": - handler = s.serveNextGasTankBalanceAdjustmentNonceJSON - case "/rpc/Relayer/AdjustGasTankBalance": - handler = s.serveAdjustGasTankBalanceJSON - case "/rpc/Relayer/GetGasTankBalanceAdjustment": - handler = s.serveGetGasTankBalanceAdjustmentJSON - case "/rpc/Relayer/ListGasTankBalanceAdjustments": - handler = s.serveListGasTankBalanceAdjustmentsJSON - case "/rpc/Relayer/ListGasSponsors": - handler = s.serveListGasSponsorsJSON - case "/rpc/Relayer/GetGasSponsor": - handler = s.serveGetGasSponsorJSON - case "/rpc/Relayer/AddGasSponsor": - handler = s.serveAddGasSponsorJSON - case "/rpc/Relayer/UpdateGasSponsor": - handler = s.serveUpdateGasSponsorJSON - case "/rpc/Relayer/RemoveGasSponsor": - handler = s.serveRemoveGasSponsorJSON - case "/rpc/Relayer/ListEcosystemGasSponsors": - handler = s.serveListEcosystemGasSponsorsJSON - case "/rpc/Relayer/GetEcosystemGasSponsor": - handler = s.serveGetEcosystemGasSponsorJSON - case "/rpc/Relayer/AddEcosystemGasSponsor": - handler = s.serveAddEcosystemGasSponsorJSON - case "/rpc/Relayer/UpdateEcosystemGasSponsor": - handler = s.serveUpdateEcosystemGasSponsorJSON - case "/rpc/Relayer/RemoveEcosystemGasSponsor": - handler = s.serveRemoveEcosystemGasSponsorJSON - case "/rpc/Relayer/AddressGasSponsors": - handler = s.serveAddressGasSponsorsJSON - case "/rpc/Relayer/GetProjectBalance": - handler = s.serveGetProjectBalanceJSON - case "/rpc/Relayer/AdjustProjectBalance": - handler = s.serveAdjustProjectBalanceJSON - default: - err := ErrWebrpcBadRoute.WithCausef("no webrpc method defined for path %v", r.URL.Path) - s.sendErrorJSON(w, r, err) - return +// urlBase helps ensure that addr specifies a scheme. If it is unparsable +// as a URL, it returns addr unchanged. +func urlBase(addr string) string { + // If the addr specifies a scheme, use it. If not, default to + // http. If url.Parse fails on it, return it unchanged. + url, err := url.Parse(addr) + if err != nil { + return addr } - - if r.Method != "POST" { - w.Header().Add("Allow", "POST") // RFC 9110. - err := ErrWebrpcBadMethod.WithCausef("unsupported HTTP method %v (only POST is allowed)", r.Method) - s.sendErrorJSON(w, r, err) - return + if url.Scheme == "" { + url.Scheme = "http" } + return url.String() +} - contentType := r.Header.Get("Content-Type") - if i := strings.Index(contentType, ";"); i >= 0 { - contentType = contentType[:i] +// newRequest makes an http.Request from a client, adding common headers. +func newRequest(ctx context.Context, url string, reqBody io.Reader, contentType string) (*http.Request, error) { + req, err := http.NewRequestWithContext(ctx, "POST", url, reqBody) + if err != nil { + return nil, err } - contentType = strings.TrimSpace(strings.ToLower(contentType)) - - switch contentType { - case "application/json": - if s.OnRequest != nil { - if err := s.OnRequest(w, r); err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return + req.Header.Set("Accept", contentType) + req.Header.Set("Content-Type", contentType) + req.Header.Set(WebrpcHeader, WebrpcHeaderValue) + if headers, ok := HTTPRequestHeaders(ctx); ok { + for k := range headers { + for _, v := range headers[k] { + req.Header.Add(k, v) } } - - handler(ctx, w, r) - default: - err := ErrWebrpcBadRequest.WithCausef("unsupported Content-Type %q (only application/json is allowed)", r.Header.Get("Content-Type")) - s.sendErrorJSON(w, r, err) } + return req, nil } -func (s *relayerService) servePingJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "Ping") - - // Call service method implementation. - ret0, err := s.RelayerServer.Ping(ctx) +// doHTTPRequest is common code to make a request to the remote service. +func doHTTPRequest(ctx context.Context, client HTTPClient, url string, in, out interface{}) (*http.Response, error) { + reqBody, err := json.Marshal(in) if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return + return nil, ErrWebrpcRequestFailed.WithCausef("failed to marshal JSON body: %w", err) } - - respPayload := struct { - Ret0 bool `json:"status"` - }{ret0} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return + if err = ctx.Err(); err != nil { + return nil, ErrWebrpcRequestFailed.WithCausef("aborted because context was done: %w", err) } - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveVersionJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "Version") - - // Call service method implementation. - ret0, err := s.RelayerServer.Version(ctx) + req, err := newRequest(ctx, url, bytes.NewBuffer(reqBody), "application/json") if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return + return nil, ErrWebrpcRequestFailed.WithCausef("could not build request: %w", err) } - respPayload := struct { - Ret0 *Version `json:"version"` - }{ret0} - respBody, err := json.Marshal(respPayload) + resp, err := client.Do(req) if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return + return nil, ErrWebrpcRequestFailed.WithCause(err) } - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveRuntimeStatusJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "RuntimeStatus") - - // Call service method implementation. - ret0, err := s.RelayerServer.RuntimeStatus(ctx) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) + if resp.StatusCode != 200 { + respBody, err := io.ReadAll(resp.Body) + if err != nil { + return nil, ErrWebrpcBadResponse.WithCausef("failed to read server error response body: %w", err) } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 *RuntimeStatus `json:"status"` - }{ret0} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveGetSequenceContextJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "GetSequenceContext") - // Call service method implementation. - ret0, err := s.RelayerServer.GetSequenceContext(ctx) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) + var rpcErr WebRPCError + if err := json.Unmarshal(respBody, &rpcErr); err != nil { + return nil, ErrWebrpcBadResponse.WithCausef("failed to unmarshal server error: %w", err) } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 *SequenceContext `json:"data"` - }{ret0} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return + if rpcErr.Cause != "" { + rpcErr.cause = errors.New(rpcErr.Cause) + } + return nil, rpcErr } - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveGetChainIDJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "GetChainID") - - // Call service method implementation. - ret0, err := s.RelayerServer.GetChainID(ctx) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) + if out != nil { + respBody, err := io.ReadAll(resp.Body) + if err != nil { + return nil, ErrWebrpcBadResponse.WithCausef("failed to read response body: %w", err) } - s.sendErrorJSON(w, r, rpcErr) - return - } - respPayload := struct { - Ret0 uint64 `json:"chainID"` - }{ret0} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return + err = json.Unmarshal(respBody, &out) + if err != nil { + return nil, ErrWebrpcBadResponse.WithCausef("failed to unmarshal JSON response body: %w", err) + } } - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) + return resp, nil } -func (s *relayerService) serveSendMetaTxnJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "SendMetaTxn") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return +func WithHTTPRequestHeaders(ctx context.Context, h http.Header) (context.Context, error) { + if _, ok := h["Accept"]; ok { + return nil, errors.New("provided header cannot set Accept") } - defer r.Body.Close() - - reqPayload := struct { - Arg0 *MetaTxn `json:"call"` - Arg1 *string `json:"quote"` - Arg2 *uint64 `json:"projectID"` - Arg3 []*TransactionPrecondition `json:"preconditions"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return + if _, ok := h["Content-Type"]; ok { + return nil, errors.New("provided header cannot set Content-Type") } - // Call service method implementation. - ret0, ret1, err := s.RelayerServer.SendMetaTxn(ctx, reqPayload.Arg0, reqPayload.Arg1, reqPayload.Arg2, reqPayload.Arg3) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) + copied := make(http.Header, len(h)) + for k, vv := range h { + if vv == nil { + copied[k] = nil + continue } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 bool `json:"status"` - Ret1 string `json:"txnHash"` - }{ret0, ret1} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return + copied[k] = make([]string, len(vv)) + copy(copied[k], vv) } - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) + return context.WithValue(ctx, HTTPClientRequestHeadersCtxKey, copied), nil } -func (s *relayerService) serveGetMetaTxnNonceJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "GetMetaTxnNonce") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 string `json:"walletContractAddress"` - Arg1 *string `json:"space"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } +func HTTPRequestHeaders(ctx context.Context) (http.Header, bool) { + h, ok := ctx.Value(HTTPClientRequestHeadersCtxKey).(http.Header) + return h, ok +} - // Call service method implementation. - ret0, err := s.RelayerServer.GetMetaTxnNonce(ctx, reqPayload.Arg0, reqPayload.Arg1) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } +// +// Webrpc helpers +// - respPayload := struct { - Ret0 string `json:"nonce"` - }{ret0} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } +type contextKey struct { + name string +} - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) +func (k *contextKey) String() string { + return "webrpc context value " + k.name } -func (s *relayerService) serveGetMetaTxnReceiptJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "GetMetaTxnReceipt") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 string `json:"metaTxID"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, ret1, err := s.RelayerServer.GetMetaTxnReceipt(ctx, reqPayload.Arg0) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 *MetaTxnReceipt `json:"receipt"` - Ret1 bool `json:"metaTxnEnqueued"` - }{ret0, ret1} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveSimulateJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "Simulate") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 string `json:"wallet"` - Arg1 string `json:"transactions"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, err := s.RelayerServer.Simulate(ctx, reqPayload.Arg0, reqPayload.Arg1) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 []*SimulateResult `json:"results"` - }{ret0} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveSimulateV3JSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "SimulateV3") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 string `json:"wallet"` - Arg1 string `json:"calls"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, err := s.RelayerServer.SimulateV3(ctx, reqPayload.Arg0, reqPayload.Arg1) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 []*SimulateV3Result `json:"results"` - }{ret0} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveUpdateMetaTxnGasLimitsJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "UpdateMetaTxnGasLimits") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 string `json:"walletAddress"` - Arg1 interface{} `json:"walletConfig"` - Arg2 string `json:"payload"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, err := s.RelayerServer.UpdateMetaTxnGasLimits(ctx, reqPayload.Arg0, reqPayload.Arg1, reqPayload.Arg2) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 string `json:"payload"` - }{ret0} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveFeeTokensJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "FeeTokens") - - // Call service method implementation. - ret0, ret1, ret2, err := s.RelayerServer.FeeTokens(ctx) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 bool `json:"isFeeRequired"` - Ret1 []*FeeToken `json:"tokens"` - Ret2 string `json:"paymentAddress"` - }{ret0, ret1, ret2} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveFeeOptionsJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "FeeOptions") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 string `json:"wallet"` - Arg1 string `json:"to"` - Arg2 string `json:"data"` - Arg3 *bool `json:"simulate"` - Arg4 *EIP7702Authorization `json:"authorization"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, ret1, ret2, err := s.RelayerServer.FeeOptions(ctx, reqPayload.Arg0, reqPayload.Arg1, reqPayload.Arg2, reqPayload.Arg3, reqPayload.Arg4) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 []*FeeOption `json:"options"` - Ret1 bool `json:"sponsored"` - Ret2 *string `json:"quote"` - }{ret0, ret1, ret2} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveSendMetaTxnWithBridgeGasJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "SendMetaTxnWithBridgeGas") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 *MetaTxn `json:"call"` - Arg1 *string `json:"quote"` - Arg2 *uint64 `json:"projectID"` - Arg3 string `json:"bridgeGas"` - Arg4 []*TransactionPrecondition `json:"preconditions"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, ret1, err := s.RelayerServer.SendMetaTxnWithBridgeGas(ctx, reqPayload.Arg0, reqPayload.Arg1, reqPayload.Arg2, reqPayload.Arg3, reqPayload.Arg4) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 bool `json:"status"` - Ret1 string `json:"txnHash"` - }{ret0, ret1} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveFeeOptionsWithBridgeGasJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "FeeOptionsWithBridgeGas") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 string `json:"wallet"` - Arg1 string `json:"to"` - Arg2 string `json:"data"` - Arg3 *bool `json:"simulate"` - Arg4 string `json:"bridgeGas"` - Arg5 *EIP7702Authorization `json:"authorization"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, ret1, ret2, err := s.RelayerServer.FeeOptionsWithBridgeGas(ctx, reqPayload.Arg0, reqPayload.Arg1, reqPayload.Arg2, reqPayload.Arg3, reqPayload.Arg4, reqPayload.Arg5) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 []*FeeOption `json:"options"` - Ret1 bool `json:"sponsored"` - Ret2 *string `json:"quote"` - }{ret0, ret1, ret2} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveGetMetaTxnNetworkFeeOptionsJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "GetMetaTxnNetworkFeeOptions") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 interface{} `json:"walletConfig"` - Arg1 string `json:"payload"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, err := s.RelayerServer.GetMetaTxnNetworkFeeOptions(ctx, reqPayload.Arg0, reqPayload.Arg1) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 []*FeeOption `json:"options"` - }{ret0} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveStartSenderJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "StartSender") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 int `json:"sender"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - err = s.RelayerServer.StartSender(ctx, reqPayload.Arg0) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write([]byte("{}")) -} - -func (s *relayerService) serveStopSenderJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "StopSender") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 int `json:"sender"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - err = s.RelayerServer.StopSender(ctx, reqPayload.Arg0) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write([]byte("{}")) -} - -func (s *relayerService) serveRepairSenderJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "RepairSender") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 int `json:"sender"` - Arg1 uint64 `json:"nonce"` - Arg2 RepairOperation `json:"operation"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - err = s.RelayerServer.RepairSender(ctx, reqPayload.Arg0, reqPayload.Arg1, reqPayload.Arg2) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write([]byte("{}")) -} - -func (s *relayerService) serveGetMetaTransactionsJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "GetMetaTransactions") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 uint64 `json:"projectId"` - Arg1 *Page `json:"page"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, ret1, err := s.RelayerServer.GetMetaTransactions(ctx, reqPayload.Arg0, reqPayload.Arg1) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 *Page `json:"page"` - Ret1 []*MetaTxnLog `json:"transactions"` - }{ret0, ret1} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveGetTransactionCostJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "GetTransactionCost") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 uint64 `json:"projectId"` - Arg1 time.Time `json:"from"` - Arg2 time.Time `json:"to"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, err := s.RelayerServer.GetTransactionCost(ctx, reqPayload.Arg0, reqPayload.Arg1, reqPayload.Arg2) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 float64 `json:"cost"` - }{ret0} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveGetGasTankJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "GetGasTank") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 uint64 `json:"id"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, err := s.RelayerServer.GetGasTank(ctx, reqPayload.Arg0) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 *GasTank `json:"gasTank"` - }{ret0} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveAddGasTankJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "AddGasTank") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 string `json:"name"` - Arg1 float64 `json:"feeMarkupFactor"` - Arg2 *bool `json:"unlimited"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, ret1, err := s.RelayerServer.AddGasTank(ctx, reqPayload.Arg0, reqPayload.Arg1, reqPayload.Arg2) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 bool `json:"status"` - Ret1 *GasTank `json:"gasTank"` - }{ret0, ret1} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveUpdateGasTankJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "UpdateGasTank") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 uint64 `json:"id"` - Arg1 *string `json:"name"` - Arg2 *float64 `json:"feeMarkupFactor"` - Arg3 *bool `json:"unlimited"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, ret1, err := s.RelayerServer.UpdateGasTank(ctx, reqPayload.Arg0, reqPayload.Arg1, reqPayload.Arg2, reqPayload.Arg3) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 bool `json:"status"` - Ret1 *GasTank `json:"gasTank"` - }{ret0, ret1} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveNextGasTankBalanceAdjustmentNonceJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "NextGasTankBalanceAdjustmentNonce") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 uint64 `json:"id"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, err := s.RelayerServer.NextGasTankBalanceAdjustmentNonce(ctx, reqPayload.Arg0) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 uint64 `json:"nonce"` - }{ret0} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveAdjustGasTankBalanceJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "AdjustGasTankBalance") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 uint64 `json:"id"` - Arg1 uint64 `json:"nonce"` - Arg2 float64 `json:"amount"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, ret1, err := s.RelayerServer.AdjustGasTankBalance(ctx, reqPayload.Arg0, reqPayload.Arg1, reqPayload.Arg2) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 bool `json:"status"` - Ret1 *GasTankBalanceAdjustment `json:"adjustment"` - }{ret0, ret1} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveGetGasTankBalanceAdjustmentJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "GetGasTankBalanceAdjustment") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 uint64 `json:"id"` - Arg1 uint64 `json:"nonce"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, err := s.RelayerServer.GetGasTankBalanceAdjustment(ctx, reqPayload.Arg0, reqPayload.Arg1) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 *GasTankBalanceAdjustment `json:"adjustment"` - }{ret0} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveListGasTankBalanceAdjustmentsJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "ListGasTankBalanceAdjustments") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 uint64 `json:"id"` - Arg1 *Page `json:"page"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, ret1, err := s.RelayerServer.ListGasTankBalanceAdjustments(ctx, reqPayload.Arg0, reqPayload.Arg1) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 *Page `json:"page"` - Ret1 []*GasTankBalanceAdjustment `json:"adjustments"` - }{ret0, ret1} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveListGasSponsorsJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "ListGasSponsors") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 uint64 `json:"projectId"` - Arg1 *Page `json:"page"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, ret1, err := s.RelayerServer.ListGasSponsors(ctx, reqPayload.Arg0, reqPayload.Arg1) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 *Page `json:"page"` - Ret1 []*GasSponsor `json:"gasSponsors"` - }{ret0, ret1} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveGetGasSponsorJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "GetGasSponsor") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 uint64 `json:"projectId"` - Arg1 uint64 `json:"id"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, err := s.RelayerServer.GetGasSponsor(ctx, reqPayload.Arg0, reqPayload.Arg1) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 *GasSponsor `json:"gasSponsor"` - }{ret0} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveAddGasSponsorJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "AddGasSponsor") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 uint64 `json:"projectId"` - Arg1 string `json:"address"` - Arg2 *string `json:"name"` - Arg3 *bool `json:"active"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, ret1, err := s.RelayerServer.AddGasSponsor(ctx, reqPayload.Arg0, reqPayload.Arg1, reqPayload.Arg2, reqPayload.Arg3) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 bool `json:"status"` - Ret1 *GasSponsor `json:"gasSponsor"` - }{ret0, ret1} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveUpdateGasSponsorJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "UpdateGasSponsor") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 uint64 `json:"projectId"` - Arg1 uint64 `json:"id"` - Arg2 *string `json:"name"` - Arg3 *bool `json:"active"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, ret1, err := s.RelayerServer.UpdateGasSponsor(ctx, reqPayload.Arg0, reqPayload.Arg1, reqPayload.Arg2, reqPayload.Arg3) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 bool `json:"status"` - Ret1 *GasSponsor `json:"gasSponsor"` - }{ret0, ret1} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveRemoveGasSponsorJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "RemoveGasSponsor") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 uint64 `json:"projectId"` - Arg1 uint64 `json:"id"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, err := s.RelayerServer.RemoveGasSponsor(ctx, reqPayload.Arg0, reqPayload.Arg1) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 bool `json:"status"` - }{ret0} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveListEcosystemGasSponsorsJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "ListEcosystemGasSponsors") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 uint64 `json:"ecosystemId"` - Arg1 *Page `json:"page"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, ret1, err := s.RelayerServer.ListEcosystemGasSponsors(ctx, reqPayload.Arg0, reqPayload.Arg1) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 *Page `json:"page"` - Ret1 []*GasSponsor `json:"gasSponsors"` - }{ret0, ret1} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveGetEcosystemGasSponsorJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "GetEcosystemGasSponsor") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 uint64 `json:"ecosystemId"` - Arg1 uint64 `json:"id"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, err := s.RelayerServer.GetEcosystemGasSponsor(ctx, reqPayload.Arg0, reqPayload.Arg1) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 *GasSponsor `json:"gasSponsor"` - }{ret0} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveAddEcosystemGasSponsorJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "AddEcosystemGasSponsor") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 uint64 `json:"ecosystemId"` - Arg1 string `json:"address"` - Arg2 *string `json:"name"` - Arg3 *bool `json:"active"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, ret1, err := s.RelayerServer.AddEcosystemGasSponsor(ctx, reqPayload.Arg0, reqPayload.Arg1, reqPayload.Arg2, reqPayload.Arg3) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 bool `json:"status"` - Ret1 *GasSponsor `json:"gasSponsor"` - }{ret0, ret1} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveUpdateEcosystemGasSponsorJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "UpdateEcosystemGasSponsor") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 uint64 `json:"ecosystemId"` - Arg1 uint64 `json:"id"` - Arg2 *string `json:"name"` - Arg3 *bool `json:"active"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, ret1, err := s.RelayerServer.UpdateEcosystemGasSponsor(ctx, reqPayload.Arg0, reqPayload.Arg1, reqPayload.Arg2, reqPayload.Arg3) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 bool `json:"status"` - Ret1 *GasSponsor `json:"gasSponsor"` - }{ret0, ret1} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveRemoveEcosystemGasSponsorJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "RemoveEcosystemGasSponsor") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 uint64 `json:"ecosystemId"` - Arg1 uint64 `json:"id"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, err := s.RelayerServer.RemoveEcosystemGasSponsor(ctx, reqPayload.Arg0, reqPayload.Arg1) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 bool `json:"status"` - }{ret0} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveAddressGasSponsorsJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "AddressGasSponsors") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 string `json:"address"` - Arg1 *Page `json:"page"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, ret1, err := s.RelayerServer.AddressGasSponsors(ctx, reqPayload.Arg0, reqPayload.Arg1) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 *Page `json:"page"` - Ret1 []*GasSponsor `json:"gasSponsors"` - }{ret0, ret1} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveGetProjectBalanceJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "GetProjectBalance") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 uint64 `json:"projectId"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, err := s.RelayerServer.GetProjectBalance(ctx, reqPayload.Arg0) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 float64 `json:"balance"` - }{ret0} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) serveAdjustProjectBalanceJSON(ctx context.Context, w http.ResponseWriter, r *http.Request) { - ctx = context.WithValue(ctx, MethodNameCtxKey, "AdjustProjectBalance") - - reqBody, err := io.ReadAll(r.Body) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to read request data: %w", err)) - return - } - defer r.Body.Close() - - reqPayload := struct { - Arg0 uint64 `json:"projectId"` - Arg1 float64 `json:"amount"` - Arg2 string `json:"identifier"` - }{} - if err := json.Unmarshal(reqBody, &reqPayload); err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadRequest.WithCausef("failed to unmarshal request data: %w", err)) - return - } - - // Call service method implementation. - ret0, err := s.RelayerServer.AdjustProjectBalance(ctx, reqPayload.Arg0, reqPayload.Arg1, reqPayload.Arg2) - if err != nil { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - s.sendErrorJSON(w, r, rpcErr) - return - } - - respPayload := struct { - Ret0 float64 `json:"balance"` - }{ret0} - respBody, err := json.Marshal(respPayload) - if err != nil { - s.sendErrorJSON(w, r, ErrWebrpcBadResponse.WithCausef("failed to marshal json response: %w", err)) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - w.Write(respBody) -} - -func (s *relayerService) sendErrorJSON(w http.ResponseWriter, r *http.Request, rpcErr WebRPCError) { - if s.OnError != nil { - s.OnError(r, &rpcErr) - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(rpcErr.HTTPStatus) - - respBody, _ := json.Marshal(rpcErr) - w.Write(respBody) -} - -func RespondWithError(w http.ResponseWriter, err error) { - rpcErr, ok := err.(WebRPCError) - if !ok { - rpcErr = ErrWebrpcEndpoint.WithCause(err) - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(rpcErr.HTTPStatus) - - respBody, _ := json.Marshal(rpcErr) - w.Write(respBody) -} - -type method struct { - name string - service string - annotations map[string]string -} - -func (m *method) Name() string { return m.name } -func (m *method) Service() string { return m.service } -func (m *method) Annotations() map[string]string { return m.annotations } - -var methods = map[string]*method{ - "/rpc/Relayer/Ping": { - name: "Ping", - service: "Relayer", - annotations: map[string]string{"internal": ""}, - }, - "/rpc/Relayer/Version": { - name: "Version", - service: "Relayer", - annotations: map[string]string{"internal": ""}, - }, - "/rpc/Relayer/RuntimeStatus": { - name: "RuntimeStatus", - service: "Relayer", - annotations: map[string]string{"internal": ""}, - }, - "/rpc/Relayer/GetSequenceContext": { - name: "GetSequenceContext", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/GetChainID": { - name: "GetChainID", - service: "Relayer", - annotations: map[string]string{"public": ""}, - }, - "/rpc/Relayer/SendMetaTxn": { - name: "SendMetaTxn", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/GetMetaTxnNonce": { - name: "GetMetaTxnNonce", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/GetMetaTxnReceipt": { - name: "GetMetaTxnReceipt", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/Simulate": { - name: "Simulate", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/SimulateV3": { - name: "SimulateV3", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/UpdateMetaTxnGasLimits": { - name: "UpdateMetaTxnGasLimits", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/FeeTokens": { - name: "FeeTokens", - service: "Relayer", - annotations: map[string]string{"public": ""}, - }, - "/rpc/Relayer/FeeOptions": { - name: "FeeOptions", - service: "Relayer", - annotations: map[string]string{"public": ""}, - }, - "/rpc/Relayer/SendMetaTxnWithBridgeGas": { - name: "SendMetaTxnWithBridgeGas", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/FeeOptionsWithBridgeGas": { - name: "FeeOptionsWithBridgeGas", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/GetMetaTxnNetworkFeeOptions": { - name: "GetMetaTxnNetworkFeeOptions", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/StartSender": { - name: "StartSender", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/StopSender": { - name: "StopSender", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/RepairSender": { - name: "RepairSender", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/GetMetaTransactions": { - name: "GetMetaTransactions", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/GetTransactionCost": { - name: "GetTransactionCost", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/GetGasTank": { - name: "GetGasTank", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/AddGasTank": { - name: "AddGasTank", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/UpdateGasTank": { - name: "UpdateGasTank", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/NextGasTankBalanceAdjustmentNonce": { - name: "NextGasTankBalanceAdjustmentNonce", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/AdjustGasTankBalance": { - name: "AdjustGasTankBalance", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/GetGasTankBalanceAdjustment": { - name: "GetGasTankBalanceAdjustment", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/ListGasTankBalanceAdjustments": { - name: "ListGasTankBalanceAdjustments", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/ListGasSponsors": { - name: "ListGasSponsors", - service: "Relayer", - annotations: map[string]string{"public": ""}, - }, - "/rpc/Relayer/GetGasSponsor": { - name: "GetGasSponsor", - service: "Relayer", - annotations: map[string]string{"public": ""}, - }, - "/rpc/Relayer/AddGasSponsor": { - name: "AddGasSponsor", - service: "Relayer", - annotations: map[string]string{"public": ""}, - }, - "/rpc/Relayer/UpdateGasSponsor": { - name: "UpdateGasSponsor", - service: "Relayer", - annotations: map[string]string{"public": ""}, - }, - "/rpc/Relayer/RemoveGasSponsor": { - name: "RemoveGasSponsor", - service: "Relayer", - annotations: map[string]string{"public": ""}, - }, - "/rpc/Relayer/ListEcosystemGasSponsors": { - name: "ListEcosystemGasSponsors", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/GetEcosystemGasSponsor": { - name: "GetEcosystemGasSponsor", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/AddEcosystemGasSponsor": { - name: "AddEcosystemGasSponsor", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/UpdateEcosystemGasSponsor": { - name: "UpdateEcosystemGasSponsor", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/RemoveEcosystemGasSponsor": { - name: "RemoveEcosystemGasSponsor", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/AddressGasSponsors": { - name: "AddressGasSponsors", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/GetProjectBalance": { - name: "GetProjectBalance", - service: "Relayer", - annotations: map[string]string{}, - }, - "/rpc/Relayer/AdjustProjectBalance": { - name: "AdjustProjectBalance", - service: "Relayer", - annotations: map[string]string{}, - }, -} - -func MethodCtx(ctx context.Context) (*method, bool) { - req := RequestFromContext(ctx) - if req == nil { - return nil, false - } - - m, ok := methods[req.URL.Path] - return m, ok -} - -func WebrpcMethods() map[string]*method { - return methods -} - -var WebRPCServices = map[string][]string{ - "Relayer": { - "Ping", - "Version", - "RuntimeStatus", - "GetSequenceContext", - "GetChainID", - "SendMetaTxn", - "GetMetaTxnNonce", - "GetMetaTxnReceipt", - "Simulate", - "SimulateV3", - "UpdateMetaTxnGasLimits", - "FeeTokens", - "FeeOptions", - "SendMetaTxnWithBridgeGas", - "FeeOptionsWithBridgeGas", - "GetMetaTxnNetworkFeeOptions", - "StartSender", - "StopSender", - "RepairSender", - "GetMetaTransactions", - "GetTransactionCost", - "GetGasTank", - "AddGasTank", - "UpdateGasTank", - "NextGasTankBalanceAdjustmentNonce", - "AdjustGasTankBalance", - "GetGasTankBalanceAdjustment", - "ListGasTankBalanceAdjustments", - "ListGasSponsors", - "GetGasSponsor", - "AddGasSponsor", - "UpdateGasSponsor", - "RemoveGasSponsor", - "ListEcosystemGasSponsors", - "GetEcosystemGasSponsor", - "AddEcosystemGasSponsor", - "UpdateEcosystemGasSponsor", - "RemoveEcosystemGasSponsor", - "AddressGasSponsors", - "GetProjectBalance", - "AdjustProjectBalance", - }, -} - -// -// Client helpers -// - -// HTTPClient is the interface used by generated clients to send HTTP requests. -// It is fulfilled by *(net/http).Client, which is sufficient for most users. -// Users can provide their own implementation for special retry policies. -type HTTPClient interface { - Do(req *http.Request) (*http.Response, error) -} - -// urlBase helps ensure that addr specifies a scheme. If it is unparsable -// as a URL, it returns addr unchanged. -func urlBase(addr string) string { - // If the addr specifies a scheme, use it. If not, default to - // http. If url.Parse fails on it, return it unchanged. - url, err := url.Parse(addr) - if err != nil { - return addr - } - if url.Scheme == "" { - url.Scheme = "http" - } - return url.String() -} - -// newRequest makes an http.Request from a client, adding common headers. -func newRequest(ctx context.Context, url string, reqBody io.Reader, contentType string) (*http.Request, error) { - req, err := http.NewRequestWithContext(ctx, "POST", url, reqBody) - if err != nil { - return nil, err - } - req.Header.Set("Accept", contentType) - req.Header.Set("Content-Type", contentType) - req.Header.Set(WebrpcHeader, WebrpcHeaderValue) - if headers, ok := HTTPRequestHeaders(ctx); ok { - for k := range headers { - for _, v := range headers[k] { - req.Header.Add(k, v) - } - } - } - return req, nil -} - -// doHTTPRequest is common code to make a request to the remote service. -func doHTTPRequest(ctx context.Context, client HTTPClient, url string, in, out interface{}) (*http.Response, error) { - reqBody, err := json.Marshal(in) - if err != nil { - return nil, ErrWebrpcRequestFailed.WithCausef("failed to marshal JSON body: %w", err) - } - if err = ctx.Err(); err != nil { - return nil, ErrWebrpcRequestFailed.WithCausef("aborted because context was done: %w", err) - } - - req, err := newRequest(ctx, url, bytes.NewBuffer(reqBody), "application/json") - if err != nil { - return nil, ErrWebrpcRequestFailed.WithCausef("could not build request: %w", err) - } - - resp, err := client.Do(req) - if err != nil { - return nil, ErrWebrpcRequestFailed.WithCause(err) - } - - if resp.StatusCode != 200 { - respBody, err := io.ReadAll(resp.Body) - if err != nil { - return nil, ErrWebrpcBadResponse.WithCausef("failed to read server error response body: %w", err) - } - - var rpcErr WebRPCError - if err := json.Unmarshal(respBody, &rpcErr); err != nil { - return nil, ErrWebrpcBadResponse.WithCausef("failed to unmarshal server error: %w", err) - } - if rpcErr.Cause != "" { - rpcErr.cause = errors.New(rpcErr.Cause) - } - return nil, rpcErr - } - - if out != nil { - respBody, err := io.ReadAll(resp.Body) - if err != nil { - return nil, ErrWebrpcBadResponse.WithCausef("failed to read response body: %w", err) - } - - err = json.Unmarshal(respBody, &out) - if err != nil { - return nil, ErrWebrpcBadResponse.WithCausef("failed to unmarshal JSON response body: %w", err) - } - } - - return resp, nil -} - -func WithHTTPRequestHeaders(ctx context.Context, h http.Header) (context.Context, error) { - if _, ok := h["Accept"]; ok { - return nil, errors.New("provided header cannot set Accept") - } - if _, ok := h["Content-Type"]; ok { - return nil, errors.New("provided header cannot set Content-Type") - } - - copied := make(http.Header, len(h)) - for k, vv := range h { - if vv == nil { - copied[k] = nil - continue - } - copied[k] = make([]string, len(vv)) - copy(copied[k], vv) - } - - return context.WithValue(ctx, HTTPClientRequestHeadersCtxKey, copied), nil -} - -func HTTPRequestHeaders(ctx context.Context) (http.Header, bool) { - h, ok := ctx.Value(HTTPClientRequestHeadersCtxKey).(http.Header) - return h, ok -} - -// -// Webrpc helpers -// - -type contextKey struct { - name string -} - -func (k *contextKey) String() string { - return "webrpc context value " + k.name -} - -var ( - HTTPClientRequestHeadersCtxKey = &contextKey{"HTTPClientRequestHeaders"} -) - -var ( - HTTPResponseWriterCtxKey = &contextKey{"HTTPResponseWriter"} - MethodNameCtxKey = &contextKey{"MethodName"} - HTTPRequestCtxKey = &contextKey{"HTTPRequest"} - ServiceNameCtxKey = &contextKey{"ServiceName"} -) - -func ServiceNameFromContext(ctx context.Context) string { - service, _ := ctx.Value(ServiceNameCtxKey).(string) - return service -} - -func MethodNameFromContext(ctx context.Context) string { - method, _ := ctx.Value(MethodNameCtxKey).(string) - return method -} - -func RequestFromContext(ctx context.Context) *http.Request { - r, _ := ctx.Value(HTTPRequestCtxKey).(*http.Request) - return r -} +var ( + HTTPClientRequestHeadersCtxKey = &contextKey{"HTTPClientRequestHeaders"} +) // PtrTo is a useful helper when constructing values for optional fields. func PtrTo[T any](v T) *T { return &v } -func ResponseWriterFromContext(ctx context.Context) http.ResponseWriter { - w, _ := ctx.Value(HTTPResponseWriterCtxKey).(http.ResponseWriter) - return w -} - // // BigInt helpers //