RPC Errors

This document references possible errors that can come from RPC calls. It is generated from the OCaml source code (master branch).

Protocol Alpha

Insufficient block proof-of-work stamp

The block's proof-of-work stamp is insufficient

Id : proto.005-PsBabyM1.baking.insufficient_proof_of_work
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.baking.insufficient_proof_of_work" }

Invalid block signature

A block was not signed with the expected private key.

Id : proto.005-PsBabyM1.baking.invalid_block_signature
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.baking.invalid_block_signature",
    "block": $block_hash,
    "expected": $Signature.Public_key_hash }
  $Signature.Public_key_hash:
    /* A Ed25519, Secp256k1, or P256 public key hash (Base58Check-encoded) */
    $unistring
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Invalid fitness gap

The gap of fitness is out of bounds

Id : proto.005-PsBabyM1.baking.invalid_fitness_gap
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.baking.invalid_fitness_gap",
    "maximum": $int64,
    "provided": $int64 }
  $int64:
    /* 64 bit integers
       Decimal representation of 64 bit integers */
    string

Invalid block signature

The block's signature is invalid

Id : proto.005-PsBabyM1.baking.invalid_signature
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.baking.invalid_signature" }

Block forged too early

The block timestamp is before the first slot for this baker at this level

Id : proto.005-PsBabyM1.baking.timestamp_too_early
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.baking.timestamp_too_early",
    "minimum": $timestamp.protocol,
    "provided": $timestamp.protocol }
  $int64:
    /* 64 bit integers
       Decimal representation of 64 bit integers */
    string
  $timestamp.protocol:
    /* A timestamp as seen by the protocol: second-level precision, epoch
       based. */
    $timestamp.rfc || $int64
  $timestamp.rfc:
    /* RFC 3339 formatted timestamp
       A date in RFC 3339 notation. */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Endorsement from unexpected delegate

The operation is signed by a delegate without endorsement rights.

Id : proto.005-PsBabyM1.baking.unexpected_endorsement
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.baking.unexpected_endorsement",
    ... }

Inconsistent double baking evidence

A double-baking evidence is inconsistent (two distinct delegates)

Id : proto.005-PsBabyM1.block.inconsistent_double_baking_evidence
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.block.inconsistent_double_baking_evidence",
    "delegate1": $Signature.Public_key_hash,
    "delegate2": $Signature.Public_key_hash }
  $Signature.Public_key_hash:
    /* A Ed25519, Secp256k1, or P256 public key hash (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Inconsistent double endorsement evidence

A double-endorsement evidence is inconsistent (two distinct delegates)

Id : proto.005-PsBabyM1.block.inconsistent_double_endorsement_evidence
Category : permanent

  { "kind": "permanent",
    "id":
      "proto.005-PsBabyM1.block.inconsistent_double_endorsement_evidence",
    "delegate1": $Signature.Public_key_hash,
    "delegate2": $Signature.Public_key_hash }
  $Signature.Public_key_hash:
    /* A Ed25519, Secp256k1, or P256 public key hash (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Invalid commitment in block header

The block header has invalid commitment.

Id : proto.005-PsBabyM1.block.invalid_commitment
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.block.invalid_commitment",
    "expected": boolean }

Invalid double baking evidence

A double-baking evidence is inconsistent (two distinct level)

Id : proto.005-PsBabyM1.block.invalid_double_baking_evidence
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.block.invalid_double_baking_evidence",
    "hash1": $block_hash,
    "level1": integer ∈ [-2^31-2, 2^31+2],
    "hash2": $block_hash,
    "level2": integer ∈ [-2^31-2, 2^31+2] }
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Invalid double endorsement evidence

A double-endorsement evidence is malformed

Id : proto.005-PsBabyM1.block.invalid_double_endorsement_evidence
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.block.invalid_double_endorsement_evidence" }

Multiple revelations were included in a manager operation

A manager operation should not contain more than one revelation

Id : proto.005-PsBabyM1.block.multiple_revelation
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.block.multiple_revelation" }

Outdated double baking evidence

A double-baking evidence is outdated.

Id : proto.005-PsBabyM1.block.outdated_double_baking_evidence
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.block.outdated_double_baking_evidence",
    "level": integer ∈ [-2^31-2, 2^31+2],
    "last": integer ∈ [-2^31-2, 2^31+2] }

Outdated double endorsement evidence

A double-endorsement evidence is outdated.

Id : proto.005-PsBabyM1.block.outdated_double_endorsement_evidence
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.block.outdated_double_endorsement_evidence",
    "level": integer ∈ [-2^31-2, 2^31+2],
    "last": integer ∈ [-2^31-2, 2^31+2] }

Too early double baking evidence

A double-baking evidence is in the future

Id : proto.005-PsBabyM1.block.too_early_double_baking_evidence
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.block.too_early_double_baking_evidence",
    "level": integer ∈ [-2^31-2, 2^31+2],
    "current": integer ∈ [-2^31-2, 2^31+2] }

Too early double endorsement evidence

A double-endorsement evidence is in the future

Id : proto.005-PsBabyM1.block.too_early_double_endorsement_evidence
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.block.too_early_double_endorsement_evidence",
    "level": integer ∈ [-2^31-2, 2^31+2],
    "current": integer ∈ [-2^31-2, 2^31+2] }

Unrequired double baking evidence

A double-baking evidence is unrequired

Id : proto.005-PsBabyM1.block.unrequired_double_baking_evidence
Category : branch

  { "kind": "branch",
    "id": "proto.005-PsBabyM1.block.unrequired_double_baking_evidence" }

Unrequired double endorsement evidence

A double-endorsement evidence is unrequired

Id : proto.005-PsBabyM1.block.unrequired_double_endorsement_evidence
Category : branch

  { "kind": "branch",
    "id": "proto.005-PsBabyM1.block.unrequired_double_endorsement_evidence" }

Invalid code notation

A malformed code notation was given to an RPC or in a script.

Id : proto.005-PsBabyM1.code.invalid_code_notation
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.code.invalid_code_notation",
    "notation": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Cannot collect fees from smart contract

An unauthorized collect call was made

Id : proto.005-PsBabyM1.collect_fees.cannot_collect_fees
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.collect_fees.cannot_collect_fees" }

Contract cannot pay fees

The smart contract will not pay fees this large for this call

Id : proto.005-PsBabyM1.collect_fees.contract_cannot_pay_fees
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.collect_fees.contract_cannot_pay_fees",
    "fee": $mutez,
    "max_allowed": $mutez }
  $mutez: $positive_bignum
  $positive_bignum:
    /* Positive big number
       Decimal representation of a positive big number */
    string

Contract cannot pay for storage

The smart contract will pay for this much storage

Id : proto.005-PsBabyM1.collect_fees.contract_cannot_pay_storage
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.collect_fees.contract_cannot_pay_storage",
    "storage_limit": $positive_bignum }
  $positive_bignum:
    /* Positive big number
       Decimal representation of a positive big number */
    string

Gas limit to check fees out of protocol hard bounds

A collect call transaction tried to exceed the hard limit on gas to check fees

Id : proto.005-PsBabyM1.collect_fees.gas_limit_too_high
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.collect_fees.gas_limit_too_high",
    "hard_gas_limit_to_pay_fees": $positive_bignum,
    "fee_gas": $positive_bignum }
  $positive_bignum:
    /* Positive big number
       Decimal representation of a positive big number */
    string

Not enough gas to check that the smart contract allows to pay fees

There was not enough gas provided to execute the code that computes the allowances in fees and storage

Id : proto.005-PsBabyM1.collect_fees.not_enough_gas_to_check_fees
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.collect_fees.not_enough_gas_to_check_fees" }

Failed to decode parameter

Unexpected JSON object.

Id : proto.005-PsBabyM1.context.failed_to_decode_parameter
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.context.failed_to_decode_parameter",
    "contents": any,
    "error": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Failed to parse parameter

The protocol parameters are not valid JSON.

Id : proto.005-PsBabyM1.context.failed_to_parse_parameter
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.context.failed_to_parse_parameter",
    "contents": /^[a-zA-Z0-9]+$/ }

Storage error (fatal internal error)

An error that should never happen unless something has been deleted or corrupted in the database.

Id : proto.005-PsBabyM1.context.storage_error
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.context.storage_error",
    "incompatible_protocol_version": $unistring }
  || { "kind": "permanent",
       "id": "proto.005-PsBabyM1.context.storage_error",
       "missing_key": [ $unistring ... ],
       "function": "set" | "copy" | "get" | "del" }
  || { "kind": "permanent",
       "id": "proto.005-PsBabyM1.context.storage_error",
       "existing_key": [ $unistring ... ] }
  || { "kind": "permanent",
       "id": "proto.005-PsBabyM1.context.storage_error",
       "corrupted_data": [ $unistring ... ] }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Balance too low

An operation tried to spend more tokens than the contract has

Id : proto.005-PsBabyM1.contract.balance_too_low
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.contract.balance_too_low",
    "contract": $contract_id,
    "balance": $mutez,
    "amount": $mutez }
  $contract_id:
    /* A contract handle
       A contract notation as given to an RPC or inside scripts. Can be a
       base58 implicit contract hash or a base58 originated contract hash. */
    $unistring
  $mutez: $positive_bignum
  $positive_bignum:
    /* Positive big number
       Decimal representation of a positive big number */
    string
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Cannot pay storage fee

The storage fee is higher than the contract balance

Id : proto.005-PsBabyM1.contract.cannot_pay_storage_fee
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.contract.cannot_pay_storage_fee" }

Invalid counter (not yet reached) in a manager operation

An operation assumed a contract counter in the future

Id : proto.005-PsBabyM1.contract.counter_in_the_future
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.contract.counter_in_the_future",
    "contract": $contract_id,
    "expected": $bignum,
    "found": $bignum }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $contract_id:
    /* A contract handle
       A contract notation as given to an RPC or inside scripts. Can be a
       base58 implicit contract hash or a base58 originated contract hash. */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Invalid counter (already used) in a manager operation

An operation assumed a contract counter in the past

Id : proto.005-PsBabyM1.contract.counter_in_the_past
Category : branch

  { "kind": "branch",
    "id": "proto.005-PsBabyM1.contract.counter_in_the_past",
    "contract": $contract_id,
    "expected": $bignum,
    "found": $bignum }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $contract_id:
    /* A contract handle
       A contract notation as given to an RPC or inside scripts. Can be a
       base58 implicit contract hash or a base58 originated contract hash. */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Empty transaction

Forbidden to credit 0đ to a contract without code.

Id : proto.005-PsBabyM1.contract.empty_transaction
Category : branch

  { "kind": "branch",
    "id": "proto.005-PsBabyM1.contract.empty_transaction",
    "contract": $contract_id }
  $contract_id:
    /* A contract handle
       A contract notation as given to an RPC or inside scripts. Can be a
       base58 implicit contract hash or a base58 originated contract hash. */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Invalid contract notation

A malformed contract notation was given to an RPC or in a script.

Id : proto.005-PsBabyM1.contract.invalid_contract_notation
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.contract.invalid_contract_notation",
    "notation": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Consume roll change

Change is not enough to consume a roll.

Id : proto.005-PsBabyM1.contract.manager.consume_roll_change
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.contract.manager.consume_roll_change" }

Inconsistent public key hash

A revealed manager public key is inconsistent with the announced hash

Id : proto.005-PsBabyM1.contract.manager.inconsistent_hash
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.contract.manager.inconsistent_hash",
    "public_key": $Signature.Public_key,
    "expected_hash": $Signature.Public_key_hash,
    "provided_hash": $Signature.Public_key_hash }
  $Signature.Public_key:
    /* A Ed25519, Secp256k1, or P256 public key (Base58Check-encoded) */
    $unistring
  $Signature.Public_key_hash:
    /* A Ed25519, Secp256k1, or P256 public key hash (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Inconsistent public key

A provided manager public key is different with the public key stored in the contract

Id : proto.005-PsBabyM1.contract.manager.inconsistent_public_key
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.contract.manager.inconsistent_public_key",
    "public_key": $Signature.Public_key,
    "expected_public_key": $Signature.Public_key }
  $Signature.Public_key:
    /* A Ed25519, Secp256k1, or P256 public key (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

No roll for delegate

Delegate has no roll.

Id : proto.005-PsBabyM1.contract.manager.no_roll_for_delegate
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.contract.manager.no_roll_for_delegate" }

No roll snapshot for cycle

A snapshot of the rolls distribution does not exist for this cycle.

Id : proto.005-PsBabyM1.contract.manager.no_roll_snapshot_for_cycle
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.contract.manager.no_roll_snapshot_for_cycle",
    "cycle": integer ∈ [-2^31-2, 2^31+2] }

Unregistered delegate

A contract cannot be delegated to an unregistered delegate

Id : proto.005-PsBabyM1.contract.manager.unregistered_delegate
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.contract.manager.unregistered_delegate",
    "hash": $Signature.Public_key_hash }
  $Signature.Public_key_hash:
    /* A Ed25519, Secp256k1, or P256 public key hash (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Non existing contract

A contract handle is not present in the context (either it never was or it has been destroyed)

Id : proto.005-PsBabyM1.contract.non_existing_contract
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.contract.non_existing_contract",
    "contract": $contract_id }
  $contract_id:
    /* A contract handle
       A contract notation as given to an RPC or inside scripts. Can be a
       base58 implicit contract hash or a base58 originated contract hash. */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Manager operation already revealed

One tried to revealed twice a manager public key

Id : proto.005-PsBabyM1.contract.previously_revealed_key
Category : branch

  { "kind": "branch",
    "id": "proto.005-PsBabyM1.contract.previously_revealed_key",
    "contract": $contract_id }
  $contract_id:
    /* A contract handle
       A contract notation as given to an RPC or inside scripts. Can be a
       base58 implicit contract hash or a base58 originated contract hash. */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Manager operation precedes key revelation

One tried to apply a manager operation without revealing the manager public key

Id : proto.005-PsBabyM1.contract.unrevealed_key
Category : branch

  { "kind": "branch",
    "id": "proto.005-PsBabyM1.contract.unrevealed_key",
    "contract": $contract_id }
  $contract_id:
    /* A contract handle
       A contract notation as given to an RPC or inside scripts. Can be a
       base58 implicit contract hash or a base58 originated contract hash. */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Unspendable contract

An operation tried to spend tokens from an unspendable contract

Id : proto.005-PsBabyM1.contract.unspendable_contract
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.contract.unspendable_contract",
    "contract": $contract_id }
  $contract_id:
    /* A contract handle
       A contract notation as given to an RPC or inside scripts. Can be a
       base58 implicit contract hash or a base58 originated contract hash. */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Delegate already active

Useless delegate reactivation

Id : proto.005-PsBabyM1.delegate.already_active
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.delegate.already_active" }

Balance too low for deposit

Cannot freeze deposit when the balance is too low

