common

Documentation

Index

• Variables
• type SigningError
  • func (SigningError) Descriptor() protoreflect.EnumDescriptor
  • func (x SigningError) Enum() *SigningError
  • func (SigningError) EnumDescriptor() ([]byte, []int)
  • func (x SigningError) Number() protoreflect.EnumNumber
  • func (x SigningError) String() string
  • func (SigningError) Type() protoreflect.EnumType

Variables

var (
	SigningError_name = map[int32]string{
		0:  "OK",
		1:  "Error_general",
		2:  "Error_internal",
		3:  "Error_low_balance",
		4:  "Error_zero_amount_requested",
		5:  "Error_missing_private_key",
		15: "Error_invalid_private_key",
		16: "Error_invalid_address",
		17: "Error_invalid_utxo",
		18: "Error_invalid_utxo_amount",
		6:  "Error_wrong_fee",
		7:  "Error_signing",
		8:  "Error_tx_too_big",
		9:  "Error_missing_input_utxos",
		10: "Error_not_enough_utxos",
		11: "Error_script_redeem",
		12: "Error_script_output",
		13: "Error_script_witness_program",
		14: "Error_invalid_memo",
		19: "Error_input_parse",
		20: "Error_no_support_n2n",
		21: "Error_signatures_count",
		22: "Error_invalid_params",
		23: "Error_invalid_requested_token_amount",
	}
	SigningError_value = map[string]int32{
		"OK":                                   0,
		"Error_general":                        1,
		"Error_internal":                       2,
		"Error_low_balance":                    3,
		"Error_zero_amount_requested":          4,
		"Error_missing_private_key":            5,
		"Error_invalid_private_key":            15,
		"Error_invalid_address":                16,
		"Error_invalid_utxo":                   17,
		"Error_invalid_utxo_amount":            18,
		"Error_wrong_fee":                      6,
		"Error_signing":                        7,
		"Error_tx_too_big":                     8,
		"Error_missing_input_utxos":            9,
		"Error_not_enough_utxos":               10,
		"Error_script_redeem":                  11,
		"Error_script_output":                  12,
		"Error_script_witness_program":         13,
		"Error_invalid_memo":                   14,
		"Error_input_parse":                    19,
		"Error_no_support_n2n":                 20,
		"Error_signatures_count":               21,
		"Error_invalid_params":                 22,
		"Error_invalid_requested_token_amount": 23,
	}
)

Enum value maps for SigningError.

var File_Common_proto protoreflect.FileDescriptor

Types

type SigningError

type SigningError int32

Error codes, used in multiple blockchains.

const (
	// This is the OK case, with value=0
	SigningError_OK SigningError = 0
	// Chain-generic codes:
	// Generic error (used if there is no suitable specific error is adequate)
	SigningError_Error_general SigningError = 1
	// Internal error, indicates some very unusual, unexpected case
	SigningError_Error_internal SigningError = 2
	// Chain-generic codes, input related:
	// Low balance: the sender balance is not enough to cover the send and other auxiliary amount such as fee, deposit, or minimal balance.
	SigningError_Error_low_balance SigningError = 3
	// Requested amount is zero, send of 0 makes no sense
	SigningError_Error_zero_amount_requested SigningError = 4
	// One required key is missing (too few or wrong keys are provided)
	SigningError_Error_missing_private_key SigningError = 5
	// A private key provided is invalid (e.g. wrong size, usually should be 32 bytes)
	SigningError_Error_invalid_private_key SigningError = 15
	// A provided address (e.g. destination address) is invalid
	SigningError_Error_invalid_address SigningError = 16
	// A provided input UTXO is invalid
	SigningError_Error_invalid_utxo SigningError = 17
	// The amount of an input UTXO is invalid
	SigningError_Error_invalid_utxo_amount SigningError = 18
	// Chain-generic, fee related:
	// Wrong fee is given, probably it is too low to cover minimal fee for the transaction
	SigningError_Error_wrong_fee SigningError = 6
	// Chain-generic, signing related:
	// General signing error
	SigningError_Error_signing SigningError = 7
	// Resulting transaction is too large
	// [NEO] Transaction too big, fee in GAS needed or try send by parts
	SigningError_Error_tx_too_big SigningError = 8
	// UTXO-chain specific, input related:
	// No input UTXOs provided [BTC]
	SigningError_Error_missing_input_utxos SigningError = 9
	// Not enough non-dust input UTXOs to cover requested amount (dust UTXOs are filtered out) [BTC]
	SigningError_Error_not_enough_utxos SigningError = 10
	// UTXO-chain specific, script related:
	// [BTC] Missing required redeem script
	SigningError_Error_script_redeem SigningError = 11
	// [BTC] Invalid required output script
	SigningError_Error_script_output SigningError = 12
	// [BTC] Unrecognized witness program
	SigningError_Error_script_witness_program SigningError = 13
	// Invalid memo, e.g. [XRP] Invalid tag
	SigningError_Error_invalid_memo SigningError = 14
	// Some input field cannot be parsed
	SigningError_Error_input_parse SigningError = 19
	// Multi-input and multi-output transaction not supported
	SigningError_Error_no_support_n2n SigningError = 20
	// Incorrect count of signatures passed to compile
	SigningError_Error_signatures_count SigningError = 21
	// Incorrect input parameter
	SigningError_Error_invalid_params SigningError = 22
	// Invalid input token amount
	SigningError_Error_invalid_requested_token_amount SigningError = 23
)

func (SigningError) Descriptor

func (SigningError) Descriptor() protoreflect.EnumDescriptor

func (SigningError) Enum

func (x SigningError) Enum() *SigningError

func (SigningError) EnumDescriptor

func (SigningError) EnumDescriptor() ([]byte, []int)

Deprecated: Use SigningError.Descriptor instead.

func (SigningError) Number

func (x SigningError) Number() protoreflect.EnumNumber

func (SigningError) String

func (x SigningError) String() string

func (SigningError) Type

func (SigningError) Type() protoreflect.EnumType