tmmsgs

var (
	APIEndpointDeleteEventStream            = ffm("api.endpoints.delete.eventstream", "Delete an event stream")
	APIEndpointDeleteEventStreamListener    = ffm("api.endpoints.delete.eventstream.listener", "Delete event stream listener")
	APIEndpointDeleteSubscription           = ffm("api.endpoints.delete.subscription", "Delete listener - route deprecated in favor of /eventstreams/{streamId}/listeners/{listenerId}")
	APIEndpointDeleteTransaction            = ffm("api.endpoints.delete.transaction", "Request transaction deletion by the policy engine. Result could be immediate (200), asynchronous (202), or rejected with an error")
	APIEndpointGetAddressBalance            = ffm("api.endpoints.get.address.balance", "Get gas token balance for a signer address")
	APIEndpointGetEventStream               = ffm("api.endpoints.get.eventstream", "Get an event stream with status")
	APIEndpointGetEventStreamListener       = ffm("api.endpoints.get.eventstream.listener", "Get event stream listener")
	APIEndpointGetEventStreamListeners      = ffm("api.endpoints.get.eventstream.listeners", "List event stream listeners")
	APIEndpointGetEventStreams              = ffm("api.endpoints.get.eventstreams", "List event streams")
	APIEndpointGetGasPrice                  = ffm("api.endpoints.get.gasprice", "Get the current gas price of the connector's chain")
	APIEndpointGetStatusLive                = ffm("api.endpoints.get.status.live", "Get the liveness status of the connector")
	APIEndpointGetStatusReady               = ffm("api.endpoints.get.status.ready", "Get the readiness status of the connector")
	APIEndpointGetSubscription              = ffm("api.endpoints.get.subscription", "Get listener - route deprecated in favor of /eventstreams/{streamId}/listeners/{listenerId}")
	APIEndpointGetSubscriptions             = ffm("api.endpoints.get.subscriptions", "Get listeners - route deprecated in favor of /eventstreams/{streamId}/listeners")
	APIEndpointGetTransaction               = ffm("api.endpoints.get.transaction", "Get individual transaction with a status summary")
	APIEndpointGetTransactions              = ffm("api.endpoints.get.transactions", "List transactions")
	APIEndpointGetTransactionConfirmations  = ffm("api.endpoints.get.transactions.confirmations", "List transaction confirmations")
	APIEndpointGetTransactionHistory        = ffm("api.endpoints.get.transactions.history", "List transaction history records")
	APIEndpointGetTransactionReceipt        = ffm("api.endpoints.get.transactions.receipt", "Get the receipt for a transaction, if available")
	APIEndpointPatchEventStream             = ffm("api.endpoints.patch.eventstreams", "Update an existing event stream")
	APIEndpointPatchEventStreamListener     = ffm("api.endpoints.patch.eventstream.listener", "Update event stream listener")
	APIEndpointPatchSubscription            = ffm("api.endpoints.patch.subscription", "Update listener - route deprecated in favor of /eventstreams/{streamId}/listeners/{listenerId}")
	APIEndpointPostEventStream              = ffm("api.endpoints.post.eventstreams", "Create a new event stream")
	APIEndpointPostEventStreamListener      = ffm("api.endpoints.post.eventstream.listener", "Create event stream listener")
	APIEndpointPostEventStreamListenerReset = ffm("api.endpoints.post.eventstream.listener.reset", "Reset an event stream listener, to redeliver all events since the specified block")
	APIEndpointPostEventStreamResume        = ffm("api.endpoints.post.eventstream.resume", "Resume an event stream")
	APIEndpointPostEventStreamSuspend       = ffm("api.endpoints.post.eventstream.suspend", "Suspend an event stream")
	APIEndpointPostRoot                     = ffm("api.endpoints.post.root", "RPC/webhook style interface initiate a submit transactions, and execute queries")
	APIEndpointPostRootQueryOutput          = ffm("api.endpoints.post.root.query.output", "The data result of a query against a smart contract")
	APIEndpointPostSubscriptionReset        = ffm("api.endpoints.post.subscription.reset", "Reset listener - route deprecated in favor of /eventstreams/{streamId}/listeners/{listenerId}/reset")
	APIEndpointPostSubscriptions            = ffm("api.endpoints.post.subscriptions", "Create new listener - route deprecated in favor of /eventstreams/{streamId}/listeners")
	APIEndpointPostTransactionSuspend       = ffm("api.endpoints.post.transactions.suspend", "Suspend processing on a pending transaction (no-op for completed transactions)")
	APIEndpointPostTransactionResume        = ffm("api.endpoints.post.transactions.resume", "Resume processing on a suspended transaction")

	APIParamStreamID      = ffm("api.params.streamId", "Event Stream ID")
	APIParamListenerID    = ffm("api.params.listenerId", "Listener ID")
	APIParamTransactionID = ffm("api.params.transactionId", "Transaction ID")
	APIParamLimit         = ffm("api.params.limit", "Maximum number of entries to return")
	APIParamAfter         = ffm("api.params.after", "Return entries after this ID - for pagination (non-inclusive)")
	APIParamTXSigner      = ffm("api.params.txSigner", "Return only transactions for a specific signing address, in reverse nonce order")
	APIParamTXPending     = ffm("api.params.txPending", "Return only pending transactions, in reverse submission sequence (a 'sequenceId' is assigned to each transaction to determine its sequence")
	APIParamSortDirection = ffm("api.params.sortDirection", "Sort direction: 'asc'/'ascending' or 'desc'/'descending'")
	APIParamSignerAddress = ffm("api.params.signerAddress", "A signing address, for example to get the gas token balance for")
	APIParamBlocktag      = ffm("api.params.blocktag", "The optional block tag to use when making a gas token balance query")
	APIParamHistory       = ffm("api.params.history", "Include transaction history summary information")
)