Id : proto.005-PsBabyM1.delegate.balance_too_low_for_deposit
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.delegate.balance_too_low_for_deposit",
    "delegate": $Signature.Public_key_hash,
    "balance": $mutez,
    "deposit": $mutez }
  $Signature.Public_key_hash:
    /* A Ed25519, Secp256k1, or P256 public key hash (Base58Check-encoded) */
    $unistring
  $mutez: $positive_bignum
  $positive_bignum:
    /* Positive big number
       Decimal representation of a positive big number */
    string
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Empty delegate account

Cannot register a delegate when its implicit account is empty

Id : proto.005-PsBabyM1.delegate.empty_delegate_account
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.delegate.empty_delegate_account",
    "delegate": $Signature.Public_key_hash }
  $Signature.Public_key_hash:
    /* A Ed25519, Secp256k1, or P256 public key hash (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Forbidden delegate deletion

Tried to unregister a delegate

Id : proto.005-PsBabyM1.delegate.no_deletion
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.delegate.no_deletion",
    "delegate": $Signature.Public_key_hash }
  $Signature.Public_key_hash:
    /* A Ed25519, Secp256k1, or P256 public key hash (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Unchanged delegated

Contract already delegated to the given delegate

Id : proto.005-PsBabyM1.delegate.unchanged
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.delegate.unchanged" }

Overflowing dun addition

An addition of two dun amounts overflowed

Id : proto.005-PsBabyM1.dun.addition_overflow
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.dun.addition_overflow",
    "amounts": [ $positive_bignum, $positive_bignum ] }
  $positive_bignum:
    /* Positive big number
       Decimal representation of a positive big number */
    string

Invalid dun divisor

Multiplication of a dun amount by a non positive integer

Id : proto.005-PsBabyM1.dun.invalid_divisor
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.dun.invalid_divisor",
    "amount": $positive_bignum,
    "divisor": $int64 }
  $int64:
    /* 64 bit integers
       Decimal representation of 64 bit integers */
    string
  $positive_bignum:
    /* Positive big number
       Decimal representation of a positive big number */
    string

Overflowing dun multiplication

A multiplication of a dun amount by an integer overflowed

Id : proto.005-PsBabyM1.dun.multiplication_overflow
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.dun.multiplication_overflow",
    "amount": $positive_bignum,
    "multiplicator": $int64 }
  $int64:
    /* 64 bit integers
       Decimal representation of 64 bit integers */
    string
  $positive_bignum:
    /* Positive big number
       Decimal representation of a positive big number */
    string

Negative dun multiplicator

Multiplication of a dun amount by a negative integer

Id : proto.005-PsBabyM1.dun.negative_multiplicator
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.dun.negative_multiplicator",
    "amount": $positive_bignum,
    "multiplicator": $int64 }
  $int64:
    /* 64 bit integers
       Decimal representation of 64 bit integers */
    string
  $positive_bignum:
    /* Positive big number
       Decimal representation of a positive big number */
    string

Underflowing dun subtraction

An subtraction of two dun amounts underflowed

Id : proto.005-PsBabyM1.dun.subtraction_underflow
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.dun.subtraction_underflow",
    "amounts": [ $positive_bignum, $positive_bignum ] }
  $positive_bignum:
    /* Positive big number
       Decimal representation of a positive big number */
    string

Invalid language argument for the requested operation

The requested operation can't be performed on thespecified language or language combination

Id : proto.005-PsBabyM1.dune_script_interpreter.invalid_language_argument
Category : permanent

  { "kind": "permanent",
    "id":
      "proto.005-PsBabyM1.dune_script_interpreter.invalid_language_argument",
    ... }

The specified language is not supported

The language is not supported on this network

Id : proto.005-PsBabyM1.dune_script_interpreter.unsupported_language
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.dune_script_interpreter.unsupported_language",
    "lang": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Empty proposal

Proposal lists cannot be empty.

Id : proto.005-PsBabyM1.empty_proposal
Category : branch

  { "kind": "branch",
    "id": "proto.005-PsBabyM1.empty_proposal" }

Gas quota exceeded for the block

The sum of gas consumed by all the operations in the block exceeds the hard gas limit per block

Id : proto.005-PsBabyM1.gas_exhausted.block
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.gas_exhausted.block" }

Not enough gas for initial deserialization of script expresions

Gas limit was not high enough to deserialize the transaction parameters or origination script code or initial storage, making the operation impossible to parse within the provided gas bounds.

Id : proto.005-PsBabyM1.gas_exhausted.init_deserialize
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.gas_exhausted.init_deserialize" }

Gas quota exceeded for the operation

A script or one of its callee took more time than the operation said it would

Id : proto.005-PsBabyM1.gas_exhausted.operation
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.gas_exhausted.operation" }

Gas limit out of protocol hard bounds

A transaction tried to exceed the hard limit on gas

Id : proto.005-PsBabyM1.gas_limit_too_high
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.gas_limit_too_high" }

Empty implicit contract

No manager operations are allowed on an empty implicit contract.

Id : proto.005-PsBabyM1.implicit.empty_implicit_contract
Category : branch

  { "kind": "branch",
    "id": "proto.005-PsBabyM1.implicit.empty_implicit_contract",
    "implicit": $Signature.Public_key_hash }
  $Signature.Public_key_hash:
    /* A Ed25519, Secp256k1, or P256 public key hash (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Incorrect number of endorsements

The number of endorsements must be non-negative and at most the endosers_per_block constant.

Id : proto.005-PsBabyM1.incorrect_number_of_endorsements
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.incorrect_number_of_endorsements",
    ... }

Incorrect priority

Block priority must be non-negative.

Id : proto.005-PsBabyM1.incorrect_priority
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.incorrect_priority",
    ... }

Internal operation replay

An internal operation was emitted twice by a script

Id : proto.005-PsBabyM1.internal_operation_replay
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.internal_operation_replay",
    "source": $contract_id,
    "nonce": integer ∈ [0, 2^16-1],
    "kind": "reveal",
    "public_key": $Signature.Public_key }
  || { "kind": "permanent",
       "id": "proto.005-PsBabyM1.internal_operation_replay",
       "source": $contract_id,
       "nonce": integer ∈ [0, 2^16-1],
       "kind": "transaction",
       "amount": $mutez,
       "destination": $contract_id,
       "parameters"?:
         { "entrypoint"?: $entrypoint,
           "value": $micheline.michelson_v1.expression } }
  || { "kind": "permanent",
       "id": "proto.005-PsBabyM1.internal_operation_replay",
       "source": $contract_id,
       "nonce": integer ∈ [0, 2^16-1],
       "kind": "origination",
       "balance": $mutez,
       "delegate"?: $Signature.Public_key_hash,
       "script": $scripted.opt_or_hash }
  || { "kind": "permanent",
       "id": "proto.005-PsBabyM1.internal_operation_replay",
       "source": $contract_id,
       "nonce": integer ∈ [0, 2^16-1],
       "kind": "delegation",
       "delegate"?: $Signature.Public_key_hash }
  || { "kind": "permanent",
       "id": "proto.005-PsBabyM1.internal_operation_replay",
       "source": $contract_id,
       "nonce": integer ∈ [0, 2^16-1],
       "kind": "dune_manager_operation",
       "dune_kind": "dune_activate_protocol",
       "level": integer ∈ [-2^31-2, 2^31+2],
       "protocol"?: $Protocol_hash,
       "protocol_parameters"?:
         { "proof_of_work_nonce_size"?: integer ∈ [0, 255],
           "nonce_length"?: integer ∈ [0, 255],
           "max_revelations_per_block"?: integer ∈ [0, 255],
           "max_operation_data_length"?: integer ∈ [-2^30-2, 2^30+2],
           "max_proposals_per_delegate"?: integer ∈ [0, 255],
           "preserved_cycles"?: integer ∈ [0, 255],
           "blocks_per_cycle"?: integer ∈ [-2^31-2, 2^31+2],
           "blocks_per_commitment"?: integer ∈ [-2^31-2, 2^31+2],
           "blocks_per_roll_snapshot"?: integer ∈ [-2^31-2, 2^31+2],
           "blocks_per_voting_period"?: integer ∈ [-2^31-2, 2^31+2],
           "time_between_blocks"?: [ $int64 ... ],
           "endorsers_per_block"?: integer ∈ [0, 2^16-1],
           "hard_gas_limit_per_operation"?: $bignum,
           "hard_gas_limit_per_block"?: $bignum,
           "proof_of_work_threshold"?: $int64,
           "tokens_per_roll"?: $mutez,
           "michelson_maximum_type_size"?: integer ∈ [0, 2^16-1],
           "seed_nonce_revelation_tip"?: $mutez,
           "origination_size"?: integer ∈ [-2^30-2, 2^30+2],
           "block_security_deposit"?: $mutez,
           "endorsement_security_deposit"?: $mutez,
           "block_reward"?: $mutez,
           "endorsement_reward"?: $mutez,
           "cost_per_byte"?: $mutez,
           "hard_storage_limit_per_operation"?: $bignum,
           "hard_gas_limit_to_pay_fees"?: $bignum,
           "protocol_revision"?: integer ∈ [-2^30-2, 2^30+2],
           "max_operation_ttl"?: integer ∈ [-2^30-2, 2^30+2],
           "initial_endorsers"?: integer ∈ [-2^30-2, 2^30+2],
           "delay_per_missing_endorsement"?: $int64,
           "protocol_actions"?: [ $unistring ... ],
           "allow_collect_call"?: boolean } }
  || { "kind": "permanent",
       "id": "proto.005-PsBabyM1.internal_operation_replay",
       "source": $contract_id,
       "nonce": integer ∈ [0, 2^16-1],
       "kind": "dune_manager_operation",
       "dune_kind": "dune_manage_accounts",
       "bytes": /^[a-zA-Z0-9]+$/ }
  || { "kind": "permanent",
       "id": "proto.005-PsBabyM1.internal_operation_replay",
       "source": $contract_id,
       "nonce": integer ∈ [0, 2^16-1],
       "kind": "dune_manager_operation",
       "dune_kind": "dune_manage_account",
       "target"?:
         { "target": $Signature.Public_key_hash,
           "signature"?: $Signature },
       "options": /^[a-zA-Z0-9]+$/ }
  || { "kind": "permanent",
       "id": "proto.005-PsBabyM1.internal_operation_replay",
       "source": $contract_id,
       "nonce": integer ∈ [0, 2^16-1],
       "kind": "dune_manager_operation",
       "dune_kind": "dune_clear_delegations" }
  || { "kind": "permanent",
       "id": "proto.005-PsBabyM1.internal_operation_replay",
       "source": $contract_id,
       "nonce": integer ∈ [0, 2^16-1],
       "kind": "transaction",
       "amount": $mutez,
       "destination": $contract_id,
       "parameters"?:
         { "entrypoint"?: $entrypoint,
           "value"?:
             $micheline.michelson_v1.expression
             || { "dune_expr": "VOID" || any || any }
             || { "dune_code": "NOOP" || any || any || any }
             || { "michelson": $unistring } },
       "collect_call"?:
         { "fee_gas": $positive_bignum,
           "reveal_public_key"?: $Signature.Public_key } }
  $Protocol_hash:
    /* A Dune protocol ID (Base58Check-encoded) */
    $unistring
  $Signature:
    /* A Ed25519, Secp256k1 or P256 signature (Base58Check-encoded) */
    $unistring
  $Signature.Public_key:
    /* A Ed25519, Secp256k1, or P256 public key (Base58Check-encoded) */
    $unistring
  $Signature.Public_key_hash:
    /* A Ed25519, Secp256k1, or P256 public key hash (Base58Check-encoded) */
    $unistring
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $contract_id:
    /* A contract handle
       A contract notation as given to an RPC or inside scripts. Can be a
       base58 implicit contract hash or a base58 originated contract hash. */
    $unistring
  $entrypoint:
    /* entrypoint
       Named entrypoint to a Michelson smart contract */
    "default"
    || "root"
    || "do"
    || "set_delegate"
    || "remove_delegate"
    || string
  $int64:
    /* 64 bit integers
       Decimal representation of 64 bit integers */
    string
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $mutez: $positive_bignum
  $positive_bignum:
    /* Positive big number
       Decimal representation of a positive big number */
    string
  $script_expr:
    /* A script expression ID (Base58Check-encoded) */
    $unistring
  $scripted.contracts:
    { "code":
        $micheline.michelson_v1.expression
        || { "dune_expr": "VOID" || any || any }
        || { "dune_code": "NOOP" || any || any || any }
        || { "michelson": $unistring },
      "storage":
        $micheline.michelson_v1.expression
        || { "dune_expr": "VOID" || any || any }
        || { "dune_code": "NOOP" || any || any || any }
        || { "michelson": $unistring } }
  $scripted.opt_or_hash:
    null
    || $scripted.contracts
    || { "code_hash": $script_expr,
         "storage":
           $micheline.michelson_v1.expression
           || { "dune_expr": "VOID" || any || any }
           || { "dune_code": "NOOP" || any || any || any }
           || { "michelson": $unistring } }
    || { "code":
           $micheline.michelson_v1.expression
           || { "dune_expr": "VOID" || any || any }
           || { "dune_code": "NOOP" || any || any || any }
           || { "michelson": $unistring },
         "code_hash": $script_expr,
         "storage":
           $micheline.michelson_v1.expression
           || { "dune_expr": "VOID" || any || any }
           || { "dune_code": "NOOP" || any || any || any }
           || { "michelson": $unistring } }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Invalid constant (parse error)

A compile-time constant was invalid for its expected form.

Id : proto.005-PsBabyM1.invalidSyntacticConstantError
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.invalidSyntacticConstantError",
    "location": $micheline.location,
    "expectedForm": $micheline.michelson_v1.expression,
    "wrongExpression": $micheline.michelson_v1.expression }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Invalid arg

Negative multiple of periods are not allowed.

Id : proto.005-PsBabyM1.invalid_arg
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.invalid_arg" }

Invalid binary format

Could not deserialize some piece of data from its binary representation

Id : proto.005-PsBabyM1.invalid_binary_format
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.invalid_binary_format" }

Invalid fitness

Fitness representation should be exactly 8 bytes long.

Id : proto.005-PsBabyM1.invalid_fitness
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.invalid_fitness" }

Invalid proposal

Ballot provided for a proposal that is not the current one.

Id : proto.005-PsBabyM1.invalid_proposal
Category : branch

  { "kind": "branch",
    "id": "proto.005-PsBabyM1.invalid_proposal" }

Bad argument error

A bad argument has been given to a function

Id : proto.005-PsBabyM1.love.bad_argument
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.love.bad_argument",
    "description": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

The contract was called on an invalid entry point

The contract was called on an invalid entry point

Id : proto.005-PsBabyM1.love.badentrypoint
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.love.badentrypoint",
    ... }

The contract was called with the wrong kind of argument

