signermsgs

var (
	APIIntegerDescription = ffm("api.integer", "An integer. You are recommended to use a JSON string. A JSON number can be used for values up to the safe maximum.")
	APIBoolDescription    = ffm("api.bool", "A boolean. You can use a boolean or a string true/false as input")
	APIFloatDescription   = ffm("api.float", "A floating point number, which will be converted to a fixed point number. You are recommended to use a JSON string. A JSON number can be used for values up to the safe maximum.")
	APIHexDescription     = ffm("api.hex", "A hex encoded set of bytes, with an optional '0x' prefix")
)

var (
	ConfigFileWalletEnabled                      = ffc("config.fileWallet.enabled", "Whether the Keystore V3 filesystem wallet is enabled", "boolean")
	ConfigFileWalletPath                         = ffc("config.fileWallet.path", "Path on the filesystem where the metadata files (and/or key files) are located", "string")
	ConfigFileWalletFilenamesPrimaryBatchRegex   = ffc("config.fileWallet.filenames.primaryMatchRegex", "Regular expression run against key/metadata filenames to extract the address (takes precedence over primaryExt)", "regexp")
	ConfigFileWalletFilenamesWith0xPrefix        = ffc("config.fileWallet.filenames.with0xPrefix", "When true and passwordExt is used, password filenames will be generated with an 0x prefix", "boolean")
	ConfigFileWalletFilenamesPrimaryExt          = ffc("config.fileWallet.filenames.primaryExt", "Extension for key/metadata files named by <ADDRESS>.<EXT>", "string")
	ConfigFileWalletFilenamesPasswordExt         = ffc("config.fileWallet.filenames.passwordExt", "Optional to use to look up password files, that sit next to the key files directly. Alternative to metadata when you have a password per keystore", "string")
	ConfigFileWalletFilenamesPasswordPath        = ffc("config.fileWallet.filenames.passwordPath", "Optional directory in which to look for the password files, when passwordExt is configured. Default is the wallet directory", "string")
	ConfigFileWalletFilenamesPasswordTrimSpace   = ffc("config.fileWallet.filenames.passwordTrimSpace", "Whether to trim leading/trailing whitespace (such as a newline) from the password when loaded from file", "boolean")
	ConfigFileWalletDefaultPasswordFile          = ffc("config.fileWallet.defaultPasswordFile", "Optional default password file to use, if one is not specified individually for the key (via metadata, or file extension)", "string")
	ConfigFileWalletDisableListener              = ffc("config.fileWallet.disableListener", "Disable the filesystem listener that automatically detects the creation of new keystore files", "boolean")
	ConfigFileWalletSignerCacheSize              = ffc("config.fileWallet.signerCacheSize", "Maximum of signing keys to hold in memory", "number")
	ConfigFileWalletSignerCacheTTL               = ffc("config.fileWallet.signerCacheTTL", "How long ot leave an unused signing key in memory", "duration")
	ConfigFileWalletMetadataFormat               = ffc("config.fileWallet.metadata.format", "Set this if the primary key file is a metadata file. Supported formats: auto (from extension) / filename / toml / yaml / json (please quote \"0x...\" strings in YAML)", "string")
	ConfigFileWalletMetadataKeyFileProperty      = ffc("config.fileWallet.metadata.keyFileProperty", "Go template to look up the key-file path from the metadata. Example: '{{ index .signing \"key-file\" }}'", "go-template")
	ConfigFileWalletMetadataPasswordFileProperty = ffc("config.fileWallet.metadata.passwordFileProperty", "Go template to look up the password-file path from the metadata", "go-template")

	ConfigServerAddress      = ffc("config.server.address", "Local address for the JSON/RPC server to listen on", "string")
	ConfigServerPort         = ffc("config.server.port", "Port for the JSON/RPC server to listen on", "number")
	ConfigAPIPublicURL       = ffc("config.server.publicURL", "External address callers should access API over", "string")
	ConfigServerReadTimeout  = ffc("config.server.readTimeout", "The maximum time to wait when reading from an HTTP connection", "duration")
	ConfigServerWriteTimeout = ffc("config.server.writeTimeout", "The maximum time to wait when writing to a HTTP connection", "duration")
	ConfigAPIShutdownTimeout = ffc("config.server.shutdownTimeout", "The maximum amount of time to wait for any open HTTP requests to finish before shutting down the HTTP server", i18n.TimeDurationType)

	ConfigBackendChainID  = ffc("config.backend.chainId", "Optionally set the Chain ID of the blockchain. Otherwise the Network ID will be queried, and used as the Chain ID in signing", "number")
	ConfigBackendURL      = ffc("config.backend.url", "URL for the backend JSON/RPC server / blockchain node", "url")
	ConfigBackendProxyURL = ffc("config.backend.proxy.url", "Optional HTTP proxy URL", "url")
)