var (
	ConfigAPIDefaultRequestTimeout = ffc("config.api.defaultRequestTimeout", "Default server-side request timeout for API calls", i18n.TimeDurationType)
	ConfigAPIMaxRequestTimeout     = ffc("config.api.maxRequestTimeout", "Maximum server-side request timeout a caller can request with a Request-Timeout header", i18n.TimeDurationType)
	ConfigAPIAddress               = ffc("config.api.address", "Listener address for API", i18n.StringType)
	ConfigAPIPort                  = ffc("config.api.port", "Listener port for API", i18n.IntType)
	ConfigAPIPublicURL             = ffc("config.api.publicURL", "External address callers should access API over", i18n.StringType)
	ConfigAPIReadTimeout           = ffc("config.api.readTimeout", "The maximum time to wait when reading from an HTTP connection", i18n.TimeDurationType)
	ConfigAPIWriteTimeout          = ffc("config.api.writeTimeout", "The maximum time to wait when writing to a HTTP connection", i18n.TimeDurationType)
	ConfigAPIShutdownTimeout       = ffc("config.api.shutdownTimeout", "The maximum amount of time to wait for any open HTTP requests to finish before shutting down the HTTP server", i18n.TimeDurationType)
	ConfigAPIPassthroughHeaders    = ffc("config.api.passthroughHeaders", "A list of HTTP request headers to pass through to dependency microservices", i18n.ArrayStringType)
	ConfigAPISimpleQuery           = ffc("config.api.simpleQuery", "Force use of original limited API query syntax, even if rich query is supported in the database", i18n.BooleanType)

	ConfigDebugPort = ffc("config.debug.port", "An HTTP port on which to enable the go debugger", i18n.IntType)

	ConfigConfirmationsBlockCacheSize           = ffc("config.confirmations.blockCacheSize", "The maximum number of block headers to keep in the cache", i18n.IntType)
	ConfigConfirmationsBlockQueueLength         = ffc("config.confirmations.blockQueueLength", "Internal queue length for notifying the confirmations manager of new blocks", i18n.IntType)
	ConfigConfirmationsNotificationsQueueLength = ffc("config.confirmations.notificationQueueLength", "Internal queue length for notifying the confirmations manager of new transactions/events", i18n.IntType)
	ConfigConfirmationsRequired                 = ffc("config.confirmations.required", "Number of confirmations required to consider a transaction/event final", i18n.IntType)
	ConfigConfirmationsStaleReceiptTimeout      = ffc("config.confirmations.staleReceiptTimeout", "Duration after which to force a receipt check for a pending transaction", i18n.TimeDurationType)
	ConfigConfirmationsReceiptWorkers           = ffc("config.confirmations.receiptWorkers", "Number of workers to use to query in parallel for receipts", i18n.IntType)

	ConfigTransactionsNonceStateTimeout = ffc("config.transactions.nonceStateTimeout", "How old the most recently submitted transaction record in our local state needs to be, before we make a request to the node to query the next nonce for a signing address", i18n.TimeDurationType)
	ConfigTransactionsMaxHistoryCount   = ffc("config.transactions.maxHistoryCount", "The number of historical status updates to retain in the operation", i18n.IntType)

	DeprecatedConfigTransactionsMaxInflight                  = ffc("config.transactions.maxInFlight", "Deprecated: Please use 'transactions.handler.simple.maxInFlight' instead", i18n.IntType)
	DeprecatedConfigPolicyEngineName                         = ffc("config.policyengine.name", "Deprecated: Please use 'transactions.handler.name' instead", i18n.StringType)
	DeprecatedConfigLoopInterval                             = ffc("config.policyloop.interval", "Deprecated: Please use 'transactions.handler.simple.interval' instead", i18n.TimeDurationType)
	DeprecatedConfigPolicyEngineSimpleFixedGasPrice          = ffc("config.policyengine.simple.fixedGasPrice", "Deprecated: Please use 'transactions.handler.simple.fixedGasPrice' instead", "Raw JSON")
	DeprecatedConfigPolicyEngineSimpleResubmitInterval       = ffc("config.policyengine.simple.resubmitInterval", "Deprecated: Please use 'transactions.handler.simple.resubmitInterval' instead", i18n.TimeDurationType)
	DeprecatedConfigPolicyEngineSimpleGasOracleEnabled       = ffc("config.policyengine.simple.gasOracle.mode", "Deprecated: Please use 'transactions.handler.simple.gasOracle.mode' instead", "'connector', 'restapi', 'fixed', or 'disabled'")
	DeprecatedConfigPolicyEngineSimpleGasOracleGoTemplate    = ffc("config.policyengine.simple.gasOracle.template", "Deprecated: Please use 'transactions.handler.simple.gasOracle.template' instead", i18n.GoTemplateType)
	DeprecatedConfigPolicyEngineSimpleGasOracleURL           = ffc("config.policyengine.simple.gasOracle.url", "Deprecated: Please use 'transactions.handler.simple.gasOracle.url' instead", i18n.StringType)
	DeprecatedConfigPolicyEngineSimpleGasOracleProxyURL      = ffc("config.policyengine.simple.gasOracle.proxy.url", "Deprecated: Please use 'transactions.handler.simple.gasOracle.proxy.url' instead", i18n.StringType)
	DeprecatedConfigPolicyEngineSimpleGasOracleMethod        = ffc("config.policyengine.simple.gasOracle.method", "Deprecated: Please use 'transactions.handler.simple.gasOracle.method' instead", i18n.StringType)
	DeprecatedConfigPolicyEngineSimpleGasOracleQueryInterval = ffc("config.policyengine.simple.gasOracle.queryInterval", "Deprecated: Please use 'transactions.handler.simple.gasOracle.queryInterval' instead", i18n.TimeDurationType)
	DeprecatedConfigLoopRetryInitDelay                       = ffc("config.policyloop.retry.initialDelay", "Deprecated: Please use 'transactions.handler.simple.interval' instead", i18n.TimeDurationType)
	DeprecatedConfigLoopRetryMaxDelay                        = ffc("config.policyloop.retry.maxDelay", "Deprecated: Please use 'transactions.handler.simple.interval' instead", i18n.TimeDurationType)
	DeprecatedConfigLoopRetryFactor                          = ffc("config.policyloop.retry.factor", "Deprecated: Please use 'transactions.handler.simple.interval' instead", i18n.TimeDurationType)
	DeprecatedConfigTXHandlerNonceStateTimeout               = ffc("config.transactions.handler.simple.nonceStateTimeout", "Deprecated: Please use 'transactions.handler.simple.nonceStateTimeout' instead", i18n.TimeDurationType)

	ConfigTXHandlerName        = ffc("config.transactions.handler.name", "The name of the transaction handler to use", i18n.StringType)
	ConfigTXHandlerMaxInflight = ffc("config.transactions.handler.simple.maxInFlight", "The maximum number of transactions to have in-flight with the transaction handler / blockchain transaction pool", i18n.IntType)

	ConfigTXHandlerSimpleInterval               = ffc("config.transactions.handler.simple.interval", "Interval at which to invoke the transaction handler loop to evaluate outstanding transactions", i18n.TimeDurationType)
	ConfigTXHandlerSimpleFixedGasPrice          = ffc("config.transactions.handler.simple.fixedGasPrice", "A fixed gasPrice value/structure to pass to the connector", "Raw JSON")
	ConfigTXHandlerSimpleResubmitInterval       = ffc("config.transactions.handler.simple.resubmitInterval", "The time between warning and re-sending a transaction (same nonce) when a blockchain transaction has not been allocated a receipt", i18n.TimeDurationType)
	ConfigTXHandlerSimpleRetryInitDelay         = ffc("config.transactions.handler.simple.retry.initialDelay", "Initial retry delay for retrieving transactions from the persistence", i18n.TimeDurationType)
	ConfigTXHandlerSimpleRetryMaxDelay          = ffc("config.transactions.handler.simple.retry.maxDelay", "Maximum delay between retries for retrieving transactions from the persistence", i18n.TimeDurationType)
	ConfigTXHandlerSimpleRetryFactor            = ffc("config.transactions.handler.simple.retry.factor", "Factor to increase the delay by, between each retry for retrieving transactions from the persistence", i18n.FloatType)
	ConfigTXHandlerSimpleGasOracleEnabled       = ffc("config.transactions.handler.simple.gasOracle.mode", "The gas oracle mode", "'connector', 'restapi', 'fixed', or 'disabled'")
	ConfigTXHandlerSimpleGasOracleGoTemplate    = ffc("config.transactions.handler.simple.gasOracle.template", "REST API Gas Oracle: A go template to execute against the result from the Gas Oracle, to create a JSON block that will be passed as the gas price to the connector", i18n.GoTemplateType)
	ConfigTXHandlerSimpleGasOracleURL           = ffc("config.transactions.handler.simple.gasOracle.url", "REST API Gas Oracle: The URL of a Gas Oracle REST API to call", i18n.StringType)
	ConfigTXHandlerSimpleGasOracleProxyURL      = ffc("config.transactions.handler.simple.gasOracle.proxy.url", "Optional HTTP proxy URL to use for the Gas Oracle REST API", i18n.StringType)
	ConfigPTXHandlerSimpleGasOracleMethod       = ffc("config.transactions.handler.simple.gasOracle.method", "The HTTP Method to use when invoking the Gas Oracle REST API", i18n.StringType)
	ConfigTXHandlerSimpleGasOracleQueryInterval = ffc("config.transactions.handler.simple.gasOracle.queryInterval", "The minimum interval between queries to the Gas Oracle", i18n.TimeDurationType)

	ConfigEventStreamsDefaultsBatchSize                 = ffc("config.eventstreams.defaults.batchSize", "Default batch size for newly created event streams", i18n.IntType)
	ConfigEventStreamsDefaultsBatchTimeout              = ffc("config.eventstreams.defaults.batchTimeout", "Default batch timeout for newly created event streams", i18n.TimeDurationType)
	ConfigEventStreamsDefaultsErrorHandling             = ffc("config.eventstreams.defaults.errorHandling", "Default error handling for newly created event streams", "'skip' or 'block'")
	ConfigEventStreamsDefaultsRetryTimeout              = ffc("config.eventstreams.defaults.retryTimeout", "Default retry timeout for newly created event streams", i18n.TimeDurationType)
	ConfigEventStreamsDefaultsBlockedRetryDelay         = ffc("config.eventstreams.defaults.blockedRetryDelay", "Default blocked retry delay for newly created event streams", i18n.TimeDurationType)
	ConfigEventStreamsDefaultsWebhookRequestTimeout     = ffc("config.eventstreams.defaults.webhookRequestTimeout", "Default WebHook request timeout for newly created event streams", i18n.TimeDurationType)
	ConfigEventStreamsDefaultsWebsocketDistributionMode = ffc("config.eventstreams.defaults.websocketDistributionMode", "Default WebSocket distribution mode for newly created event streams", "'load_balance' or 'broadcast'")
	ConfigEventStreamsCheckpointInterval                = ffc("config.eventstreams.checkpointInterval", "Regular interval to write checkpoints for an event stream listener that is not actively detecting/delivering events", i18n.TimeDurationType)
	ConfigEventStreamsRetryInitDelay                    = ffc("config.eventstreams.retry.initialDelay", "Initial retry delay", i18n.TimeDurationType)
	ConfigEventStreamsRetryMaxDelay                     = ffc("config.eventstreams.retry.maxDelay", "Maximum delay between retries", i18n.TimeDurationType)
	ConfigEventStreamsRetryFactor                       = ffc("config.eventstreams.retry.factor", "Factor to increase the delay by, between each retry", i18n.FloatType)

	ConfigPersistenceType              = ffc("config.persistence.type", "The type of persistence to use", "`leveldb`, `postgres`(supports rich query)")
	ConfigPersistenceLevelDBPath       = ffc("config.persistence.leveldb.path", "The path for the LevelDB persistence directory", i18n.StringType)
	ConfigPersistenceLevelDBMaxHandles = ffc("config.persistence.leveldb.maxHandles", "The maximum number of cached file handles LevelDB should keep open", i18n.IntType)
	ConfigPersistenceLevelDBSyncWrites = ffc("config.persistence.leveldb.syncWrites", "Whether to synchronously perform writes to the storage", i18n.BooleanType)

	ConfigWebhooksAllowPrivateIPs = ffc("config.webhooks.allowPrivateIPs", "Whether to allow WebHook URLs that resolve to Private IP address ranges (vs. internet addresses)", i18n.BooleanType)
	ConfigWebhooksURL             = ffc("config.webhooks.url", "Unused (overridden by the WebHook configuration of an individual event stream)", i18n.IgnoredType)
	ConfigWebhooksProxyURL        = ffc("config.webhooks.proxy.url", "Optional HTTP proxy to use when invoking WebHooks", i18n.StringType)

	ConfigMetricsAddress         = ffc("config.metrics.address", "The IP address on which the metrics HTTP API should listen", i18n.IntType)
	ConfigMetricsEnabled         = ffc("config.metrics.enabled", "Enables the metrics API", i18n.BooleanType)
	ConfigMetricsPath            = ffc("config.metrics.path", "The path from which to serve the Prometheus metrics", i18n.StringType)
	ConfigMetricsPort            = ffc("config.metrics.port", "The port on which the metrics HTTP API should listen", i18n.IntType)
	ConfigMetricsPublicURL       = ffc("config.metrics.publicURL", "The fully qualified public URL for the metrics API. This is used for building URLs in HTTP responses and in OpenAPI Spec generation", "URL "+i18n.StringType)
	ConfigMetricsReadTimeout     = ffc("config.metrics.readTimeout", "The maximum time to wait when reading from an HTTP connection", i18n.TimeDurationType)
	ConfigMetricsWriteTimeout    = ffc("config.metrics.writeTimeout", "The maximum time to wait when writing to an HTTP connection", i18n.TimeDurationType)
	ConfigMetricsShutdownTimeout = ffc("config.metrics.shutdownTimeout", "The maximum amount of time to wait for any open HTTP requests to finish before shutting down the HTTP server", i18n.TimeDurationType)

	ConfigDatabasePostgresMaxConnIdleTime   = ffc("config.persistence.postgres.maxConnIdleTime", "The maximum amount of time a database connection can be idle", i18n.TimeDurationType)
	ConfigDatabasePostgresMaxConnLifetime   = ffc("config.persistence.postgres.maxConnLifetime", "The maximum amount of time to keep a database connection open", i18n.TimeDurationType)
	ConfigDatabasePostgresMaxConns          = ffc("config.persistence.postgres.maxConns", "Maximum connections to the database", i18n.IntType)
	ConfigDatabasePostgresMaxIdleConns      = ffc("config.persistence.postgres.maxIdleConns", "The maximum number of idle connections to the database", i18n.IntType)
	ConfigDatabasePostgresURL               = ffc("config.persistence.postgres.url", "The PostgreSQL connection string for the database", i18n.StringType)
	ConfigGlobalMigrationsAuto              = ffc("config.global.migrations.auto", "Enables automatic database migrations", i18n.BooleanType)
	ConfigGlobalMigrationsDirectory         = ffc("config.global.migrations.directory", "The directory containing the numerically ordered migration DDL files to apply to the database", i18n.StringType)
	ConfigTXWriterBatchSize                 = ffc("config.global.txwriter.batchSize", "Number of persistence operations on transactions to attempt to group into a DB transaction", i18n.IntType)
	ConfigTXWriterBatchTimeout              = ffc("config.global.txwriter.batchTimeout", "Duration to hold batch open for new transaction operations before flushing to the DB", i18n.TimeDurationType)
	ConfigTXWriterCacheSlots                = ffc("config.global.txwriter.cacheSlots", "Number of transactions to hold cached metadata for to avoid DB read operations to calculate history", i18n.IntType)
	ConfigTXWriterCount                     = ffc("config.global.txwriter.count", "Number of transactions writing routines to start", i18n.IntType)
	ConfigTXWriterHistoryCompactionInterval = ffc("config.global.txwriter.historyCompactionInterval", "Duration between cleanup activities on the DB for a transaction with a large history", i18n.TimeDurationType)
	ConfigTXWriterHistorySummaryLimit       = ffc("config.global.txwriter.historySummaryLimit", "Maximum number of action entries to return embedded in the JSON response object when querying a transaction summary", i18n.IntType)
)