The contract was called with the wrong kind of argument

Id : proto.005-PsBabyM1.love.badparameter
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.love.badparameter",
    ... }

The contract return an invalid value

The contract returned an invalid value

Id : proto.005-PsBabyM1.love.badreturntype
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.love.badreturntype",
    ... }

An invalid storage was provided

The contract was deployed with a storage that doesnot match the type it expects

Id : proto.005-PsBabyM1.love.badstorage
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.love.badstorage",
    ... }

An invalid view was requested

An invalid view was requested

Id : proto.005-PsBabyM1.love.badview
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.love.badview",
    ... }

A decoding error occured

The decoder failed to recognize the input data

Id : proto.005-PsBabyM1.love.decoding_error
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.love.decoding_error",
    "description": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

A deserialization error occured

The deserializer failed to recognize the input data

Id : proto.005-PsBabyM1.love.deserialization_error
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.love.deserialization_error",
    "code": integer ∈ [-2^30-2, 2^30+2],
    "description": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

An environment error occurred

Something that should be in the environment is not

Id : proto.005-PsBabyM1.love.environment_error
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.love.environment_error",
    "description": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

A generic error occured

An unspecific error occured

Id : proto.005-PsBabyM1.love.generic_error
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.love.generic_error",
    "description": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

A broken invariant was detected

Something that should not occur have occured ;this is likely a bug in the interpreter

Id : proto.005-PsBabyM1.love.invariant_broken
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.love.invariant_broken",
    "description": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

An overflow occured

A computation generated an out-of-bound value

Id : proto.005-PsBabyM1.love.overflow
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.love.overflow",
    ... }

A parse error occured

The parser failed to recognize the input data

Id : proto.005-PsBabyM1.love.parse_error
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.love.parse_error",
    "description": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

A stack overflow occured

The maximum stack length has been reached

Id : proto.005-PsBabyM1.love.stack_overflow
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.love.stack_overflow",
    ... }

A typing error occurred

An ill-typed contract or value was detected

Id : proto.005-PsBabyM1.love.typing_error
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.love.typing_error",
    "description": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

An invalid comparison was attempted

Tried to compare uncomparable values

Id : proto.005-PsBabyM1.love.uncomparable
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.love.uncomparable",
    ... }

An unhandled exception occured

An exception was raised by the interpreter orone of its components and reached the top level

Id : proto.005-PsBabyM1.love.unhandled_exception
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.love.unhandled_exception",
    "description": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

An unhandled user exception occured

An exception was raised by the interpretedcontract and reached the top level

Id : proto.005-PsBabyM1.love.unhandled_user_exception
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.love.unhandled_user_exception",
    "description": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

A typing error occurred

An unknown constructor was encountered

Id : proto.005-PsBabyM1.love.unknown_constr
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.love.unknown_constr",
    "description": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

A typing error occurred

An unknown field was encountered

Id : proto.005-PsBabyM1.love.unknown_field
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.love.unknown_field",
    "description": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

A typing error occurred

An unknown type was encountered

Id : proto.005-PsBabyM1.love.unknown_type
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.love.unknown_type",
    "description": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Malformed period

Period is negative.

Id : proto.005-PsBabyM1.malformed_period
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.malformed_period" }

Contract supplied an invalid parameter

Either no parameter was supplied to a contract with a non-unit parameter type, a non-unit parameter was passed to an account, or a parameter was supplied of the wrong type

Id : proto.005-PsBabyM1.michelson_v1.bad_contract_parameter
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.bad_contract_parameter",
    "contract": $contract_id }
  $contract_id:
    /* A contract handle
       A contract notation as given to an RPC or inside scripts. Can be a
       base58 implicit contract hash or a base58 originated contract hash. */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Bad return

Unexpected stack at the end of a lambda or script.

Id : proto.005-PsBabyM1.michelson_v1.bad_return
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.bad_return",
    "location": $micheline.location,
    "expected_return_type": $micheline.michelson_v1.expression,
    "wrong_stack_type":
      [ { "type": $micheline.michelson_v1.expression,
          "annots"?: [ $unistring ... ] } ... ] }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Bad stack

The stack has an unexpected length or contents.

Id : proto.005-PsBabyM1.michelson_v1.bad_stack
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.bad_stack",
    "location": $micheline.location,
    "primitive_name": $michelson.v1.primitives,
    "relevant_stack_portion": integer ∈ [-2^15, 2^15-1],
    "wrong_stack_type":
      [ { "type": $micheline.michelson_v1.expression,
          "annots"?: [ $unistring ... ] } ... ] }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Bad stack item

The type of a stack item is unexpected (this error is always accompanied by a more precise one).

Id : proto.005-PsBabyM1.michelson_v1.bad_stack_item
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.bad_stack_item",
    "item_level": integer ∈ [-2^15, 2^15-1] }

Not enough gas to serialize error

The error was too big to be serialized with the provided gas

Id : proto.005-PsBabyM1.michelson_v1.cannot_serialize_error
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.michelson_v1.cannot_serialize_error" }

Not enough gas to serialize argument of FAILWITH

Argument of FAILWITH was too big to be serialized with the provided gas

Id : proto.005-PsBabyM1.michelson_v1.cannot_serialize_failure
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.michelson_v1.cannot_serialize_failure" }

Not enough gas to serialize execution trace

Execution trace with stacks was to big to be serialized with the provided gas

Id : proto.005-PsBabyM1.michelson_v1.cannot_serialize_log
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.michelson_v1.cannot_serialize_log" }

Not enough gas to serialize execution storage

The returned storage was too big to be serialized with the provided gas

Id : proto.005-PsBabyM1.michelson_v1.cannot_serialize_storage
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.michelson_v1.cannot_serialize_storage" }

Comparable type expected

A non comparable type was used in a place where only comparable types are accepted.

Id : proto.005-PsBabyM1.michelson_v1.comparable_type_expected
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.comparable_type_expected",
    "location": $micheline.location,
    "wrong_type": $micheline.michelson_v1.expression }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Script is using a deprecated instruction

A deprecated instruction usage is disallowed in newly created contracts

Id : proto.005-PsBabyM1.michelson_v1.deprecated_instruction
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.deprecated_instruction",
    "prim": $michelson.v1.primitives }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"

Duplicate entrypoint (type error)

Two entrypoints have the same name.

Id : proto.005-PsBabyM1.michelson_v1.duplicate_entrypoint
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.duplicate_entrypoint",
    "path": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Duplicate map keys

Map literals cannot contain duplicated keys

Id : proto.005-PsBabyM1.michelson_v1.duplicate_map_keys
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.duplicate_map_keys",
    "location": $micheline.location,
    "item": $micheline.michelson_v1.expression }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Script has a duplicated field (parse error)

When parsing script, a field was found more than once

Id : proto.005-PsBabyM1.michelson_v1.duplicate_script_field
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.duplicate_script_field",
    "loc": $micheline.location,
    "prim": $michelson.v1.primitives }
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"

Sets literals cannot contain duplicate elements

Set literals cannot contain duplicate elements, but a duplicae was found while parsing.

Id : proto.005-PsBabyM1.michelson_v1.duplicate_set_values_in_literal
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.duplicate_set_values_in_literal",
    "location": $micheline.location,
    "value": $micheline.michelson_v1.expression }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Entrypoint name too long (type error)

An entrypoint name exceeds the maximum length of 31 characters.

Id : proto.005-PsBabyM1.michelson_v1.entrypoint_name_too_long
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.entrypoint_name_too_long",
    "name": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

FAIL not in tail position

There is non trivial garbage code after a FAIL instruction.

Id : proto.005-PsBabyM1.michelson_v1.fail_not_in_tail_position
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.fail_not_in_tail_position",
    "location": $micheline.location }
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]

Ill formed type

The toplevel error thrown when trying to parse a type expression (always followed by more precise errors).

Id : proto.005-PsBabyM1.michelson_v1.ill_formed_type
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.ill_formed_type",
    "identifier"?: $unistring,
    "ill_formed_expression": $micheline.michelson_v1.expression,
    "location": $micheline.location }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Ill typed contract

The toplevel error thrown when trying to typecheck a contract code against given input, output and storage types (always followed by more precise errors).

Id : proto.005-PsBabyM1.michelson_v1.ill_typed_contract
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.ill_typed_contract",
    "ill_typed_code": $micheline.michelson_v1.expression,
    "type_map":
      [ { "location": $micheline.location,
          "stack_before":
            [ [ $micheline.michelson_v1.expression, [ $unistring ... ] ] ... ],
          "stack_after":
            [ [ $micheline.michelson_v1.expression, [ $unistring ... ] ] ... ] } ... ] }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Ill typed data

The toplevel error thrown when trying to typecheck a data expression against a given type (always followed by more precise errors).

Id : proto.005-PsBabyM1.michelson_v1.ill_typed_data
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.ill_typed_data",
    "identifier"?: $unistring,
    "expected_type": $micheline.michelson_v1.expression,
    "ill_typed_expression": $micheline.michelson_v1.expression }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Annotations inconsistent between branches

The annotations on two types could not be merged

Id : proto.005-PsBabyM1.michelson_v1.inconsistent_annotations
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.inconsistent_annotations",
    "annot1": $unistring,
    "annot2": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Annotations for field accesses is inconsistent

The specified field does not match the field annotation in the type

Id : proto.005-PsBabyM1.michelson_v1.inconsistent_field_annotations
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.inconsistent_field_annotations",
    "annot1": $unistring,
    "annot2": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Inconsistent stack lengths

A stack was of an unexpected length (this error is always in the context of a located error).

Id : proto.005-PsBabyM1.michelson_v1.inconsistent_stack_lengths
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.inconsistent_stack_lengths" }

Types contain inconsistent annotations

The two types contain annotations that do not match

Id : proto.005-PsBabyM1.michelson_v1.inconsistent_type_annotations
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.inconsistent_type_annotations",
    "location": $micheline.location,
    "type1": $micheline.michelson_v1.expression,
    "type2": $micheline.michelson_v1.expression }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Inconsistent types

This is the basic type clash error, that appears in several places where the equality of two types have to be proven, it is always accompanied with another error that provides more context.

Id : proto.005-PsBabyM1.michelson_v1.inconsistent_types
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.inconsistent_types",
    "first_type": $micheline.michelson_v1.expression,
    "other_type": $micheline.michelson_v1.expression }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Invalid arity

In a script or data expression, a primitive was applied to an unsupported number of arguments.

Id : proto.005-PsBabyM1.michelson_v1.invalid_arity
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.invalid_arity",
    "location": $micheline.location,
    "primitive_name": $michelson.v1.primitives,
    "expected_arity": integer ∈ [-128, 127],
    "wrong_arity": integer ∈ [-128, 127] }
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"

Invalid big_map

A script or data expression references a big_map that does not exist or assumes a wrong type for an existing big_map.

Id : proto.005-PsBabyM1.michelson_v1.invalid_big_map
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.invalid_big_map",
    "location": $micheline.location,
    "big_map": $bignum }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]

Invalid constant

A data expression was invalid for its expected type.

Id : proto.005-PsBabyM1.michelson_v1.invalid_constant
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.invalid_constant",
    "location": $micheline.location,
    "expected_type": $micheline.michelson_v1.expression,
    "wrong_expression": $micheline.michelson_v1.expression }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Invalid contract

A script or data expression references a contract that does not exist or assumes a wrong type for an existing contract.

Id : proto.005-PsBabyM1.michelson_v1.invalid_contract
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.invalid_contract",
    "location": $micheline.location,
    "contract": $contract_id }
  $contract_id:
    /* A contract handle
       A contract notation as given to an RPC or inside scripts. Can be a
       base58 implicit contract hash or a base58 originated contract hash. */
    $unistring
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Invalid expression kind

In a script or data expression, an expression was of the wrong kind (for instance a string where only a primitive applications can appear).

Id : proto.005-PsBabyM1.michelson_v1.invalid_expression_kind
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.invalid_expression_kind",
    "location": $micheline.location,
    "expected_kinds": [ $expressionKind ... ],
    "wrong_kind": $expressionKind }
  $expressionKind:
    /* Expression kind
       One of the four possible kinds of expression (integer, string,
       primitive application or sequence). */
    "string" | "integer" | "sequence" | "primitiveApplication" | "bytes"
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]

ITER body returned wrong stack type

The body of an ITER instruction must result in the same stack type as before the ITER.

Id : proto.005-PsBabyM1.michelson_v1.invalid_iter_body
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.invalid_iter_body",
    "loc": $micheline.location,
    "bef_stack":
      [ { "type": $micheline.michelson_v1.expression,
          "annots"?: [ $unistring ... ] } ... ],
    "aft_stack":
      [ { "type": $micheline.michelson_v1.expression,
          "annots"?: [ $unistring ... ] } ... ] }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

FAIL instruction occurred as body of map block

FAIL cannot be the only instruction in the body. The propper type of the return list cannot be inferred.

Id : proto.005-PsBabyM1.michelson_v1.invalid_map_block_fail
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.invalid_map_block_fail",
    "loc": $micheline.location }
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]

Invalid map body

The body of a map block did not match the expected type

Id : proto.005-PsBabyM1.michelson_v1.invalid_map_body
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.invalid_map_body",
    "loc": $micheline.location,
    "body_type":
      [ { "type": $micheline.michelson_v1.expression,
          "annots"?: [ $unistring ... ] } ... ] }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Invalid primitive

In a script or data expression, a primitive was unknown.

Id : proto.005-PsBabyM1.michelson_v1.invalid_primitive
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.invalid_primitive",
    "location": $micheline.location,
    "expected_primitive_names"?: [ $michelson.v1.primitives ... ],
    "wrong_primitive_name": $michelson.v1.primitives }
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"

Invalid primitive name

In a script or data expression, a primitive name is unknown or has a wrong case.

Id : proto.005-PsBabyM1.michelson_v1.invalid_primitive_name
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.invalid_primitive_name",
    "expression": $micheline.generic.expression,
    "location": $micheline.location }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.generic.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.generic.expression ... ]
    || { "prim": $unistring,
         "args"?: [ $micheline.generic.expression ... ],
         "annots"?: [ string ... ] }
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Invalid primitive name case

In a script or data expression, a primitive name is neither uppercase, lowercase or capitalized.

Id : proto.005-PsBabyM1.michelson_v1.invalid_primitive_name_case
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.invalid_primitive_name_case",
    "wrong_primitive_name": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Invalid primitive namespace

In a script or data expression, a primitive was of the wrong namespace.

Id : proto.005-PsBabyM1.michelson_v1.invalid_primitive_namespace
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.invalid_primitive_namespace",
    "location": $micheline.location,
    "primitive_name": $michelson.v1.primitives,
    "expected_namespace": $primitiveNamespace,
    "wrong_namespace": $primitiveNamespace }
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $primitiveNamespace:
    /* Primitive namespace
       One of the three possible namespaces of primitive (data constructor,
       type name or instruction). */
    "constant" | "type" | "instruction"