var (
	MsgInvalidOutputType           = ffe("FF22010", "Invalid output type: %s")
	MsgInvalidParam                = ffe("FF22011", "Invalid parameter at position %d for method %s: %s")
	MsgRPCRequestFailed            = ffe("FF22012", "Backend RPC request failed: %s")
	MsgReadDirFile                 = ffe("FF22013", "Directory listing failed")
	MsgWalletNotAvailable          = ffe("FF22014", "Wallet for address '%s' not available", 404)
	MsgWalletFailed                = ffe("FF22015", "Wallet for address '%s' could not be initialized")
	MsgBadGoTemplate               = ffe("FF22016", "Bad go template for '%s' - try something like '{{ index .signing \"key-file\" }}' syntax")
	MsgNoWalletEnabled             = ffe("FF22017", "No wallets enabled in configuration")
	MsgInvalidRequest              = ffe("FF22018", "Invalid request data")
	MsgInvalidParamCount           = ffe("FF22019", "Invalid number of parameters: expected=%d received=%d")
	MsgMissingFrom                 = ffe("FF22020", "Missing 'from' address")
	MsgQueryChainID                = ffe("FF22021", "Failed to query Chain ID")
	MsgSigningFailed               = ffe("FF22022", "Signing failed: %s")
	MsgInvalidTransaction          = ffe("FF22023", "Invalid eth_sendTransaction input")
	MsgMissingRequestID            = ffe("FF22024", "Invalid JSON/RPC request. Must set request ID")
	MsgUnsupportedABIType          = ffe("FF22025", "Unsupported elementary type '%s' in ABI type '%s'")
	MsgUnsupportedABISuffix        = ffe("FF22026", "Unsupported type suffix '%s' in ABI type '%s' - expected %s")
	MsgMissingABISuffix            = ffe("FF22027", "Missing type suffix in ABI type '%s' - expected %s")
	MsgInvalidABISuffix            = ffe("FF22028", "Invalid suffix in ABI type '%s' - expected %s")
	MsgInvalidABIArraySpec         = ffe("FF22029", "Invalid array suffix in ABI type '%s'")
	MsgInvalidIntegerABIInput      = ffe("FF22030", "Unable to parse '%v' of type %T as integer for component %s")
	MsgInvalidFloatABIInput        = ffe("FF22031", "Unable to parse '%v' of type %T as floating point number for component %s")
	MsgInvalidStringABIInput       = ffe("FF22032", "Unable to parse '%v' of type %T as string for component %s")
	MsgInvalidBoolABIInput         = ffe("FF22033", "Unable to parse '%v' of type %T as boolean for component %s")
	MsgInvalidHexABIInput          = ffe("FF22034", "Unable to parse input of type %T as hex for component %s")
	MsgMustBeSliceABIInput         = ffe("FF22035", "Unable to parse input of type %T for component %s - must be an array")
	MsgFixedLengthABIArrayMismatch = ffe("FF22036", "Input array is length %d, and required fixed array length is %d for component %s")
	MsgTupleABIArrayMismatch       = ffe("FF22037", "Input array is length %d, and required tuple component count is %d for component %s")
	MsgTupleABINotArrayOrMap       = ffe("FF22038", "Input type %T is not array or map for component %s")
	MsgTupleInABINoName            = ffe("FF22039", "Tuple child %d does not have a name for component %s")
	MsgMissingInputKeyABITuple     = ffe("FF22040", "Input map missing key '%s' required for tuple component %s")
	MsgBadABITypeComponent         = ffe("FF22041", "Bad ABI type component: %d")
	MsgWrongTypeComponentABIEncode = ffe("FF22042", "Incorrect type expected=%s found=%T for ABI encoding of component %s")
	MsgInsufficientDataABIEncode   = ffe("FF22043", "Insufficient data elements on input expected=%d found=%d for ABI encoding of component %s")
	MsgNumberTooLargeABIEncode     = ffe("FF22044", "Numeric value does not fit in bit length %d for ABI encoding of component %s")
	MsgNotEnoughBytesABIArrayCount = ffe("FF22045", "Insufficient bytes to read array index for component %s")
	MsgABIArrayCountTooLarge       = ffe("FF22046", "Array index %s too large for component %s")
	MsgNotEnoughBytesABIValue      = ffe("FF22047", "Insufficient bytes to read %s value %s")
	MsgNotEnoughBytesABISignature  = ffe("FF22048", "Insufficient bytes to read signature")
	MsgIncorrectABISignatureID     = ffe("FF22049", "Incorrect ID for signature %s expected=%s found=%s")
	MsgUnknownABIElementaryType    = ffe("FF22050", "Unknown elementary type %s for component %s")
	MsgUnknownTupleSerializer      = ffe("FF22051", "Unknown tuple serialization option %d")
	MsgInvalidFFIDetailsSchema     = ffe("FF22052", "Invalid FFI details schema for '%s'")
	MsgEventsInsufficientTopics    = ffe("FF22053", "Ran out of topics for indexed fields at field %d of %s")
	MsgEventSignatureMismatch      = ffe("FF22054", "Event signature mismatch for '%s': expected='%s' found='%s'")
	MsgFFITypeMismatch             = ffe("FF22055", "Input type '%s' is not valid for ABI type '%s'")
	MsgBadRegularExpression        = ffe("FF22056", "Bad regular expression for /%s/: %s")
	MsgMissingRegexpCaptureGroup   = ffe("FF22057", "Regular expression is missing a capture group (subexpression) for address: /%s/")
	MsgAddressMismatch             = ffe("FF22059", "Address '%s' loaded from wallet file does not match requested lookup address / filename '%s'")
	MsgFailedToStartListener       = ffe("FF22060", "Failed to start filesystem listener: %s")
	MsgDecodeNotTuple              = ffe("FF22061", "Decode can only be called against a root tuple component type=%d")
	MsgNegativeUnsignedABIEncode   = ffe("FF22062", "Negative numeric value is invalid for component %s")
	MsgRequestCanceledContext      = ffe("FF22063", "Request with id %s failed due to canceled context")
	MsgInvalidSigner               = ffe("FF22064", "Invalid signer")
	MsgResultParseFailed           = ffe("FF22065", "Failed to parse result (expected=%T): %s")
	MsgSubscribeResponseInvalid    = ffe("FF22066", "Subscription response invalid")
	MsgWebSocketReconnected        = ffe("FF22067", "WebSocket reconnected during JSON/RPC call")
	MsgContextCancelledWSConnect   = ffe("FF22068", "Context canceled while connecting WebSocket")
	MsgNotElementary               = ffe("FF22069", "Not elementary type: %s")
	MsgEIP712UnknownABICompType    = ffe("FF22070", "Unknown ABI component type: %s")
	MsgEIP712UnsupportedStrType    = ffe("FF22071", "Unsupported type: %s")
	MsgEIP712UnsupportedABIType    = ffe("FF22072", "ABI type not supported by EIP-712 encoding: %s")
	MsgEIP712TypeNotFound          = ffe("FF22073", "Type '%s' not found in type map")
	MsgEIP712PrimaryNotTuple       = ffe("FF22074", "Type primary type must be a struct/tuple: %s")
	MsgEIP712BadInternalType       = ffe("FF22075", "Failed to extract struct name from ABI internalType '%s'")
	MsgEIP712ValueNotMap           = ffe("FF22076", "Value for struct '%s' not a map (%T)")
	MsgEIP712InvalidArraySuffix    = ffe("FF22077", "Type '%s' has invalid array suffix")
	MsgEIP712ValueNotArray         = ffe("FF22078", "Value for '%s' not an array (%T)")
	MsgEIP712InvalidArrayLen       = ffe("FF22079", "Value for '%s' must have %d entries (found %d)")
	MsgEIP712PrimaryTypeRequired   = ffe("FF22080", "Primary type must be specified")
)