var (
	MsgInvalidOutputType                       = ffe("FF21010", "Invalid output type: %s")
	MsgConnectorError                          = ffe("FF21012", "Connector failed request. requestId=%s reason=%s error: %s")
	MsgConnectorInvalidContentType             = ffe("FF21013", "Connector failed request. requestId=%s invalid response content type: %s")
	MsgInvalidConfirmationRequest              = ffe("FF21016", "Invalid confirmation request %+v")
	MsgCoreError                               = ffe("FF21017", "Error from core status=%d: %s")
	MsgConfigParamNotSet                       = ffe("FF21018", "Configuration parameter '%s' must be set")
	DeprecatedMsgPolicyEngineNotRegistered     = ffe("FF21019", "(Deprecated) No policy engine registered with name '%s'")                // deprecated
	DeprecatedMsgNoGasConfigSetForPolicyEngine = ffe("FF21020", "(Deprecated) A fixed gas price must be set when not using a gas oracle") // deprecated
	MsgErrorQueryingGasOracleAPI               = ffe("FF21021", "Error from gas station API [%d]: %s")
	MsgInvalidRequestErr                       = ffe("FF21022", "Invalid '%s' request: %s", http.StatusBadRequest)
	MsgUnsupportedRequestType                  = ffe("FF21023", "Unsupported request type: %s", http.StatusBadRequest)
	MsgMissingGOTemplate                       = ffe("FF21024", "Missing template for processing response from Gas Oracle REST API")
	MsgBadGOTemplate                           = ffe("FF21025", "Invalid Go template: %s")
	MsgGasOracleResultError                    = ffe("FF21026", "Error processing result from gas station API via template")
	MsgStreamStateError                        = ffe("FF21027", "Event stream is in %s state", http.StatusConflict)
	MsgMissingName                             = ffe("FF21028", "Name is required", http.StatusBadRequest)
	MsgInvalidStreamType                       = ffe("FF21029", "Invalid event stream type '%s'", http.StatusBadRequest)
	MsgMissingWebhookURL                       = ffe("FF21030", "'url' is required for webhook configuration", http.StatusBadRequest)
	MsgStopFailedUpdatingESConfig              = ffe("FF21031", "Failed to stop event stream to apply updated configuration: %s")
	MsgStartFailedUpdatingESConfig             = ffe("FF21032", "Failed to restart event stream while applying updated configuration: %s")
	MsgBlockWebhookAddress                     = ffe("FF21033", "Cannot send Webhook POST to address '%s' for host '%s'")
	MsgInvalidDistributionMode                 = ffe("FF21034", "Invalid distribution mode for WebSocket: %s", http.StatusBadRequest)
	MsgWebhookFailedStatus                     = ffe("FF21035", "Webhook request failed with status %d")
	MsgWSErrorFromClient                       = ffe("FF21036", "Error received from WebSocket client: %s")
	MsgWebSocketClosed                         = ffe("FF21037", "WebSocket '%s' closed")
	MsgWebSocketInterruptedSend                = ffe("FF21038", "Interrupted waiting for WebSocket connection to send event")
	MsgWebSocketInterruptedReceive             = ffe("FF21039", "Interrupted waiting for WebSocket acknowledgment")
	MsgBadListenerOptions                      = ffe("FF21040", "Invalid listener options: %s", http.StatusBadRequest)
	MsgInvalidHost                             = ffe("FF21041", "Cannot send Webhook POST to host '%s': %s")
	MsgWebhookErr                              = ffe("FF21042", "Webhook request failed: %s")
	MsgUnknownPersistence                      = ffe("FF21043", "Unknown persistence type '%s'")
	MsgInvalidLimit                            = ffe("FF21044", "Invalid limit string '%s': %s")
	MsgStreamNotFound                          = ffe("FF21045", "Event stream '%v' not found", http.StatusNotFound)
	MsgListenerNotFound                        = ffe("FF21046", "Event listener '%v' not found", http.StatusNotFound)
	MsgDuplicateStreamName                     = ffe("FF21047", "Duplicate event stream name '%s' used by stream '%s'", http.StatusConflict)
	MsgMissingID                               = ffe("FF21048", "ID is required", http.StatusBadRequest)
	MsgPersistenceInitFail                     = ffe("FF21049", "Failed to initialize '%s' persistence: %s")
	MsgLevelDBPathMissing                      = ffe("FF21050", "Path must be supplied for LevelDB persistence")
	MsgFilterUpdateNotAllowed                  = ffe("FF21051", "Event filters cannot be updated after a listener is created. Previous signature: '%s'. New signature: '%s'")
	MsgResetStreamNotFound                     = ffe("FF21052", "Attempt to reset listener '%s', which is not currently registered on stream '%s'", http.StatusNotFound)
	MsgPersistenceMarshalFailed                = ffe("FF21053", "JSON serialization failed while writing to persistence")
	MsgPersistenceUnmarshalFailed              = ffe("FF21054", "JSON parsing failed while reading from persistence")
	MsgPersistenceReadFailed                   = ffe("FF21055", "Failed to read key '%s' from persistence")
	MsgPersistenceWriteFailed                  = ffe("FF21056", "Failed to read key '%s' from persistence")
	MsgPersistenceDeleteFailed                 = ffe("FF21057", "Failed to delete key '%s' from persistence")
	MsgPersistenceInitFailed                   = ffe("FF21058", "Failed to initialize persistence at path '%s'")
	MsgPersistenceTXIncomplete                 = ffe("FF21059", "Transaction is missing indexed fields")
	MsgNotStarted                              = ffe("FF21060", "Connector has not fully started yet", http.StatusServiceUnavailable)
	MsgPaginationErrTxNotFound                 = ffe("FF21062", "The ID specified in the 'after' option (for pagination) must match an existing transaction: '%s'", http.StatusNotFound)
	MsgTXConflictSignerPending                 = ffe("FF21063", "Only one of 'signer' and 'pending' can be supplied when querying transactions", http.StatusBadRequest)
	MsgInvalidSortDirection                    = ffe("FF21064", "Sort direction must be 'asc'/'ascending' or 'desc'/'descending': '%s'", http.StatusBadRequest)
	MsgDuplicateID                             = ffe("FF21065", "ID '%s' is not unique", http.StatusConflict)
	MsgTransactionFailed                       = ffe("FF21066", "Transaction execution failed")
	MsgTransactionNotFound                     = ffe("FF21067", "Transaction '%s' not found", http.StatusNotFound)
	DeprecatedMsgPolicyEngineRequestTimeout    = ffe("FF21068", "(Deprecated) The policy engine did not acknowledge the request after %.2fs", 408) // deprecated
	DeprecatedMsgPolicyEngineRequestInvalid    = ffe("FF21069", "(Deprecated) Invalid policy engine request type '%d'")                            // deprecated
	MsgTransactionHandlerNotRegistered         = ffe("FF21070", "No transaction handler registered with name '%s'")
	MsgNoGasConfigSetForTransactionHandler     = ffe("FF21071", "A fixed gas price must be set when not using a gas oracle")
	MsgTransactionHandlerRequestTimeout        = ffe("FF21072", "The transaction handler did not acknowledge the request after %.2fs", 408)
	MsgTransactionHandlerRequestInvalid        = ffe("FF21073", "Invalid transaction handler request type '%d'")
	MsgTransactionHandlerResponseNoSequenceID  = ffe("FF21074", "Transaction handler failed to allocate a sequence ID for request '%s'", http.StatusInternalServerError)
	MsgPersistenceSequenceIDNotAllowed         = ffe("FF21075", "New transaction should not have sequence ID")
	MsgInvalidJSONGasObject                    = ffe("FF21076", "Failed to parse response from Gas Oracle REST API as a JSON object")
	MsgTHMetricsInvalidName                    = ffe("FF21077", "Transaction handler metrics registration name can only contain lowercase letters and underscore. Actual name:%s")
	MsgTHMetricsHelpTextMissing                = ffe("FF21078", "Transaction handler metrics registration help text must be provided")
	MsgTHMetricsDuplicateName                  = ffe("FF21080", "Transaction handler metrics registration invalid name already registered: %s")
	MsgInvalidNonRichQuery                     = ffe("FF21081", "Rich query is not supported by persistence. Query params limited to %v")
	MsgSQLScanFailed                           = ffe("FF21082", "Failed to read value from DB (%T)")
	MsgShuttingDown                            = ffe("FF21083", "Connector shutdown initiated", 500)
	MsgTransactionPersistenceError             = ffe("FF21084", "Failed to persist transaction data", 500)
	MsgOpNotSupportedWithoutRichQuery          = ffe("FF21085", "Not supported: The connector must be configured with a rich query database to support this operation", 501)
	MsgTransactionOpInvalid                    = ffe("FF21086", "Transaction operation is missing required fields", 400)
)