Script is missing a field (parse error)

When parsing script, a field was expected, but not provided

Id : proto.005-PsBabyM1.michelson_v1.missing_script_field
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.missing_script_field",
    "prim": $michelson.v1.primitives }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"

No such entrypoint (type error)

An entrypoint was not found when calling a contract.

Id : proto.005-PsBabyM1.michelson_v1.no_such_entrypoint
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.no_such_entrypoint",
    "entrypoint": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Script runtime error

Toplevel error for all runtime script errors

Id : proto.005-PsBabyM1.michelson_v1.runtime_error
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.michelson_v1.runtime_error",
    "contract_handle": $contract_id,
    "contract_code": $micheline.michelson_v1.expression }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $contract_id:
    /* A contract handle
       A contract notation as given to an RPC or inside scripts. Can be a
       base58 implicit contract hash or a base58 originated contract hash. */
    $unistring
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Script failed (overflow error)

A FAIL instruction was reached due to the detection of an overflow

Id : proto.005-PsBabyM1.michelson_v1.script_overflow
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.michelson_v1.script_overflow",
    "location": $micheline.location,
    "trace"?:
      [ { "location": $micheline.location,
          "gas": $bignum || "unaccounted",
          "stack":
            [ { "item": $micheline.michelson_v1.expression,
                "annot"?: $unistring } ... ] } ... ] }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Script failed

A FAILWITH instruction was reached

Id : proto.005-PsBabyM1.michelson_v1.script_rejected
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.michelson_v1.script_rejected",
    "location": $micheline.location,
    "with": $micheline.michelson_v1.expression,
    "trace"?:
      [ { "location": $micheline.location,
          "gas": $bignum || "unaccounted",
          "stack":
            [ { "item": $micheline.michelson_v1.expression,
                "annot"?: $unistring } ... ] } ... ] }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

SELF instruction in lambda

A SELF instruction was encountered in a lambda expression.

Id : proto.005-PsBabyM1.michelson_v1.self_in_lambda
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.self_in_lambda",
    "location": $micheline.location }
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]

Stack item type too large

An instruction generated a type larger than the limit.

Id : proto.005-PsBabyM1.michelson_v1.type_too_large
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.type_too_large",
    "loc": $micheline.location,
    "type_size": integer ∈ [0, 2^16-1],
    "maximum_type_size": integer ∈ [0, 2^16-1] }
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]

Undefined binop

A binary operation is called on operands of types over which it is not defined.

Id : proto.005-PsBabyM1.michelson_v1.undefined_binop
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.undefined_binop",
    "location": $micheline.location,
    "operator_name": $michelson.v1.primitives,
    "wrong_left_operand_type": $micheline.michelson_v1.expression,
    "wrong_right_operand_type": $micheline.michelson_v1.expression }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Undefined unop

A unary operation is called on an operand of type over which it is not defined.

Id : proto.005-PsBabyM1.michelson_v1.undefined_unop
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.undefined_unop",
    "location": $micheline.location,
    "operator_name": $michelson.v1.primitives,
    "wrong_operand_type": $micheline.michelson_v1.expression }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

An annotation was encountered where no annotation is expected

A node in the syntax tree was impropperly annotated

Id : proto.005-PsBabyM1.michelson_v1.unexpected_annotation
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.unexpected_annotation",
    "location": $micheline.location }
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]

Big map in unauthorized position (type error)

When parsing script, a big_map type was found in a position where it could end up stored inside a big_map, which is forbidden for now.

Id : proto.005-PsBabyM1.michelson_v1.unexpected_bigmap
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.unexpected_bigmap",
    "loc": $micheline.location }
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]

Contract in unauthorized position (type error)

When parsing script, a contract type was found in the storage or parameter field.

Id : proto.005-PsBabyM1.michelson_v1.unexpected_contract
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.unexpected_contract",
    "loc": $micheline.location }
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]

Operation in unauthorized position (type error)

When parsing script, an operation type was found in the storage or parameter field.

Id : proto.005-PsBabyM1.michelson_v1.unexpected_operation
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.unexpected_operation",
    "loc": $micheline.location }
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]

Annotations of the same kind were found spread apart

Annotations of the same kind must be grouped

Id : proto.005-PsBabyM1.michelson_v1.ungrouped_annotations
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.ungrouped_annotations",
    "location": $micheline.location }
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]

Unknown primitive name

In a script or data expression, a primitive was unknown.

Id : proto.005-PsBabyM1.michelson_v1.unknown_primitive_name
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.unknown_primitive_name",
    "wrong_primitive_name": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Unmatched branches

At the join point at the end of two code branches the stacks have inconsistent lengths or contents.

Id : proto.005-PsBabyM1.michelson_v1.unmatched_branches
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.unmatched_branches",
    "location": $micheline.location,
    "first_stack_type":
      [ { "type": $micheline.michelson_v1.expression,
          "annots"?: [ $unistring ... ] } ... ],
    "other_stack_type":
      [ { "type": $micheline.michelson_v1.expression,
          "annots"?: [ $unistring ... ] } ... ] }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Invalid map key order

Map keys must be in strictly increasing order

Id : proto.005-PsBabyM1.michelson_v1.unordered_map_literal
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.unordered_map_literal",
    "location": $micheline.location,
    "item": $micheline.michelson_v1.expression }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Invalid set value order

Set values must be in strictly increasing order

Id : proto.005-PsBabyM1.michelson_v1.unordered_set_literal
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.unordered_set_literal",
    "location": $micheline.location,
    "value": $micheline.michelson_v1.expression }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.location:
    /* Canonical location in a Micheline expression
       The location of a node in a Micheline expression tree in prefix
       order, with zero being the root and adding one for every basic node,
       sequence and primitive application. */
    integer ∈ [-2^30-2, 2^30+2]
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Unreachable entrypoint (type error)

An entrypoint in the contract is not reachable.

Id : proto.005-PsBabyM1.michelson_v1.unreachable_entrypoint
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.michelson_v1.unreachable_entrypoint",
    "path": [ $michelson.v1.primitives ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"

failure

Unexpected error

Id : proto.005-PsBabyM1.misc.failure
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.misc.failure",
    "message": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Previously revealed nonce

Duplicated revelation for a nonce.

Id : proto.005-PsBabyM1.nonce.previously_revealed
Category : branch

  { "kind": "branch",
    "id": "proto.005-PsBabyM1.nonce.previously_revealed",
    ... }

Too early nonce revelation

Nonce revelation happens before cycle end

Id : proto.005-PsBabyM1.nonce.too_early_revelation
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.nonce.too_early_revelation",
    ... }

Too late nonce revelation

Nonce revelation happens too late

Id : proto.005-PsBabyM1.nonce.too_late_revelation
Category : branch

  { "kind": "branch",
    "id": "proto.005-PsBabyM1.nonce.too_late_revelation",
    ... }

Unexpected nonce

The provided nonce is inconsistent with the committed nonce hash.

Id : proto.005-PsBabyM1.nonce.unexpected
Category : branch

  { "kind": "branch",
    "id": "proto.005-PsBabyM1.nonce.unexpected",
    ... }

Level in Activate Protocol should be the last level of the cycle

Some parameters that can only be changed at cycle end were changed

Id : proto.005-PsBabyM1.operation.activation_level_should_be_last
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.operation.activation_level_should_be_last",
    "level": integer ∈ [-2^31-2, 2^31+2] }

Cannot parse operation

The operation is ill-formed or for another protocol version

Id : proto.005-PsBabyM1.operation.cannot_parse
Category : branch

  { "kind": "branch",
    "id": "proto.005-PsBabyM1.operation.cannot_parse",
    ... }

Duplicate endorsement

Two endorsements received from same delegate

Id : proto.005-PsBabyM1.operation.duplicate_endorsement
Category : branch

  { "kind": "branch",
    "id": "proto.005-PsBabyM1.operation.duplicate_endorsement",
    "delegate": $Signature.Public_key_hash }
  $Signature.Public_key_hash:
    /* A Ed25519, Secp256k1, or P256 public key hash (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Invalid activation

The given key and secret do not correspond to any existing preallocated contract

Id : proto.005-PsBabyM1.operation.invalid_activation
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.operation.invalid_activation",
    "pkh": $Ed25519.Public_key_hash }
  $Ed25519.Public_key_hash:
    /* An Ed25519 public key hash (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Unexpected level in endorsement

The level of an endorsement is inconsistent with the provided block hash.

Id : proto.005-PsBabyM1.operation.invalid_endorsement_level
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.operation.invalid_endorsement_level",
    ... }

Invalid operation signature

The operation signature is ill-formed or has been made with the wrong public key

Id : proto.005-PsBabyM1.operation.invalid_signature
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.operation.invalid_signature",
    ... }

Missing operation signature

The operation is of a kind that must be signed, but the signature is missing

Id : proto.005-PsBabyM1.operation.missing_signature
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.operation.missing_signature",
    ... }

Not enough endorsements for priority

The block being validated does not include the required minimum number of endorsements for this priority.

Id : proto.005-PsBabyM1.operation.not_enought_endorsements_for_priority
Category : permanent

  { "kind": "permanent",
    "id":
      "proto.005-PsBabyM1.operation.not_enought_endorsements_for_priority",
    "required": integer ∈ [-2^30-2, 2^30+2],
    "endorsements": integer ∈ [-2^30-2, 2^30+2],
    "priority": integer ∈ [-2^30-2, 2^30+2],
    "timestamp": $timestamp.protocol }
  $int64:
    /* 64 bit integers
       Decimal representation of 64 bit integers */
    string
  $timestamp.protocol:
    /* A timestamp as seen by the protocol: second-level precision, epoch
       based. */
    $timestamp.rfc || $int64
  $timestamp.rfc:
    /* RFC 3339 formatted timestamp
       A date in RFC 3339 notation. */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Wrong level in Activate Protocol

The Activate Protocol operation comes too late.

Id : proto.005-PsBabyM1.operation.wrong_activation_level
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.operation.wrong_activation_level",
    "level": integer ∈ [-2^31-2, 2^31+2] }

Wrong code hash in origination

The code hash supplied does not match the code