var (
	ABIEntryAnonymous       = ffm("EthABIEntry.anonymous", "If the event is anonymous then the signature of the event does not take up a topic slot")
	ABIEntryType            = ffm("EthABIEntry.type", "The type of the ABI entry: 'event', 'error', 'function', 'constructor', 'receive', or 'fallback'")
	ABIEntryName            = ffm("EthABIEntry.name", "The name of the ABI entry")
	ABIEntryInputs          = ffm("EthABIEntry.inputs", "Array of ABI parameter definitions")
	ABIEntryOutputs         = ffm("EthABIEntry.outputs", "Array of ABI parameter definitions")
	ABIEntryStateMutability = ffm("EthABIEntry.stateMutability", "The state mutability of the function: 'pure', 'view', 'nonpayable' (the default) and 'payable'")
	ABIEntryConstant        = ffm("EthABIEntry.constant", "Functions only: Superseded by stateMutability payable/nonpayable")
	ABIEntryPayable         = ffm("EthABIEntry.payable", "Functions only: Superseded by stateMutability pure/view")

	ABIParameterName         = ffm("EthABIParameter.name", "The name of the parameter")
	ABIParameterType         = ffm("EthABIParameter.type", "The type of the parameter per the ABI specification")
	ABIParameterComponents   = ffm("EthABIParameter.components", "An array of components, if the parameter is a tuple")
	ABIParameterIndexed      = ffm("EthABIParameter.indexed", "Whether this parameter uses one of the topics, or is in the data area")
	ABIParameterInternalType = ffm("EthABIParameter.internalType", "Used by the solc compiler to include additional details - importantly the struct name for tuples")

	EthTransactionFrom                 = ffm("EthTransaction.internalType", "The from address (not encoded into the transaction directly, but used on this structure on input)")
	EthTransactionNonce                = ffm("EthTransaction.nonce", "Number used once (nonce) that specifies the sequence of this transaction in all transactions sent to the chain from this signing address")
	EthTransactionGasPrice             = ffm("EthTransaction.gasPrice", "The price per unit offered for the gas used when executing this transaction, if submitting to a chain that requires gas fees (in wei of the native chain token)")
	EthTransactionMaxPriorityFeePerGas = ffm("EthTransaction.maxPriorityFeePerGas", "Part of the EIP-1559 extension to transaction pricing. The amount provided to the miner of the block per unit of gas, in addition to the base fee (which is burned when the block is mined)")
	EthTransactionMaxFeePerGas         = ffm("EthTransaction.maxFeePerGas", "Part of the EIP-1559 extension to transaction pricing. The total amount you are willing to pay per unit of gas used by your contract, which is the total of the baseFeePerGas (determined by the chain at execution time) and the maxPriorityFeePerGas")
	EthTransactionGas                  = ffm("EthTransaction.gas", "The gas limit for execution of your transaction. Must be provided regardless of whether you paying a fee for the gas")
	EthTransactionTo                   = ffm("EthTransaction.to", "The target address of the transaction. Omitted for contract deployments")
	EthTransactionValue                = ffm("EthTransaction.value", "An optional amount of native token to transfer along with the transaction (in wei)")
	EthTransactionData                 = ffm("EthTransaction.data", "The encoded and signed transaction payload")

	EIP712ResultHash         = ffm("EIP712Result.hash", "The EIP-712 hash generated according to the Typed Data V4 algorithm")
	EIP712ResultSignatureRSV = ffm("EIP712Result.signatureRSV", "Hex encoded array of 65 bytes containing the R, S & V of the ECDSA signature. This is the standard signature encoding used in Ethereum recover utilities (note that some other utilities might expect a different encoding/packing of the data)")
	EIP712ResultV            = ffm("EIP712Result.v", "The V value of the ECDSA signature as a hex encoded integer")
	EIP712ResultR            = ffm("EIP712Result.r", "The R value of the ECDSA signature as a 32byte hex encoded array")
	EIP712ResultS            = ffm("EIP712Result.s", "The S value of the ECDSA signature as a 32byte hex encoded array")

	TypedDataDomain      = ffm("TypedData.domain", "The data to encode into the EIP712Domain as part fo signing the transaction")
	TypedDataMessage     = ffm("TypedData.message", "The data to encode into primaryType structure, with nested values for any sub-structures")
	TypedDataTypes       = ffm("TypedData.types", "Array of types to use when encoding, which must include the primaryType and the EIP712Domain (noting the primary type can be EIP712Domain if the message is empty)")
	TypedDataPrimaryType = ffm("TypedData.primaryType", "The primary type to begin encoding the EIP-712 hash from in the list of types, using the input message (unless set directly to EIP712Domain, in which case the message can be omitted)")
)