Id : proto.005-PsBabyM1.operation.wrong_code_hash
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.operation.wrong_code_hash",
    "expected": $script_expr,
    "provided": $script_expr }
  $script_expr:
    /* A script expression ID (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Wrong endorsement predecessor

Trying to include an endorsement in a block that is not the successor of the endorsed one

Id : proto.005-PsBabyM1.operation.wrong_endorsement_predecessor
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.operation.wrong_endorsement_predecessor",
    "expected": $block_hash,
    "provided": $block_hash }
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Wrong voting period

Trying to onclude a proposal or ballot meant for another voting period

Id : proto.005-PsBabyM1.operation.wrong_voting_period
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.operation.wrong_voting_period",
    "current": integer ∈ [-2^31-2, 2^31+2],
    "provided": integer ∈ [-2^31-2, 2^31+2] }

Bad protocol revision change

The protocol revision cannot be changed to a lower value.

Id : proto.005-PsBabyM1.protocol_revision.illegal_change
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.protocol_revision.illegal_change",
    "new_revision": integer ∈ [-2^30-2, 2^30+2],
    "current_revision": integer ∈ [-2^30-2, 2^30+2] }

Unsupported protocol revision

The protocol revision is not supported by this node.

Id : proto.005-PsBabyM1.protocol_revision.unsupported
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.protocol_revision.unsupported",
    "revision": integer ∈ [-2^30-2, 2^30+2],
    "max_revision": integer ∈ [-2^30-2, 2^30+2] }

Unknown code hash

The supplied hash does not match any know code in the storage

Id : proto.005-PsBabyM1.scripts.unknown_hash
Category : branch

  { "kind": "branch",
    "id": "proto.005-PsBabyM1.scripts.unknown_hash",
    "code_hash": $script_expr }
  $script_expr:
    /* A script expression ID (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Unknown seed

The requested seed is not available

Id : proto.005-PsBabyM1.seed.unknown_seed
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.seed.unknown_seed",
    "oldest": integer ∈ [-2^31-2, 2^31+2],
    "requested": integer ∈ [-2^31-2, 2^31+2],
    "latest": integer ∈ [-2^31-2, 2^31+2] }

Storage quota exceeded for the operation

A script or one of its callee wrote more bytes than the operation said it would

Id : proto.005-PsBabyM1.storage_exhausted.operation
Category : temporary

  { "kind": "temporary",
    "id": "proto.005-PsBabyM1.storage_exhausted.operation" }

Storage limit out of protocol hard bounds

A transaction tried to exceed the hard limit on storage

Id : proto.005-PsBabyM1.storage_limit_too_high
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.storage_limit_too_high" }

Timestamp add

Overflow when adding timestamps.

Id : proto.005-PsBabyM1.timestamp_add
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.timestamp_add" }

Timestamp sub

Substracting timestamps resulted in negative period.

Id : proto.005-PsBabyM1.timestamp_sub
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.timestamp_sub" }

Too many internal operations

A transaction exceeded the hard limit of internal operations it can emit

Id : proto.005-PsBabyM1.too_many_internal_operations
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.too_many_internal_operations" }

Too many proposals

The delegate reached the maximum number of allowed proposals.

Id : proto.005-PsBabyM1.too_many_proposals
Category : branch

  { "kind": "branch",
    "id": "proto.005-PsBabyM1.too_many_proposals" }

Unauthorized ballot

The delegate provided for the ballot is not in the voting listings.

Id : proto.005-PsBabyM1.unauthorized_ballot
Category : branch

  { "kind": "branch",
    "id": "proto.005-PsBabyM1.unauthorized_ballot" }

Unauthorized proposal

The delegate provided for the proposal is not in the voting listings.

Id : proto.005-PsBabyM1.unauthorized_proposal
Category : branch

  { "kind": "branch",
    "id": "proto.005-PsBabyM1.unauthorized_proposal" }

Ill timed access to the origination nonce

An origination was attemped out of the scope of a manager operation

Id : proto.005-PsBabyM1.undefined_operation_nonce
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.undefined_operation_nonce" }

Unexpected ballot

Ballot recorded outside of a voting period.

Id : proto.005-PsBabyM1.unexpected_ballot
Category : branch

  { "kind": "branch",
    "id": "proto.005-PsBabyM1.unexpected_ballot" }

Unexpected level

Level must be non-negative.

Id : proto.005-PsBabyM1.unexpected_level
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.unexpected_level",
    "level": integer ∈ [-2^31-2, 2^31+2] }

Unexpected nonce length

Nonce length is incorrect.

Id : proto.005-PsBabyM1.unexpected_nonce_length
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.unexpected_nonce_length" }

Unexpected proposal

Proposal recorded outside of a proposal period.

Id : proto.005-PsBabyM1.unexpected_proposal
Category : branch

  { "kind": "branch",
    "id": "proto.005-PsBabyM1.unexpected_proposal" }

On-chain governance operations are forbidden

This on-chain governance operation is forbidden in the Dune Network.

Id : proto.005-PsBabyM1.voting_disabled
Category : permanent

  { "kind": "permanent",
    "id": "proto.005-PsBabyM1.voting_disabled" }

Shell

Canceled fetch of a Operation_hash

The fetch of a Operation_hash has been canceled

Id : distributed_db.Operation_hash.fetch_canceled
Category : permanent

  { "kind": "permanent",
    "id": "distributed_db.Operation_hash.fetch_canceled",
    "key": $Operation_hash }
  $Operation_hash:
    /* A Dune operation ID (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Timed out fetch of a Operation_hash

The fetch of a Operation_hash has timed out

Id : distributed_db.Operation_hash.fetch_timeout
Category : permanent

  { "kind": "permanent",
    "id": "distributed_db.Operation_hash.fetch_timeout",
    "key": $Operation_hash }
  $Operation_hash:
    /* A Dune operation ID (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Missing Operation_hash

Some Operation_hash is missing from the distributed db

Id : distributed_db.Operation_hash.missing
Category : permanent

  { "kind": "permanent",
    "id": "distributed_db.Operation_hash.missing",
    "key": $Operation_hash }
  $Operation_hash:
    /* A Dune operation ID (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Canceled fetch of a Protocol_hash

The fetch of a Protocol_hash has been canceled

Id : distributed_db.Protocol_hash.fetch_canceled
Category : permanent

  { "kind": "permanent",
    "id": "distributed_db.Protocol_hash.fetch_canceled",
    "key": $Protocol_hash }
  $Protocol_hash:
    /* A Dune protocol ID (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Timed out fetch of a Protocol_hash

The fetch of a Protocol_hash has timed out

Id : distributed_db.Protocol_hash.fetch_timeout
Category : permanent

  { "kind": "permanent",
    "id": "distributed_db.Protocol_hash.fetch_timeout",
    "key": $Protocol_hash }
  $Protocol_hash:
    /* A Dune protocol ID (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Missing Protocol_hash

Some Protocol_hash is missing from the distributed db

Id : distributed_db.Protocol_hash.missing
Category : permanent

  { "kind": "permanent",
    "id": "distributed_db.Protocol_hash.missing",
    "key": $Protocol_hash }
  $Protocol_hash:
    /* A Dune protocol ID (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Canceled fetch of a block_hash

The fetch of a block_hash has been canceled

Id : distributed_db.block_hash.fetch_canceled
Category : permanent

  { "kind": "permanent",
    "id": "distributed_db.block_hash.fetch_canceled",
    "key": $block_hash }
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Timed out fetch of a block_hash

The fetch of a block_hash has timed out

Id : distributed_db.block_hash.fetch_timeout
Category : permanent

  { "kind": "permanent",
    "id": "distributed_db.block_hash.fetch_timeout",
    "key": $block_hash }
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Missing block_hash

Some block_hash is missing from the distributed db

Id : distributed_db.block_hash.missing
Category : permanent

  { "kind": "permanent",
    "id": "distributed_db.block_hash.missing",
    "key": $block_hash }
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Canceled fetch of a operation_hashes

The fetch of a operation_hashes has been canceled

Id : distributed_db.operation_hashes.fetch_canceled
Category : permanent

  { "kind": "permanent",
    "id": "distributed_db.operation_hashes.fetch_canceled",
    "key": { "block": $block_hash,
             "index": integer ∈ [0, 2^16-1] } }
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Timed out fetch of a operation_hashes

The fetch of a operation_hashes has timed out

Id : distributed_db.operation_hashes.fetch_timeout
Category : permanent

  { "kind": "permanent",
    "id": "distributed_db.operation_hashes.fetch_timeout",
    "key": { "block": $block_hash,
             "index": integer ∈ [0, 2^16-1] } }
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Missing operation_hashes

Some operation_hashes is missing from the distributed db

Id : distributed_db.operation_hashes.missing
Category : permanent

  { "kind": "permanent",
    "id": "distributed_db.operation_hashes.missing",
    "key": { "block": $block_hash,
             "index": integer ∈ [0, 2^16-1] } }
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Canceled fetch of a operations

The fetch of a operations has been canceled

Id : distributed_db.operations.fetch_canceled
Category : permanent

  { "kind": "permanent",
    "id": "distributed_db.operations.fetch_canceled",
    "key": { "block": $block_hash,
             "index": integer ∈ [0, 2^16-1] } }
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Timed out fetch of a operations

The fetch of a operations has timed out

Id : distributed_db.operations.fetch_timeout
Category : permanent

  { "kind": "permanent",
    "id": "distributed_db.operations.fetch_timeout",
    "key": { "block": $block_hash,
             "index": integer ∈ [0, 2^16-1] } }
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Missing operations

Some operations is missing from the distributed db

Id : distributed_db.operations.missing
Category : permanent

  { "kind": "permanent",
    "id": "distributed_db.operations.missing",
    "key": { "block": $block_hash,
             "index": integer ∈ [0, 2^16-1] } }
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Invalid block locator

Block locator is invalid.

Id : node.bootstrap_pipeline.invalid_locator
Category : permanent

  { "kind": "permanent",
    "id": "node.bootstrap_pipeline.invalid_locator",
    "id": $Crypto_box.Public_key_hash,
    "locator": $block_locator }
  $Context_hash:
    /* A hash of context (Base58Check-encoded) */
    $unistring
  $Crypto_box.Public_key_hash:
    /* A Cryptobox public key ID (Base58Check-encoded) */
    $unistring
  $Operation_list_list_hash:
    /* A list of list of operations (Base58Check-encoded) */
    $unistring
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $block_header:
    /* Block header
       Block header. It contains both shell and protocol specific data. */
    { "level": integer ∈ [-2^31-2, 2^31+2],
      "proto": integer ∈ [0, 255],
      "predecessor": $block_hash,
      "timestamp": $timestamp.protocol,
      "validation_pass": integer ∈ [0, 255],
      "operations_hash": $Operation_list_list_hash,
      "fitness": $fitness,
      "context": $Context_hash,
      "protocol_data": /^[a-zA-Z0-9]+$/ }
  $block_locator:
    /* A sparse block locator à la Bitcoin */
    { "current_head": $block_header,
      "history": [ $block_hash ... ] }
  $fitness:
    /* Block fitness
       The fitness, or score, of a block, that allow the Dune to decide
       which chain is the best. A fitness value is a list of byte
       sequences. They are compared as follows: shortest lists are smaller;
       lists of the same length are compared according to the
       lexicographical order. */
    [ /^[a-zA-Z0-9]+$/ ... ]
  $int64:
    /* 64 bit integers
       Decimal representation of 64 bit integers */
    string
  $timestamp.protocol:
    /* A timestamp as seen by the protocol: second-level precision, epoch
       based. */
    $timestamp.rfc || $int64
  $timestamp.rfc:
    /* RFC 3339 formatted timestamp
       A date in RFC 3339 notation. */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Too short locator

Block locator is too short.

Id : node.bootstrap_pipeline.too_short_locator
Category : permanent

  { "kind": "permanent",
    "id": "node.bootstrap_pipeline.too_short_locator",
    "id": $Crypto_box.Public_key_hash,
    "locator": $block_locator }
  $Context_hash:
    /* A hash of context (Base58Check-encoded) */
    $unistring
  $Crypto_box.Public_key_hash:
    /* A Cryptobox public key ID (Base58Check-encoded) */
    $unistring
  $Operation_list_list_hash:
    /* A list of list of operations (Base58Check-encoded) */
    $unistring
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $block_header:
    /* Block header
       Block header. It contains both shell and protocol specific data. */
    { "level": integer ∈ [-2^31-2, 2^31+2],
      "proto": integer ∈ [0, 255],
      "predecessor": $block_hash,
      "timestamp": $timestamp.protocol,
      "validation_pass": integer ∈ [0, 255],
      "operations_hash": $Operation_list_list_hash,
      "fitness": $fitness,
      "context": $Context_hash,
      "protocol_data": /^[a-zA-Z0-9]+$/ }
  $block_locator:
    /* A sparse block locator à la Bitcoin */
    { "current_head": $block_header,
      "history": [ $block_hash ... ] }
  $fitness:
    /* Block fitness
       The fitness, or score, of a block, that allow the Dune to decide
       which chain is the best. A fitness value is a list of byte
       sequences. They are compared as follows: shortest lists are smaller;
       lists of the same length are compared according to the
       lexicographical order. */
    [ /^[a-zA-Z0-9]+$/ ... ]
  $int64:
    /* 64 bit integers
       Decimal representation of 64 bit integers */
    string
  $timestamp.protocol:
    /* A timestamp as seen by the protocol: second-level precision, epoch
       based. */
    $timestamp.rfc || $int64
  $timestamp.rfc:
    /* RFC 3339 formatted timestamp
       A date in RFC 3339 notation. */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Connection closed

IO error: connection with a peer is closed.

Id : node.p2p_io_scheduler.connection_closed
Category : permanent

  { "kind": "permanent",
    "id": "node.p2p_io_scheduler.connection_closed" }

Connected

Fail to connect with a peer: a connection is already established.

Id : node.p2p_pool.connected
Category : permanent

  { "kind": "permanent",
    "id": "node.p2p_pool.connected" }

Connection refused

Connection was refused.

Id : node.p2p_pool.connection_refused
Category : permanent

  { "kind": "permanent",
    "id": "node.p2p_pool.connection_refused" }

Peer Banned

The peer identity you tried to connect is banned.

Id : node.p2p_pool.peer_banned
Category : permanent

  { "kind": "permanent",
    "id": "node.p2p_pool.peer_banned",
    "peer": $Crypto_box.Public_key_hash }
  $Crypto_box.Public_key_hash:
    /* A Cryptobox public key ID (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Pending connection

Fail to connect with a peer: a connection is already pending.

Id : node.p2p_pool.pending_connection
Category : permanent

  { "kind": "permanent",
    "id": "node.p2p_pool.pending_connection" }

Point Banned

The address you tried to connect is banned.

Id : node.p2p_pool.point_banned
Category : permanent

  { "kind": "permanent",
    "id": "node.p2p_pool.point_banned",
    "point": $p2p_point.id }
  $p2p_point.id:
    /* Identifier for a peer point */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Private mode

Node is in private mode.

Id : node.p2p_pool.private_mode
Category : permanent

  { "kind": "permanent",
    "id": "node.p2p_pool.private_mode" }

Rejected peer

Connection to peer was rejected.

Id : node.p2p_pool.rejected
Category : permanent

  { "kind": "permanent",
    "id": "node.p2p_pool.rejected",
    "peer id": $Crypto_box.Public_key_hash }
  $Crypto_box.Public_key_hash:
    /* A Cryptobox public key ID (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Too many connections

Too many connections.

Id : node.p2p_pool.too_many_connections
Category : permanent

  { "kind": "permanent",
    "id": "node.p2p_pool.too_many_connections" }

Decipher error

An error occurred while deciphering.

Id : node.p2p_socket.decipher_error
Category : permanent

  { "kind": "permanent",
    "id": "node.p2p_socket.decipher_error" }

Decoding error

An error occurred while decoding.

Id : node.p2p_socket.decoding_error
Category : permanent

  { "kind": "permanent",
    "id": "node.p2p_socket.decoding_error" }

Encoding error

An error occurred while encoding.

Id : node.p2p_socket.encoding_error
Category : permanent

  { "kind": "permanent",
    "id": "node.p2p_socket.encoding_error" }

Invalid authentication

Rejected peer connection: invalid authentication.

Id : node.p2p_socket.invalid_auth
Category : permanent

  { "kind": "permanent",
    "id": "node.p2p_socket.invalid_auth" }

Invalid chunks size

Size of chunks is not valid.

Id : node.p2p_socket.invalid_chunks_size
Category : permanent

  { "kind": "permanent",
    "id": "node.p2p_socket.invalid_chunks_size",
    "value": integer ∈ [-2^30-2, 2^30+2],
    "min": integer ∈ [-2^30-2, 2^30+2],
    "max": integer ∈ [-2^30-2, 2^30+2] }

Invalid incoming ciphertext size

The announced size for the incoming ciphertext is invalid.

Id : node.p2p_socket.invalid_incoming_ciphertext_size
Category : permanent

  { "kind": "permanent",
    "id": "node.p2p_socket.invalid_incoming_ciphertext_size" }

Invalid message size

The size of the message to be written is invalid.

Id : node.p2p_socket.invalid_message_size
Category : permanent

  { "kind": "permanent",
    "id": "node.p2p_socket.invalid_message_size" }

Myself

Remote peer is actually yourself.

Id : node.p2p_socket.myself
Category : permanent

  { "kind": "permanent",
    "id": "node.p2p_socket.myself",
    "connection id": $p2p_connection.id }
  $p2p_address:
    /* An address for locating peers. */
    $unistring
  $p2p_connection.id:
    /* The identifier for a p2p connection. It includes an address and a
       port number. */
    { "addr": $p2p_address,
      "port"?: integer ∈ [0, 2^16-1] }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Not enough proof of work

Remote peer cannot be authenticated: not enough proof of work.

Id : node.p2p_socket.not_enough_proof_of_work
Category : permanent

  { "kind": "permanent",
    "id": "node.p2p_socket.not_enough_proof_of_work",
    "peer id": $Crypto_box.Public_key_hash }
  $Crypto_box.Public_key_hash:
    /* A Cryptobox public key ID (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Rejected socket connection - no common network protocol

Rejected peer connection: rejected socket connection as we have no common network protocol with the peer.

Id : node.p2p_socket.rejected_no_common_protocol
Category : permanent

  { "kind": "permanent",
    "id": "node.p2p_socket.rejected_no_common_protocol",
    "announced_version": $network_version }
  $distributed_db_version:
    /* A version number for the distributed DB protocol */
    integer ∈ [0, 2^16-1]
  $distributed_db_version.name:
    /* A name for the distributed DB protocol */
    $unistring
  $network_version:
    /* A version number for the network protocol (includes distributed DB
       version and p2p version) */
    { "chain_name": $distributed_db_version.name,
      "distributed_db_version": $distributed_db_version,
      "p2p_version": $p2p_version }
  $p2p_version:
    /* A version number for the p2p layer. */
    integer ∈ [0, 2^16-1]
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Rejected socket connection

Rejected peer connection: rejected socket connection.

Id : node.p2p_socket.rejected_socket_connection
Category : permanent

  { "kind": "permanent",
    "id": "node.p2p_socket.rejected_socket_connection" }

Known invalid

Known invalid block found in the peer's chain

Id : node.peer_validator.known_invalid
Category : permanent

  { "kind": "permanent",
    "id": "node.peer_validator.known_invalid" }

Unknown ancestor

Unknown ancestor block found in the peer's chain

Id : node.peer_validator.unknown_ancestor
Category : permanent

  { "kind": "permanent",
    "id": "node.peer_validator.unknown_ancestor" }

Future block header

The block was annotated with a time too far in the future.

Id : node.prevalidation.future_block_header
Category : temporary

  { "kind": "temporary",
    "id": "node.prevalidation.future_block_header",
    "block": $block_hash,
    "block_time": $timestamp.protocol,
    "time": $timestamp.system }
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $int64:
    /* 64 bit integers
       Decimal representation of 64 bit integers */
    string
  $timestamp.protocol:
    /* A timestamp as seen by the protocol: second-level precision, epoch
       based. */
    $timestamp.rfc || $int64
  $timestamp.rfc:
    /* RFC 3339 formatted timestamp
       A date in RFC 3339 notation. */
    $unistring
  $timestamp.system:
    /* A timestamp as seen by the underlying, local computer:
       subsecond-level precision, epoch or rfc3339 based. */
    $timestamp.rfc || $int64
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Oversized operation

The operation size is bigger than allowed.

Id : node.prevalidation.oversized_operation
Category : permanent

  { "kind": "permanent",
    "id": "node.prevalidation.oversized_operation",
    "size": integer ∈ [-2^30-2, 2^30+2],
    "max_size": integer ∈ [-2^30-2, 2^30+2] }

Parsing error in prevalidation

Raised when an operation has not been parsed correctly during prevalidation.

Id : node.prevalidation.parse_error
Category : permanent

  { "kind": "permanent",
    "id": "node.prevalidation.parse_error" }

Too many pending operations in prevalidation

The prevalidation context is full.

Id : node.prevalidation.too_many_operations
Category : temporary

  { "kind": "temporary",
    "id": "node.prevalidation.too_many_operations" }

Invalid protocol

Invalid protocol.

Id : node.protocol_validator.invalid_protocol
Category : permanent

  { "kind": "permanent",
    "id": "node.protocol_validator.invalid_protocol",
    "invalid_protocol": $Protocol_hash,
    "error": "compilation_failed" }
  || { "kind": "permanent",
       "id": "node.protocol_validator.invalid_protocol",
       "invalid_protocol": $Protocol_hash,
       "error": "dynlinking_failed" }
  $Protocol_hash:
    /* A Dune protocol ID (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Bad data directory

The data directory could not be read. This could be because it was generated with an old version of the dune-node program. Deleting and regenerating this directory may fix the problem.

Id : node.state.bad_data_dir
Category : permanent

  { "kind": "permanent",
    "id": "node.state.bad_data_dir" }

Inconsistent commit hash

When commiting the context of a block, the announced context hash was not the one computed at commit time.

Id : node.state.block.inconsistent_context_hash
Category : permanent

  { "kind": "permanent",
    "id": "node.state.block.inconsistent_context_hash",
    "local_context_hash": $Context_hash,
    "block_header_context_hash": $Context_hash }
  $Context_hash:
    /* A hash of context (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Block not invalid

The invalid block to be unmarked was not actually invalid.

Id : node.state.block_not_invalid
Category : permanent

  { "kind": "permanent",
    "id": "node.state.block_not_invalid",
    "block": $block_hash }
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Unknown chain

The chain identifier could not be found in the chain identifiers table.

Id : node.state.unknown_chain
Category : permanent

  { "kind": "permanent",
    "id": "node.state.unknown_chain",
    "chain": $Chain_id }
  $Chain_id:
    /* Network identifier (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Block incompatible with the current checkpoint.

The block belongs to a branch that is not compatible with the current checkpoint.

Id : node.validator.checkpoint_error
Category : branch

  { "kind": "branch",
    "id": "node.validator.checkpoint_error",
    "block": $block_hash,
    "peer"?: $Crypto_box.Public_key_hash }
  $Crypto_box.Public_key_hash:
    /* A Cryptobox public key ID (Base58Check-encoded) */
    $unistring
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Inactive chain

Attempted validation of a block from an inactive chain.

Id : node.validator.inactive_chain
Category : branch

  { "kind": "branch",
    "id": "node.validator.inactive_chain",
    "inactive_chain": $Chain_id }
  $Chain_id:
    /* Network identifier (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Incorrect history mode switch

Incorrect history mode switch.

Id : node_config_file.incorrect_history_mode_switch
Category : permanent

  { "kind": "permanent",
    "id": "node_config_file.incorrect_history_mode_switch",
    "previous_mode": "full" | "archive" | "rolling",
    "next_mode": "full" | "archive" | "rolling" }

Missing key in store

Missing key in store

Id : raw_store.unknown
Category : permanent

  { "kind": "permanent",
    "id": "raw_store.unknown",
    "key": [ $unistring ... ] }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Invalid merkle tree

The provided list of operations is inconsistent with the block header.

Id : validator.inconsistent_operations_hash
Category : temporary

  { "kind": "temporary",
    "id": "validator.inconsistent_operations_hash",
    "block": $block_hash,
    "expected": $Operation_list_list_hash,
    "found": $Operation_list_list_hash }
  $Operation_list_list_hash:
    /* A list of list of operations (Base58Check-encoded) */
    $unistring
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Invalid block

Invalid block.

Id : validator.invalid_block
Category : permanent

  { "kind": "permanent",
    "id": "validator.invalid_block",
    "invalid_block": $block_hash,
    "error": "cannot_parse_operation",
    "operation": $Operation_hash }
  || { "kind": "permanent",
       "id": "validator.invalid_block",
       "invalid_block": $block_hash,
       "error": "invalid_fitness",
       "expected": $fitness,
       "found": $fitness }
  || { "kind": "permanent",
       "id": "validator.invalid_block",
       "invalid_block": $block_hash,
       "error": "non_increasing_timestamp" }
  || { "kind": "permanent",
       "id": "validator.invalid_block",
       "invalid_block": $block_hash,
       "error": "non_increasing_fitness" }
  || { "kind": "permanent",
       "id": "validator.invalid_block",
       "invalid_block": $block_hash,
       "error": "invalid_level",
       "expected": integer ∈ [-2^31-2, 2^31+2],
       "found": integer ∈ [-2^31-2, 2^31+2] }
  || { "kind": "permanent",
       "id": "validator.invalid_block",
       "invalid_block": $block_hash,
       "error": "invalid_proto_level",
       "expected": integer ∈ [0, 255],
       "found": integer ∈ [0, 255] }
  || { "kind": "permanent",
       "id": "validator.invalid_block",
       "invalid_block": $block_hash,
       "error": "replayed_operation",
       "operation": $Operation_hash }
  || { "kind": "permanent",
       "id": "validator.invalid_block",
       "invalid_block": $block_hash,
       "error": "outdated_operation",
       "operation": $Operation_hash,
       "originating_block": $block_hash }
  || { "kind": "permanent",
       "id": "validator.invalid_block",
       "invalid_block": $block_hash,
       "error": "expired_chain",
       "chain_id": $Chain_id,
       "expiration": $timestamp.protocol,
       "timestamp": $timestamp.protocol }
  || { "kind": "permanent",
       "id": "validator.invalid_block",
       "invalid_block": $block_hash,
       "error": "unexpected_number_of_passes",
       "found": integer ∈ [0, 255] }
  || { "kind": "permanent",
       "id": "validator.invalid_block",
       "invalid_block": $block_hash,
       "error": "too_many_operations",
       "validation_pass": integer ∈ [0, 255],
       "found": integer ∈ [0, 2^16-1],
       "max": integer ∈ [0, 2^16-1] }
  || { "kind": "permanent",
       "id": "validator.invalid_block",
       "invalid_block": $block_hash,
       "error": "oversized_operation",
       "operation": $Operation_hash,
       "found": integer ∈ [-2^30-2, 2^30+2],
       "max": integer ∈ [-2^30-2, 2^30+2] }
  || { "kind": "permanent",
       "id": "validator.invalid_block",
       "invalid_block": $block_hash,
       "error": "invalid_pass",
       "operation": $Operation_hash,
       "pass": integer ∈ [0, 255],
       "allowed_pass": [ integer ∈ [0, 255] ... ] }
  || { "kind": "permanent",
       "id": "validator.invalid_block",
       "invalid_block": $block_hash,
       "error": "cannot_parse_bock_header" }
  || { "kind": "permanent",
       "id": "validator.invalid_block",
       "invalid_block": $block_hash,
       "error": "economic_protocol_error",
       "errors": [ any ... ] }
  $Chain_id:
    /* Network identifier (Base58Check-encoded) */
    $unistring
  $Operation_hash:
    /* A Dune operation ID (Base58Check-encoded) */
    $unistring
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $fitness:
    /* Block fitness
       The fitness, or score, of a block, that allow the Dune to decide
       which chain is the best. A fitness value is a list of byte
       sequences. They are compared as follows: shortest lists are smaller;
       lists of the same length are compared according to the
       lexicographical order. */
    [ /^[a-zA-Z0-9]+$/ ... ]
  $int64:
    /* 64 bit integers
       Decimal representation of 64 bit integers */
    string
  $timestamp.protocol:
    /* A timestamp as seen by the protocol: second-level precision, epoch
       based. */
    $timestamp.rfc || $int64
  $timestamp.rfc:
    /* RFC 3339 formatted timestamp
       A date in RFC 3339 notation. */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Missing test protocol

Missing test protocol when forking the test chain

Id : validator.missing_test_protocol
Category : temporary

  { "kind": "temporary",
    "id": "validator.missing_test_protocol",
    "test_protocol": $Protocol_hash }
  $Protocol_hash:
    /* A Dune protocol ID (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Missing protocol

The protocol required for validating a block is missing.

Id : validator.unavailable_protocol
Category : temporary

  { "kind": "temporary",
    "id": "validator.unavailable_protocol",
    "block": $block_hash,
    "missing_protocol": $Protocol_hash }
  $Protocol_hash:
    /* A Dune protocol ID (Base58Check-encoded) */
    $unistring
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Validation process failed

Failed to validate block using exteranl validation process.

Id : validator.validation_process_failed
Category : temporary

  { "kind": "temporary",
    "id": "validator.validation_process_failed",
    "error":
      { "constant": "missing_handshake" }
      || { "inconsistent_handshake": $unistring }
      || { "pretocol_dynlink_failure": $unistring } }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Worker closed

An operation on a worker could not complete before it was shut down.

Id : worker.closed
Category : permanent

  { "kind": "permanent",
    "id": "worker.closed",
    "worker": [ $unistring, $unistring ] }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Michelson parsing/macros

Micheline parser error: annotation exceeds max length

While parsing a piece of Micheline source, an annotation exceeded the maximum length (255).

Id : micheline.parse_error.annotation_exceeds_max_length
Category : permanent

  { "kind": "permanent",
    "id": "micheline.parse_error.annotation_exceeds_max_length",
    "location":
      { "start":
          { "line": integer ∈ [0, 2^16-1],
            "column": integer ∈ [0, 2^16-1],
            "point": integer ∈ [0, 2^16-1],
            "byte": integer ∈ [0, 2^16-1] },
        "stop":
          { "line": integer ∈ [0, 2^16-1],
            "column": integer ∈ [0, 2^16-1],
            "point": integer ∈ [0, 2^16-1],
            "byte": integer ∈ [0, 2^16-1] } } }

Micheline parser error: empty_expression

Tried to interpret an empty piece or Micheline source as a single expression.

Id : micheline.parse_error.empty_expression
Category : permanent

  { "kind": "permanent",
    "id": "micheline.parse_error.empty_expression" }

Micheline parser error: extra token

While parsing a piece of Micheline source, an extra semi colon or parenthesis was encountered.

Id : micheline.parse_error.extra_token
Category : permanent

  { "kind": "permanent",
    "id": "micheline.parse_error.extra_token",
    "location":
      { "start":
          { "line": integer ∈ [0, 2^16-1],
            "column": integer ∈ [0, 2^16-1],
            "point": integer ∈ [0, 2^16-1],
            "byte": integer ∈ [0, 2^16-1] },
        "stop":
          { "line": integer ∈ [0, 2^16-1],
            "column": integer ∈ [0, 2^16-1],
            "point": integer ∈ [0, 2^16-1],
            "byte": integer ∈ [0, 2^16-1] } },
    "token":
      { "string": $unistring }
      || { "int": $unistring }
      || { "annot": $unistring }
      || { "comment": $unistring,
           "end_of_line"?: boolean }
      || { "punctuation": "(" | ";" | "}" | "{" | ")" }
      || { "bytes": $unistring } }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Micheline parser error: invalid UTF-8 sequence

While parsing a piece of Micheline source, a sequence of bytes that is not valid UTF-8 was encountered.

Id : micheline.parse_error.invalid_utf8_sequence
Category : permanent

  { "kind": "permanent",
    "id": "micheline.parse_error.invalid_utf8_sequence",
    "point":
      { "line": integer ∈ [0, 2^16-1],
        "column": integer ∈ [0, 2^16-1],
        "point": integer ∈ [0, 2^16-1],
        "byte": integer ∈ [0, 2^16-1] },
    "sequence": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Micheline parser error: misaligned node

While parsing a piece of Micheline source, an expression was not aligned with its siblings of the same mother application or sequence.

Id : micheline.parse_error.misaligned_node
Category : permanent

  { "kind": "permanent",
    "id": "micheline.parse_error.misaligned_node",
    "expression":
      { "expression": $micheline.generic.expression,
        "locations":
          [ { "start":
                { "line": integer ∈ [0, 2^16-1],
                  "column": integer ∈ [0, 2^16-1],
                  "point": integer ∈ [0, 2^16-1],
                  "byte": integer ∈ [0, 2^16-1] },
              "stop":
                { "line": integer ∈ [0, 2^16-1],
                  "column": integer ∈ [0, 2^16-1],
                  "point": integer ∈ [0, 2^16-1],
                  "byte": integer ∈ [0, 2^16-1] } } ... ] } }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.generic.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.generic.expression ... ]
    || { "prim": $unistring,
         "args"?: [ $micheline.generic.expression ... ],
         "annots"?: [ string ... ] }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Micheline parser error: missing break after number

While parsing a piece of Micheline source, a number was not visually separated from its follower token, leading to misreadability.

Id : micheline.parse_error.missing_break_after_number
Category : permanent

  { "kind": "permanent",
    "id": "micheline.parse_error.missing_break_after_number",
    "point":
      { "line": integer ∈ [0, 2^16-1],
        "column": integer ∈ [0, 2^16-1],
        "point": integer ∈ [0, 2^16-1],
        "byte": integer ∈ [0, 2^16-1] } }

Micheline parser error: odd lengthed bytes

While parsing a piece of Micheline source, the length of a byte sequence (0x...) was not a multiple of two, leaving a trailing half byte.

Id : micheline.parse_error.odd_lengthed_bytes
Category : permanent

  { "kind": "permanent",
    "id": "micheline.parse_error.odd_lengthed_bytes",
    "location":
      { "start":
          { "line": integer ∈ [0, 2^16-1],
            "column": integer ∈ [0, 2^16-1],
            "point": integer ∈ [0, 2^16-1],
            "byte": integer ∈ [0, 2^16-1] },
        "stop":
          { "line": integer ∈ [0, 2^16-1],
            "column": integer ∈ [0, 2^16-1],
            "point": integer ∈ [0, 2^16-1],
            "byte": integer ∈ [0, 2^16-1] } } }

Micheline parser error: unclosed token

While parsing a piece of Micheline source, a parenthesis or a brace was unclosed.

Id : micheline.parse_error.unclosed_token
Category : permanent

  { "kind": "permanent",
    "id": "micheline.parse_error.unclosed_token",
    "location":
      { "start":
          { "line": integer ∈ [0, 2^16-1],
            "column": integer ∈ [0, 2^16-1],
            "point": integer ∈ [0, 2^16-1],
            "byte": integer ∈ [0, 2^16-1] },
        "stop":
          { "line": integer ∈ [0, 2^16-1],
            "column": integer ∈ [0, 2^16-1],
            "point": integer ∈ [0, 2^16-1],
            "byte": integer ∈ [0, 2^16-1] } },
    "token":
      { "string": $unistring }
      || { "int": $unistring }
      || { "annot": $unistring }
      || { "comment": $unistring,
           "end_of_line"?: boolean }
      || { "punctuation": "(" | ";" | "}" | "{" | ")" }
      || { "bytes": $unistring } }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Micheline parser error: undefined escape sequence

While parsing a piece of Micheline source, an unexpected escape sequence was encountered in a string.

Id : micheline.parse_error.undefined_escape_sequence
Category : permanent

  { "kind": "permanent",
    "id": "micheline.parse_error.undefined_escape_sequence",
    "point":
      { "line": integer ∈ [0, 2^16-1],
        "column": integer ∈ [0, 2^16-1],
        "point": integer ∈ [0, 2^16-1],
        "byte": integer ∈ [0, 2^16-1] },
    "sequence": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Micheline parser error: unexpected character

While parsing a piece of Micheline source, an unexpected character was encountered.

Id : micheline.parse_error.unexpected_character
Category : permanent

  { "kind": "permanent",
    "id": "micheline.parse_error.unexpected_character",
    "point":
      { "line": integer ∈ [0, 2^16-1],
        "column": integer ∈ [0, 2^16-1],
        "point": integer ∈ [0, 2^16-1],
        "byte": integer ∈ [0, 2^16-1] },
    "character": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Micheline parser error: unexpected token

While parsing a piece of Micheline source, an unexpected token was encountered.

Id : micheline.parse_error.unexpected_token
Category : permanent

  { "kind": "permanent",
    "id": "micheline.parse_error.unexpected_token",
    "location":
      { "start":
          { "line": integer ∈ [0, 2^16-1],
            "column": integer ∈ [0, 2^16-1],
            "point": integer ∈ [0, 2^16-1],
            "byte": integer ∈ [0, 2^16-1] },
        "stop":
          { "line": integer ∈ [0, 2^16-1],
            "column": integer ∈ [0, 2^16-1],
            "point": integer ∈ [0, 2^16-1],
            "byte": integer ∈ [0, 2^16-1] } },
    "token":
      { "string": $unistring }
      || { "int": $unistring }
      || { "annot": $unistring }
      || { "comment": $unistring,
           "end_of_line"?: boolean }
      || { "punctuation": "(" | ";" | "}" | "{" | ")" }
      || { "bytes": $unistring } }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Micheline parser error: unterminated comment

While parsing a piece of Micheline source, a commentX was not terminated.

Id : micheline.parse_error.unterminated_comment
Category : permanent

  { "kind": "permanent",
    "id": "micheline.parse_error.unterminated_comment",
    "location":
      { "start":
          { "line": integer ∈ [0, 2^16-1],
            "column": integer ∈ [0, 2^16-1],
            "point": integer ∈ [0, 2^16-1],
            "byte": integer ∈ [0, 2^16-1] },
        "stop":
          { "line": integer ∈ [0, 2^16-1],
            "column": integer ∈ [0, 2^16-1],
            "point": integer ∈ [0, 2^16-1],
            "byte": integer ∈ [0, 2^16-1] } } }

Micheline parser error: unterminated integer

While parsing a piece of Micheline source, an integer was not terminated.

Id : micheline.parse_error.unterminated_integer
Category : permanent

  { "kind": "permanent",
    "id": "micheline.parse_error.unterminated_integer",
    "location":
      { "start":
          { "line": integer ∈ [0, 2^16-1],
            "column": integer ∈ [0, 2^16-1],
            "point": integer ∈ [0, 2^16-1],
            "byte": integer ∈ [0, 2^16-1] },
        "stop":
          { "line": integer ∈ [0, 2^16-1],
            "column": integer ∈ [0, 2^16-1],
            "point": integer ∈ [0, 2^16-1],
            "byte": integer ∈ [0, 2^16-1] } } }

Micheline parser error: unterminated string

While parsing a piece of Micheline source, a string was not terminated.

Id : micheline.parse_error.unterminated_string
Category : permanent

  { "kind": "permanent",
    "id": "micheline.parse_error.unterminated_string",
    "location":
      { "start":
          { "line": integer ∈ [0, 2^16-1],
            "column": integer ∈ [0, 2^16-1],
            "point": integer ∈ [0, 2^16-1],
            "byte": integer ∈ [0, 2^16-1] },
        "stop":
          { "line": integer ∈ [0, 2^16-1],
            "column": integer ∈ [0, 2^16-1],
            "point": integer ∈ [0, 2^16-1],
            "byte": integer ∈ [0, 2^16-1] } } }

Client

<Untitled>

Id : rpc_client.request_failed
Category : permanent

  { "kind": "permanent",
    "id": "rpc_client.request_failed",
    "meth": $unistring,
    "uri": $unistring,
    "error":
      { "kind": "empty_answer" }
      || { "kind": "connection_failed",
           "message": $unistring }
      || { "kind": "bad_request",
           "message": $unistring }
      || { "kind": "method_not_allowed",
           "allowed": [ $unistring ... ] }
      || { "kind": "unsupported_media_type",
           "content_type"?: $unistring }
      || { "kind": "not_acceptable",
           "proposed": $unistring,
           "acceptable": $unistring }
      || { "kind": "unexpected_status_code",
           "code": integer ∈ [0, 2^16-1],
           "content": $unistring,
           "media_type"?: $unistring }
      || { "kind": "unexpected_content_type",
           "received": $unistring,
           "acceptable": [ $unistring ... ],
           "body": $unistring }
      || { "kind": "unexpected_content",
           "content": $unistring,
           "media_type": $unistring,
           "error": $unistring }
      || { "kind": "ocaml_exception",
           "content": $unistring } }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Miscellaneous

Bad hash

Wrong hash given

Id : Bad_hash
Category : permanent

  { "kind": "permanent",
    "id": "Bad_hash",
    "hash_ty": $unistring,
    "hash_is": /^[a-zA-Z0-9]+$/,
    "hash_should": /^[a-zA-Z0-9]+$/ }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Fail during checkout context

The context checkout failed using a given hash

Id : Block_validator_process.failed_to_checkout_context
Category : permanent

  { "kind": "permanent",
    "id": "Block_validator_process.failed_to_checkout_context",
    "hash": $Context_hash }
  $Context_hash:
    /* A hash of context (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Context not found

Cannot find context corresponding to hash

Id : Context_not_found
Category : permanent

  { "kind": "permanent",
    "id": "Context_not_found",
    "context_not_found": /^[a-zA-Z0-9]+$/ }

Inconsistent imported block

The imported block is not the expected one.

Id : InconsistentImportedBlock
Category : permanent

  { "kind": "permanent",
    "id": "InconsistentImportedBlock",
    "block_hash": $block_hash,
    "block_hash_expected": $block_hash }
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Inconsistent operation hashes

The operations given do not match their hashes.

Id : InconsistentOperationHashes
Category : permanent

  { "kind": "permanent",
    "id": "InconsistentOperationHashes",
    "expected_operation_hashes": $Operation_list_list_hash,
    "received_operation_hashes": $Operation_list_list_hash }
  $Operation_list_list_hash:
    /* A list of list of operations (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Inconsistent snapshot data

The data provided by the snapshot is inconsistent

Id : Inconsistent_snapshot_data
Category : permanent

  { "kind": "permanent",
    "id": "Inconsistent_snapshot_data" }

Inconsistent snapshot file

Error while reading snapshot file

Id : Inconsistent_snapshot_file
Category : permanent

  { "kind": "permanent",
    "id": "Inconsistent_snapshot_file" }

Invalid snapshot version

The version of the snapshot to import is not valid

Id : Invalid_snapshot_version
Category : permanent

  { "kind": "permanent",
    "id": "Invalid_snapshot_version",
    "found": $unistring,
    "expected": [ $unistring ... ] }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Missing data in imported snapshot

Mandatory data missing while reaching end of snapshot file.

Id : Missing_snapshot_data
Category : permanent

  { "kind": "permanent",
    "id": "Missing_snapshot_data" }

RPC lookup failed

RPC lookup failed. No RPC exists at the URL or the RPC tried to access non-existent data.

Id : RPC_context.Not_found
Category : branch

  { "kind": "branch",
    "id": "RPC_context.Not_found",
    "method": $unistring,
    "uri": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Failed to restore context

Internal error while restoring the context

Id : Restore_context_failure
Category : permanent

  { "kind": "permanent",
    "id": "Restore_context_failure" }

Snapshot import failure

The imported snapshot is malformed.

Id : SnapshotImportFailure
Category : permanent

  { "kind": "permanent",
    "id": "SnapshotImportFailure",
    "message": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

System read error

Failed to read file

Id : System_read_error
Category : permanent

  { "kind": "permanent",
    "id": "System_read_error",
    "system_read_error": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Failed to validate block because of a system error

The validator failed because of a system error

Id : Validator_process.system_error_while_validating
Category : temporary

  { "kind": "temporary",
    "id": "Validator_process.system_error_while_validating",
    "errno":
      integer ∈ [-128, 127]
      || "nfile"
         | "addrinuse"
         | "busy"
         | "mfile"
         | "exist"
         | "netreset"
         | "acces"
         | "badf"
         | "mlink"
         | "noexec"
         | "xdev"
         | "notdir"
         | "connrefused"
         | "nodev"
         | "range"
         | "nametoolong"
         | "shutdown"
         | "notempty"
         | "spipe"
         | "nolck"
         | "notty"
         | "hostunreach"
         | "noprotoopt"
         | "child"
         | "rofs"
         | "hostdown"
         | "fbig"
         | "2big"
         | "already"
         | "dom"
         | "noent"
         | "nosys"
         | "afnosupport"
         | "netdown"
         | "perm"
         | "timedout"
         | "isdir"
         | "connreset"
         | "pipe"
         | "inval"
         | "protonosupport"
         | "nomem"
         | "nospc"
         | "nobufs"
         | "intr"
         | "fault"
         | "io"
         | "addrnotavail"
         | "notsock"
         | "overflow"
         | "connaborted"
         | "notconn"
         | "deadlk"
         | "inprogress"
         | "toomanyrefs"
         | "isconn"
         | "pfnosupport"
         | "netunreach"
         | "opnotsupp"
         | "wouldblock"
         | "destaddrreq"
         | "msgsize"
         | "socktnosupport"
         | "loop"
         | "srch"
         | "nxio"
         | "prototype"
         | "again",
    "function": $unistring,
    "msg": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Writing error

Cannot write in file for context dump

Id : Writing_error
Category : permanent

  { "kind": "permanent",
    "id": "Writing_error",
    "context_dump_no_space": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Wrong block export

The block to export in the snapshot is not valid.

Id : WrongBlockExport
Category : permanent

  { "kind": "permanent",
    "id": "WrongBlockExport",
    "block_hash": $block_hash,
    "kind": "cannot_be_found" | "too_few_predecessors" | "pruned" }
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Wrong protocol hash

Wrong protocol hash

Id : WrongProtocolHash
Category : permanent

  { "kind": "permanent",
    "id": "WrongProtocolHash",
    "protocol_hash": $Protocol_hash }
  $Protocol_hash:
    /* A Dune protocol ID (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Wrong snapshot export

Snapshot exports is not compatible with the current configuration.

Id : WrongSnapshotExport
Category : permanent

  { "kind": "permanent",
    "id": "WrongSnapshotExport",
    "src": "full" | "archive" | "rolling",
    "dst": "full" | "archive" | "rolling" }

Cannot serialize metadata

Unable to serialize metadata

Id : block_validation.cannot_serialize_metadata
Category : permanent

  { "kind": "permanent",
    "id": "block_validation.cannot_serialize_metadata" }

Canceled

A promise was unexpectedly canceled

Id : canceled
Category : temporary

  { "kind": "temporary",
    "id": "canceled",
    ... }

Invalid key uri

A key has been provided with an invalid uri.

Id : cli.key.invalid_uri
Category : permanent

  { "kind": "permanent",
    "id": "cli.key.invalid_uri",
    "value": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Signature mismatch

The signer produced an invalid signature

Id : cli.signature_mismatch
Category : permanent

  { "kind": "permanent",
    "id": "cli.signature_mismatch",
    "locator": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Unregistered key scheme

A key has been provided with an unregistered scheme (no corresponding plugin)

Id : cli.unregistered_key_scheme
Category : permanent

  { "kind": "permanent",
    "id": "cli.unregistered_key_scheme",
    "value": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Deserialized counter does not match the stored one

The byte sequence references a multisig counter that does not match the one currently stored in the given multisig contract

Id : client.005-PsBabyM1.Bad deserialized counter
Category : permanent

  { "kind": "permanent",
    "id": "client.005-PsBabyM1.Bad deserialized counter",
    "recieved_expected":
      [ integer ∈ [-2^30-2, 2^30+2], integer ∈ [-2^30-2, 2^30+2] ] }

The expression is not a valid multisig action

When trying to deserialise an action from a sequence of bytes, we got an expression that does not correspond to a known multisig action

Id : client.005-PsBabyM1.actionDeserialisation
Category : permanent

  { "kind": "permanent",
    "id": "client.005-PsBabyM1.actionDeserialisation",
    "expr":
      $micheline.michelson_v1.expression
      || { "dune_expr": "VOID" || any || any }
      || { "dune_code": "NOOP" || any || any || any }
      || { "michelson": $unistring } }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

The byte sequence is not for the given multisig contract

When trying to deserialise an action from a sequence of bytes, we got an action for another multisig contract

Id : client.005-PsBabyM1.badDeserializedContract
Category : permanent

  { "kind": "permanent",
    "id": "client.005-PsBabyM1.badDeserializedContract",
    "recieved_expected": [ $contract_id, $contract_id ] }
  $contract_id:
    /* A contract handle
       A contract notation as given to an RPC or inside scripts. Can be a
       base58 implicit contract hash or a base58 originated contract hash. */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Bad -endorsement-delay arg

invalid duration in -endorsement-delay

Id : client.005-PsBabyM1.badEndorsementDelayArg
Category : permanent

  { "kind": "permanent",
    "id": "client.005-PsBabyM1.badEndorsementDelayArg",
    "parameter": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Bad -max-priority arg

invalid priority in -max-priority

Id : client.005-PsBabyM1.badMaxPriorityArg
Category : permanent

  { "kind": "permanent",
    "id": "client.005-PsBabyM1.badMaxPriorityArg",
    "parameter": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Bad -max-waiting-time arg

invalid duration in -max-waiting-time

Id : client.005-PsBabyM1.badMaxWaitingTimeArg
Category : permanent

  { "kind": "permanent",
    "id": "client.005-PsBabyM1.badMaxWaitingTimeArg",
    "parameter": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Bad -minimal-fees arg

invalid fee threshold in -fee-threshold

Id : client.005-PsBabyM1.badMinimalFeesArg
Category : permanent

  { "kind": "permanent",
    "id": "client.005-PsBabyM1.badMinimalFeesArg",
    "parameter": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Bad -preserved-levels arg

invalid number of levels in -preserved-levels

Id : client.005-PsBabyM1.badPreservedLevelsArg
Category : permanent

  { "kind": "permanent",
    "id": "client.005-PsBabyM1.badPreservedLevelsArg",
    "parameter": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Bad Tez Arg

Invalid đ notation in parameter.

Id : client.005-PsBabyM1.badTezArg
Category : permanent

  { "kind": "permanent",
    "id": "client.005-PsBabyM1.badTezArg",
    "parameter": $unistring,
    "literal": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

The byte sequence is not a valid multisig action

When trying to deserialise an action from a sequence of bytes, we got an error

Id : client.005-PsBabyM1.bytesDeserialisation
Category : permanent

  { "kind": "permanent",
    "id": "client.005-PsBabyM1.bytesDeserialisation",
    "expr": /^[a-zA-Z0-9]+$/ }

The given contract is not a multisig contract because it has no script

A multisig command has referenced a scriptless smart contract instead of a multisig smart contract.

Id : client.005-PsBabyM1.contractHasNoScript
Category : permanent

  { "kind": "permanent",
    "id": "client.005-PsBabyM1.contractHasNoScript",
    "contract": $contract_id }
  $contract_id:
    /* A contract handle
       A contract notation as given to an RPC or inside scripts. Can be a
       base58 implicit contract hash or a base58 originated contract hash. */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

The given contract is not a multisig contract because it has no storage

A multisig command has referenced a smart contract without storage instead of a multisig smart contract.

Id : client.005-PsBabyM1.contractHasNoStorage
Category : permanent

  { "kind": "permanent",
    "id": "client.005-PsBabyM1.contractHasNoStorage",
    "contract": $contract_id }
  $contract_id:
    /* A contract handle
       A contract notation as given to an RPC or inside scripts. Can be a
       base58 implicit contract hash or a base58 originated contract hash. */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

The storage of the given contract is not of the shape expected for a multisig contract

A multisig command has referenced a smart contract whose storage is of a different shape than the expected one.

Id : client.005-PsBabyM1.contractHasUnexpectedStorage
Category : permanent

  { "kind": "permanent",
    "id": "client.005-PsBabyM1.contractHasUnexpectedStorage",
    "contract": $contract_id }
  $contract_id:
    /* A contract handle
       A contract notation as given to an RPC or inside scripts. Can be a
       base58 implicit contract hash or a base58 originated contract hash. */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

The given contract has no code

Attempt to get the code of a contract failed because it has nocode. No scriptless contract should remain.

Id : client.005-PsBabyM1.contractWithoutCode
Category : permanent

  { "kind": "permanent",
    "id": "client.005-PsBabyM1.contractWithoutCode",
    "contract": $contract_id }
  $contract_id:
    /* A contract handle
       A contract notation as given to an RPC or inside scripts. Can be a
       base58 implicit contract hash or a base58 originated contract hash. */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

The following signature did not match a public key in the given multisig contract

A signature was given for a multisig contract that matched none of the public keys of the contract signers

Id : client.005-PsBabyM1.invalidSignature
Category : permanent

  { "kind": "permanent",
    "id": "client.005-PsBabyM1.invalidSignature",
    "invalid_signature": $Signature }
  $Signature:
    /* A Ed25519, Secp256k1 or P256 signature (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Wrong number of arguments to macro

A wrong number of arguments was provided to a macro

Id : client.005-PsBabyM1.michelson.macros.bas_arity
Category : permanent

  { "kind": "permanent",
    "id": "client.005-PsBabyM1.michelson.macros.bas_arity",
    "macro_name": $unistring,
    "given_number_of_arguments": integer ∈ [0, 2^16-1],
    "expected_number_of_arguments": integer ∈ [0, 2^16-1] }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Macro expects a sequence

An macro expects a sequence, but a sequence was not provided

Id : client.005-PsBabyM1.michelson.macros.sequence_expected
Category : permanent

  { "kind": "permanent",
    "id": "client.005-PsBabyM1.michelson.macros.sequence_expected",
    "macro_name": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Unexpected annotation

A macro had an annotation, but no annotation was permitted on this macro.

Id : client.005-PsBabyM1.michelson.macros.unexpected_annotation
Category : permanent

  { "kind": "permanent",
    "id": "client.005-PsBabyM1.michelson.macros.unexpected_annotation",
    "macro_name": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Given threshold is not positive

A multisig threshold should be a positive number

Id : client.005-PsBabyM1.nonPositiveThreshold
Category : permanent

  { "kind": "permanent",
    "id": "client.005-PsBabyM1.nonPositiveThreshold",
    "threshold": integer ∈ [-2^30-2, 2^30+2] }

The given contract is not one of the supported contracts

A multisig command has referenced a smart contract whose script is not one of the known multisig contract scripts.

Id : client.005-PsBabyM1.notASupportedMultisigContract
Category : permanent

  { "kind": "permanent",
    "id": "client.005-PsBabyM1.notASupportedMultisigContract",
    "hash": $script_expr,
    "script":
      $micheline.michelson_v1.expression
      || { "dune_expr": "VOID" || any || any }
      || { "dune_code": "NOOP" || any || any || any }
      || { "michelson": $unistring } }
  $bignum:
    /* Big number
       Decimal representation of a big number */
    string
  $micheline.michelson_v1.expression:
    { "int": $bignum }
    || { "string": $unistring }
    || { "bytes": /^[a-zA-Z0-9]+$/ }
    || [ $micheline.michelson_v1.expression ... ]
    || { "prim": $michelson.v1.primitives,
         "args"?: [ $micheline.michelson_v1.expression ... ],
         "annots"?: [ string ... ] }
  $michelson.v1.primitives:
    "ADMIN_ACCOUNTS"
    | "ADD"
    | "IF_NONE"
    | "SWAP"
    | "nat"
    | "Elt"
    | "big_map"
    | "map"
    | "SHA256"
    | "Right"
    | "LEFT"
    | "storage"
    | "SLICE"
    | "False"
    | "SHA512"
    | "BALANCE"
    | "EMPTY_BIG_MAP"
    | "OR"
    | "XOR"
    | "lambda"
    | "COMPARE"
    | "option"
    | "NEQ"
    | "BLOCK_LEVEL"
    | "AMOUNT"
    | "DIP"
    | "ABS"
    | "chain_id"
    | "MEM"
    | "ALLOW_PEERS"
    | "CONCAT"
    | "LOOP_LEFT"
    | "UPDATE"
    | "DUP"
    | "IS_IMPLICIT"
    | "CAR"
    | "CONS"
    | "NONE"
    | "GET"
    | "Left"
    | "SIZE"
    | "GET_ACCOUNT_INFO"
    | "DROP"
    | "NIL"
    | "DIG"
    | "RENAME"
    | "True"
    | "parameter"
    | "EQ"
    | "Pair"
    | "ADDRESS"
    | "AND"
    | "set"
    | "CHECK_SIGNATURE"
    | "IF_LEFT"
    | "LAMBDA"
    | "CREATE_CONTRACT"
    | "NEG"
    | "or"
    | "BLAKE2B"
    | "bytes"
    | "SET_DELEGATE"
    | "CONTRACT"
    | "LSL"
    | "SUB"
    | "IMPLICIT_ACCOUNT"
    | "PACK"
    | "list"
    | "PAIR"
    | "contract"
    | "GT"
    | "STEPS_TO_QUOTA"
    | "TRANSFER_TOKENS"
    | "CDR"
    | "PUSH"
    | "CHAIN_ID"
    | "signature"
    | "DUG"
    | "SELF"
    | "LSR"
    | "key"
    | "Unit"
    | "Some"
    | "UNPACK"
    | "INT"
    | "pair"
    | "COLLECT_CALL"
    | "ISNAT"
    | "EXEC"
    | "NOW"
    | "LOOP"
    | "string"
    | "MAP"
    | "None"
    | "address"
    | "EMPTY_SET"
    | "MUL"
    | "timestamp"
    | "LT"
    | "ADMIN_PROTOCOL"
    | "SOURCE"
    | "mutez"
    | "SENDER"
    | "IF_CONS"
    | "RIGHT"
    | "LE"
    | "IF"
    | "SOME"
    | "CAST"
    | "int"
    | "REVOKE_PEERS"
    | "key_hash"
    | "unit"
    | "EMPTY_MAP"
    | "APPLY"
    | "MANAGE_ACCOUNT"
    | "bool"
    | "operation"
    | "FAILWITH"
    | "GET_BALANCE"
    | "HASH_KEY"
    | "NOT"
    | "UNIT"
    | "EDIV"
    | "CREATE_ACCOUNT"
    | "GE"
    | "ITER"
    | "code"
  $script_expr:
    /* A script expression ID (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Not enough signatures were provided for this multisig action

To run an action on a multisig contract, you should provide at least as many signatures as indicated by the threshold stored in the multisig contract.

Id : client.005-PsBabyM1.notEnoughSignatures
Category : permanent

  { "kind": "permanent",
    "id": "client.005-PsBabyM1.notEnoughSignatures",
    "threshold_nsigs":
      [ integer ∈ [-2^30-2, 2^30+2], integer ∈ [-2^30-2, 2^30+2] ] }

Given threshold is too high

The given threshold is higher than the number of keys, this would lead to a frozen multisig contract

Id : client.005-PsBabyM1.thresholdTooHigh
Category : permanent

  { "kind": "permanent",
    "id": "client.005-PsBabyM1.thresholdTooHigh",
    "recieved_expected":
      [ integer ∈ [-2^30-2, 2^30+2], integer ∈ [-2^30-2, 2^30+2] ] }

Cannot open file for context restoring

Id : context_dump.read.cannot_open
Category : permanent

  { "kind": "permanent",
    "id": "context_dump.read.cannot_open",
    "context_restore_cannot_open": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Suspicious file: data after end

Id : context_dump.read.suspicious
Category : permanent

  { "kind": "permanent",
    "id": "context_dump.read.suspicious",
    "context_restore_suspicious": integer ∈ [-2^30-2, 2^30+2] }

Cannot open file for context dump

Id : context_dump.write.cannot_open
Category : permanent

  { "kind": "permanent",
    "id": "context_dump.write.cannot_open",
    "context_dump_cannot_open": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

The provided JSON could not be decoded in the specified language

An invalid JSON was provided for the specified language

Id : dune_lang_v1_parser.invalid_json
Category : permanent

  { "kind": "permanent",
    "id": "dune_lang_v1_parser.invalid_json",
    "lang": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Parsing Error

The source contains a parsing error

Id : dune_lang_v1_parser.parsing_error
Category : permanent

  { "kind": "permanent",
    "id": "dune_lang_v1_parser.parsing_error",
    "source": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

The specified language is not supported

An unspecified language was specified

Id : dune_lang_v1_parser.unsupported_language
Category : permanent

  { "kind": "permanent",
    "id": "dune_lang_v1_parser.unsupported_language",
    "lang": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Generic error

Unclassified error

Id : failure
Category : temporary

  { "kind": "temporary",
    "id": "failure",
    "msg": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Internal Event Sink: Wrong Activation URI

Activation of an Internal Event SINK with an URI failed

Id : internal-event-activation-error
Category : permanent

  { "kind": "permanent",
    "id": "internal-event-activation-error",
    "missing-uri-scheme": { "uri": $unistring } }
  || { "kind": "permanent",
       "id": "internal-event-activation-error",
       "non-registered-uri-scheme": { "uri": $unistring } }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Invalid depth argument

The raw context extraction depth argument must be positive.

Id : raw_context.invalid_depth
Category : permanent

  { "kind": "permanent",
    "id": "raw_context.invalid_depth",
    "depth": integer ∈ [-2^30-2, 2^30+2] }

Decoding_error

Error while decoding a remote signer message

Id : signer.decoding_error
Category : permanent

  { "kind": "permanent",
    "id": "signer.decoding_error" }

Encoding_error

Error while encoding a remote signer message

Id : signer.encoding_error
Category : permanent

  { "kind": "permanent",
    "id": "signer.encoding_error" }

Recv_error

Error while reading a remote signer message

Id : signer.recv_error
Category : permanent

  { "kind": "permanent",
    "id": "signer.recv_error",
    "error": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Send_error

Error while sending message to a remote signer

Id : signer.send_error
Category : permanent

  { "kind": "permanent",
    "id": "signer.send_error",
    "error": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Block_contents_not_found

Block not found

Id : state.block.contents_not_found
Category : permanent

  { "kind": "permanent",
    "id": "state.block.contents_not_found",
    "block_contents_not_found": $block_hash }
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Block_not_found

Block not found

Id : state.block.not_found
Category : permanent

  { "kind": "permanent",
    "id": "state.block.not_found",
    "block_not_found": $block_hash }
  $block_hash:
    /* A block identifier (Base58Check-encoded) */
    $unistring
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Unix System_info failure

Unix System_info failure

Id : unix.system_info
Category : temporary

  { "kind": "temporary",
    "id": "unix.system_info",
    "failure": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Unix error

An unhandled unix exception

Id : unix_error
Category : temporary

  { "kind": "temporary",
    "id": "unix_error",
    "msg": $unistring }
  $unistring:
    /* Universal string representation
       Either a plain UTF8 string, or a sequence of bytes for strings that
       contain invalid byte sequences. */
    string || { "invalid_utf8_string": [ integer ∈ [0, 255] ... ] }

Timeout

Timeout

Id : utils.Timeout
Category : temporary

  { "kind": "temporary",
    "id": "utils.Timeout",
    ... }