An accumulator root hash is the root hash of a
An account in the Endless blockchain is a container for an arbitrary number of Move modules and Move resources.
The state of each account is composed of both code and data.
The account is identified by account address.
See Accounts for more information.
An account address is the address of an Endless account.
Account address refers to a specific destination on the Endless network. The address dictates the destination and source of a specific amount of assets exchanged by two parties on the blockchain.
Endless addresses are 64-character hex string (32 bytes). Often times these strings are prefixed with 0x and for first 16 addresses, the leading 0s are excluded (ex. 0x1)
See Accounts for more information.
An Application Programming Interface (API) is a set of protocols and tools that allow users to interact with Endless blockchain nodes and client networks via external applications. Endless offers a REST API to communicate with our nodes.
See documentation for more details.
Endless token (EDS) is the Endless blockchain native token used for paying network and transaction fees.
On Endless, blocks are a batch of transactions committed at the same time.
Block number is analogous to "block height" in blockchain literature.
Transactions are referenced by ledger version rather than by block.
A validator that does not follow the specification of the consensus protocol, and wishes to compromise the correct execution of the protocol.
BFT algorithms traditionally support up to one-third of the algorithm's voting power being held by Byzantine validators.
Byzantine Fault Tolerance (BFT) is the ability of a distributed system to provide safety and liveness guarantees in the presence of faulty, or "Byzantine," validators below a certain threshold.
The Endless blockchain uses EndlessBFT, a consensus protocol based on Jolteon.
BFT algorithms typically operate with a number of entities, collectively holding N votes (which are called "validators" in the Endless network’s application of the system).
N is chosen to withstand some number of validators holding f votes, which might be malicious.
Command line interface refers to the Endless CLI used for developing on the Endless blockchain, operating nodes, and debugging issues. Find out more at Use the Endless CLI.
Client is software that receives information from the blockchain and manages transactions. Clients interact with the blockchain through the Endless nodes.
Code labs and tutorials depict various workflows - such as the use of the Endless CLI in minting non-fungible tokens (NFTs) - in order for users to understand how the process works and employ related functions in their code. If users have the necessary funds in their accounts, they can follow the same code lab and tutorial steps used in devnet, testnet and mainnet networks.
Consensus is a component of a validator.
The consensus component is responsible for coordination and agreement amongst all validators on the block of transactions to be executed, their order, and the execution results.
The Endless blockchain is formed with these agreed-upon transactions and their corresponding execution results.
The consensus component is accountable for achieving security, trust, and agreement among all validators on the Endless blockchain.
A consensus protocol is collectively executed by n validators to accept or reject a transaction and to agree on the ordering of transactions and execution results.
See BFT.
Decentralized applications (dapps) are programs or digital applications that run on the Endless blockchain autonomously. Smart contracts are commonly used to achieve this function.
The Endless devnet is a publicly deployed instance of the Endless network that runs using a set of validator test nodes.
The devnet is a demonstration of the Endless network that is built for experimenting with new ideas
The devnet simulates a digital payment system and the coins on the devnet have no real world value.
The devnet is the network by which developers are given the opportunity to test given protocols. It is similar to testnet as it operates independently of the mainnet yet is reset weekly.
Ed25519 is our supported digital signature scheme.
More specifically, the Endless network uses the PureEdDSA scheme over the Ed25519 curve, as defined in RFC 8032.
Endless is a Layer 1 blockchain for everyone. It uses the Move programming language and launched its mainnet on 2022-10-17 to redefine the web3 user experience. The Endless blockchain is dedicated to creating better user experiences through increased speed, security, scalability, reliability and usability with low transaction costs. The word "Endless" means "The People" in the Ohlone language. Learn more about the Endless blockchain on the .
EndlessBFT is the Endless protocol's BFT consensus algorithm.
EndlessBFT is based on Jolteon.
The Endless blockchain is a ledger of immutable transactions agreed upon by the validators on the Endless network (the network of validators).
Endless is the containing the code for Endless Network software. Endless contains software for
the Endless blockchain itself, which generates and stores the immutable ledger of confirmed transactions and
the validation process, which implements the consensus algorithm to validate transactions and add them to the Endless blockchain immutable ledger.
Endless ecosystem refers to various components of the Endless blockchain network and their interactions. The Endless ecosystem includes the community, , and . See Contribute to the Endless Ecosystem for all possible ways to join Endless.
The is an interface that helps users examine details of the Endless blockchain, including account information, validators, and transactions.
The Endless Explorer help users validate their work in Endless wallets and other tools in the blockchain. Find more details at Use the Endless Explorer.
The Endless Framework defines the public API for blockchain updates and the structure of on-chain data. It defines the business logic and access control for the three key pillars of Endless functionality: payments, treasury, and on-chain governance. It is implemented as a set of modules written in the Move programming language and stored on-chain as Move bytecode.
An Endless node is a peer entity of the Endless network that tracks the state of the Endless blockchain. There are two types of Endless nodes, validators and fullnodes.
Endless protocol is the specification of how transactions are submitted, ordered, executed, and recorded within the Endless network.
A EndlessAccount is a Move resource that holds all the administrative data associated with an account, such as sequence number, balance, and authentication key.
A EndlessAccount is the only resource that every account is guaranteed to contain.
The EndlessAccount module is a Move module that contains the code for manipulating the administrative data held in a particular EndlessAccount.T resource.
Code for checking or incrementing sequence numbers, withdrawing or depositing currency, and extracting gas deposits is included in the EndlessAccount module.
See devnet.
An epoch is the period of time between reconfigurations of the validator set and other administrative actions by the blockchain. On Endless mainnet currently, it is every 2 hours.
An event is the user-facing representation of the effects of executing a transaction.
A transaction may be designed to emit any number of events as a list. For example, a Coin<EndlessCoin> transfer emits a WithdrawEvent for the sender account and a DepositEvent for the recipient account.
In the Endless protocol, events provide evidence that the successful execution of a transaction resulted in a specific effect. The DepositEvent
Execution in the Endless blockchain is an Endless node component that manages the block of transactions. The execution component stores successful transactions.
A transaction ceases to be valid after its expiration time. If it is assumed that:
Time_C is the current time that is agreed upon between validators (Time_C is not the local time of the client);
Time_E is the expiration time of a transaction T_N; and
Time_C > Time_E and transaction T_N has not been included in the blockchain,
then there is a guarantee that T_N will never be included in the blockchain.
Faucet is a service that mints EDS on devnet and testnet. EDS on these networks has no real world value, it is only for development purposes.
You can use the faucet in a few different ways:
With the Endless CLI.
Through a wallet, such as or . See full list of
Fullnodes are clients that ensure data are stored up-to-date on the network. They replicate blockchain state and transactions from other fullnodes and validator nodes.
A fungible asset is an asset, such as a currency, share, in-game resource, etc., that is interchangeable with another identical asset without any loss in its value. For example, EDS is a fungible asset because you can exchange one EDS for another.
Follow the Asset Standards to create fungible assets on the Endless blockchain.
Next generation of the Coin standard that addresses shortcomings of endless_framework::coin such as lack of guaranteed enforcement of freeze and burn and advanced functionalities such as programmable transfers, e.g., approve in ERC-20.
For the legacy Endless Token Standard (endless_token::token), a fungible token is a token that is interchangeable with other identical tokens (i.e., tokens that share the same TokenId). This means the tokens have the same creator address, collection name, token name, and property version.
For the Endless Digital Asset Standard (endless_token_objects::token), a fungible token is a fungible asset with metadata object that includes a Digital Asset resource.
A fungible unit is an individual unit of a fungible asset. These units are identical and interchangeable without any loss in value. For example, each Octa (the smallest unit of EDS) is a fungible unit.
Gas is a way to pay for computation and storage on a blockchain network. All transactions on the Endless network cost a certain amount of gas.
The gas required for a transaction depends on the size of the transaction, the computational cost of executing the transaction, and the amount of additional global state created by the transaction (e.g., if new accounts are created).
The purpose of gas is regulating demand for the limited computational and storage resources of the validators, including preventing denial of service (DoS) attacks.
See Gas and Storage Fees for more information.
Each transaction specifies the gas unit price the sender is willing to pay per unit of gas.
The price of gas required for a transaction depends on the current demand for usage of the network.
Gas price is expressed in Octa. 1 EDS = 10^8 Octa
See Gas and Storage Fees for more information.
Honesty means a validator that faithfully executes the consensus protocol and is not Byzantine.
Jolteon is a recent proposal for a BFT consensus protocol.
EndlessBFT, the Endless network's consensus algorithm, is based on Jolteon.
It simplifies the reasoning about safety, and it addresses some performance limitations of previous consensus protocols. In particular, it reduces latency by 33% compared to HotStuff.
Indexer is the component of Endless that retrieves, processes, and efficiently stores raw data in the database to provide speedy access to the Endless blockchain state.
At a high level, indexer gets data from a gRPC stream and runs processors to transform raw blockchain data and serve transformed data via GraphQL endpoint.
A leader is a validator that proposes a block of transactions for the consensus protocol.
In leader-based protocols, nodes must agree on a leader to make progress.
Leaders are selected by a function that takes the current as input.
Mainnet refers to a working, fully-operational blockchain. A mainnet network has been fully deployed and performs the functionality of transferring digital currency from a sender to a recipient.
The Maximum Gas Amount of a transaction is the maximum gas amount in gas units that the sender is ready to pay for the transaction.
The transaction can be successfully executed only if the gas used does not exceed the maximum gas amount.
The gas charged is equal to the gas price multiplied by units of gas required to process this transaction.
If the transaction runs out of gas while it is being executed or the account runs out of balance during execution, then the sender will be charged for gas used and the transaction will fail.
See Gas and Storage Fees for more information.
Mempool is one of the components of the validator. It holds an in-memory buffer of transactions that have been submitted but not yet agreed upon and executed. Mempool receives transactions from other full nodes.
Transactions in the mempool of a validator are added from the JSON-RPC Service of the current node and from the mempool of other Endless nodes.
When the current validator is the leader, its consensus component pulls the transactions from its mempool and proposes the order of the transactions that form a block. The validator quorum then votes on the proposal.
Merkle tree is a type of authenticated data structure that allows for efficient verification of data integrity and updates.
The Endless network treats the entire blockchain as a single data structure that records the history of transactions and states over time.
The implementation simplifies the work of apps accessing the blockchain. It allows apps to:
The is an append-only Merkle tree that the Endless blockchain uses to store the ledger.
A Merkle accumulator can provide proofs that a transaction was included in the chain ("proof of inclusion").
They are also called "history trees" in literature.
A module in the Move programming language may either be a program or library that can create, transfer, or store assets.
Move is a new programming language that implements all the transactions on the Endless blockchain.
It has two different kinds of code — Move scripts and Move modules.
Move is a safe and secure programming language for web3 that emphasizes access control and scarcity. It is the programming language used to build the Endless blockchain. You can read more about it in Move on Endless.
Move programs are compiled into Move bytecode.
Move bytecode is used to express Move scripts and Move modules.
A Move module defines the rules for updating the global state of the Endless blockchain.
In the Endless protocol, a Move module is a smart contract.
Each user-submitted transaction includes a Move script. The Move script invokes procedures of one or more Move modules to update the global state of the blockchain according to the rules.
Move resources contain data that can be accessed according to the procedures declared in a Move module.
Move resources can never be copied, reused, or lost. This protects Move programmers from accidentally or intentionally losing track of a resource.
The Move virtual machine executes Move scripts written in Move bytecode to produce an execution result. This result is used to update the blockchain state.
The virtual machine is part of a validator.
The Move virtual machine (MoveVM) processes each validator node that translates transactions along with the current blockchain ledger state to produce a changeset as input or storage delta as output.
A node is a peer entity of the Endless network that tracks the state of the Endless blockchain.
An Endless node consists of logical components. Mempool, consensus, and the Move virtual machine are examples of node components.
Nonce is a number only used once, a random or semi-random number that is generated for a specific use for authentication protocols and cryptographic hash functions.
Open-source community is a term used for a group of developers who work on open-source software. If you're reading this glossary, then you are part of the Endless project's developer community.
A proof is a way to verify the accuracy of data in the blockchain.
Every operation in the Endless blockchain can be verified cryptographically that it is indeed correct and that data has not been omitted.
For example, if a user queries the information within a particular executed transaction, they will be provided with a cryptographic proof that the data returned to them is correct.
Proof-of-Stake (PoS) is a security mechanism that serves in confirming the uniqueness and legitimacy of blockchain transactions. The PoS consensus mechanism is leveraged by the Endless blockchain powered by a network of validators, which in turn update the system and process transactions.
A resource account is used to manage resources independent of an account managed by a user. For example, a developer may use a resource account to manage an account for module publishing, say managing a contract.
The contract itself does not require a signer post initialization. A resource account gives you the means for the module to provide a signer to other modules and sign transactions on behalf of the module.
See Resource accounts for instructions on use.
The REST Service component is the external interface of an Endless node. Any incoming client request, such as submitted transactions or queries, must first go through the REST Service. A client needs to go through the REST Service component to access storage or any other component in the system. This filters requests and protects the system.
Whenever a client submits a new transaction, the REST Service passes it to mempool.
A round consists of achieving consensus on a block of transactions and their execution results.
A round number is a shared counter used to select leaders during an epoch of the consensus protocol.
Endless software development kits (SDKs) are sets of tools that enable a developer to quickly create a custom app on the Endless platform. Find out more at Use the Endless SDKs.
The sequence number for an account indicates the number of transactions that have been submitted and committed on chain from that account. It is incremented every time a transaction sent from that account is executed or aborted and stored in the blockchain.
A transaction is executed only if it matches the current sequence number for the sender account. This helps sequence multiple transactions from the same sender and prevents replay attacks.
If the current sequence number of an account A is X, then a transaction T on account A will only be executed if T's sequence number is X.
Alternate name: Sender address.
Sender is the address that originates the transaction. A transaction must be signed by the sender but can have more than one signer.
Method for decreasing latency for BFT protocols. See
Smart contract refers to a computer program that automatically and directly carries out the contract's terms.
See Move Module for related details.
A state in the Endless protocol is a snapshot of the distributed database.
A transaction modifies the database and produces a new and updated state.
State root hash is a over all keys and values the state of the Endless blockchain at a given version.
A implements the Table type and in Endless is used to store information as key-value data within an account at large scale.
See for the associated Endless source file.
Testnet describes the Endless network that is not fully functional yet more stable than devnet; it is an alternative network to mainnet to be used for testing.
Tokens are digital units of value issued on a blockchain. They can be redeemed for assets or value held. Tokens can be of the types: Fungible Token (FT), Non-Fungible Token (NFT), and Semi-Fungible Token (SFT).
A raw transaction contains the following fields:
Sender (account address)
Move script
Gas price
Each transaction submitted by a user includes a Move script.
These transactions, also known as Move scripts, represent the operations a client submits to a validator.
The operation could be a request to move coins from user A to user B, or it could involve interactions with published Move modules (smart contracts).
The Move script is an arbitrary program that interacts with resources published in the global storage of the Endless blockchain by calling the procedures of a module. It encodes the logic for a transaction.
To see example uses of Move scripts, follow Move scripts and the Your First Multisig tutorial.
Alternate name: Validators.
A validator is an entity of the Endless ecosystem that validates on the Endless blockchain. It receives requests from clients and runs consensus, execution, and storage.
A validator maintains the history of all the transactions on the blockchain.
Internally, a validator needs to keep the current state, to execute transactions, and to calculate the next state.
Validator nodes are a unique class of fullnodes that take part in consensus, specifically a Byzantine Fault Tolerance (BFT) consensus protocol in Endless. Validators agree upon transactions to be added to the Endless blockchain as well as the order in which they are added.
A version is a sequentially increasing number that increments for every transaction.
On endless, transactions are globally ordered and every transaction has a version (often called called "height" in blockchain literature.)
Transaction version 0 is the first transaction (genesis transaction), and a transaction version 100 is the 101st transaction in the blockchain.
An Endless transaction is well-formed if each of the following conditions are true for the transaction:
The transaction has a valid signature.
An account exists at the sender address.
It includes a public key, and the hash of the public key matches the sender account's authentication key.
The sequence number of the transaction matches the sender account's sequence number.
This page catalogs common errors encountered in the Endless blockchain and explains how to resolve them wherever possible. As with all software, the code itself is the source of truth for error handling and will always contain entries not found here. Instead, this matrix aims to help you address those errors most typically found, misunderstood, or both.
For the sources of these errors, see:
In this configuration, N is typically set to 3f+1. Validators holding up to f votes will be allowed to be faulty — offline, malicious, slow, etc. As long as 2f+1 votes are held by honest validators, they will be able to reach consensus on consistent decisions.
This implies that BFT consensus protocols can function correctly, even if up to one-third of the voting power is held by validators that are compromised or fail.
Events are persisted on the blockchain and are used to answer queries by clients.
Using an SDK, for example by using the FaucetClient in the TypeScript SDK.
With a direct HTTP request. Learn how to do this here.
Verify the integrity of the data using a unified framework.
When the transaction is applied, the sequence number of the account will become X+1. The account has a strictly increasing sequence number.
Maximum gas amount
Sequence number
Expiration time
A signed transaction is a raw transaction with the digital signature.
An executed transaction changes the state of the Endless blockchain.
A single Move script can send funds to multiple recipients and invoke procedures from several different modules.
A Move script is not stored in the global state and cannot be invoked by other Move scripts. It is a single-use program.
Endless validators are in charge of verifying transactions.
The sender account's balance is greater than the maximum gas amount.
The expiration time of the transaction has not passed.
LOOKUP_FAILED
A function that is being called isn't present on the network being used
Check that your dependencies on-chain have the same version
UNKNOWN_VALIDATION_STATUS
We don't want the default value to be valid.
N/A
INVALID_SIGNATURE
The transaction has a bad signature.
Submit a new transaction with a new signature
INVALID_AUTH_KEY
Bad account authentication key.
INVALID_ARGUMENT
Caller specified an invalid argument (HTTP: 400).
OUT_OF_RANGE
An input or result of a computation is out of range (HTTP: 400).
INVALID_STATE
The system is not in a state where the operation can be performed (HTTP: 400).
UNAUTHENTICATED
Request not authenticated due to missing, invalid, or expired authentication token (HTTP: 401).
PERMISSION_DENIED
The client does not have sufficient permission (HTTP: 403).
NOT_FOUND
A specified resource is not found (HTTP: 404).
EACCOUNT_ALREADY_EXISTS
Account already exists.
N/A
EACCOUNT_DOES_NOT_EXIST
Account does not exist.
Create the account first
ESEQUENCE_NUMBER_TOO_BIG
Sequence number exceeds the maximum value for a u64.
Provide a smaller sequence number
EMALFORMED_AUTHENTICATION_KEY
The provided authentication key has an invalid length.
ECOIN_INFO_ADDRESS_MISMATCH
Address of account which is used to initialize a coin CoinType doesn't match the deployer of module.
Create the coin using a CoinType in the same account creating the coin.
ECOIN_INFO_ALREADY_PUBLISHED
CoinType is already initialized as a coin.
N/A
ECOIN_INFO_NOT_PUBLISHED
CoinType hasn't been initialized as a coin.
Create the coin with CoinType first before using it
ECOIN_STORE_ALREADY_PUBLISHED
Account already has CoinStore registered for CoinType.
EALREADY_HAS_BALANCE
The token has balance and cannot be initialized.
ECOLLECTIONS_NOT_PUBLISHED
There isn't any collection under this account.
ECOLLECTION_NOT_PUBLISHED
Cannot find collection in creator's account.
ECOLLECTION_ALREADY_EXISTS
The collection already exists.
ECREATE_WOULD_EXCEED_COLLECTION_MAXIMUM
Exceeds the collection's maximal number of token_data.
EINSUFFICIENT_BALANCE
Insufficient token balance.
Submit a new transaction with a new signature, check that the account matches the authentication key and hasn't been rotated
SEQUENCE_NUMBER_TOO_OLD
Sequence number is too old.
Submit a new transaction with a newer sequence number from the account
SEQUENCE_NUMBER_TOO_NEW
Sequence number is too new.
Submit a new transaction with a new signature
INSUFFICIENT_BALANCE_FOR_TRANSACTION_FEE
Insufficient balance to pay minimum transaction fee.
Fund the account with more EDS to pay for the gas fee
TRANSACTION_EXPIRED
The transaction has expired.
Submit a new transaction with an expiration time further in the future
SENDING_ACCOUNT_DOES_NOT_EXIST
The sending account does not exist.
Create the account prior to sending the transaction again
REJECTED_WRITE_SET
This write set transaction was rejected because it did not meet the requirements for one.
N/A
INVALID_WRITE_SET
This write set transaction cannot be applied to the current state.
N/A
EXCEEDED_MAX_TRANSACTION_SIZE
Length of program field in raw transaction exceeded max length.
The transaction is too large for a single transaction; if this is a package publish, try to break it into multiple packages
UNKNOWN_SCRIPT
This script is not in our allowlist of scripts.
N/A
UNKNOWN_MODULE
Transaction is trying to publish a new module.
N/A
MAX_GAS_UNITS_EXCEEDS_MAX_GAS_UNITS_BOUND
Max gas units submitted with transaction exceeds max gas units bound in VM.
Decrease the max gas amount in the transaction below the maximum value in the gas schedule
MAX_GAS_UNITS_BELOW_MIN_TRANSACTION_GAS_UNITS
Max gas units submitted with transaction not enough to cover the intrinsic cost of the transaction.
Increase the max gas amount above the minimum value in the gas schedule
GAS_UNIT_PRICE_BELOW_MIN_BOUND
Gas unit price submitted with transaction is below minimum gas price set in the VM.
Increase the gas unit price below the minimum gas unit price in the gas schedule
GAS_UNIT_PRICE_ABOVE_MAX_BOUND
Gas unit price submitted with the transaction is above the maximum gas price set in the VM.
Decrease the gas unit price below the maximum gas unit price in the gas schedule
INVALID_GAS_SPECIFIER
Gas specifier submitted is either malformed (not a valid identifier), or does not refer to an accepted gas specifier.
N/A
SENDING_ACCOUNT_FROZEN
The sending account is frozen.
N/A
UNABLE_TO_DESERIALIZE_ACCOUNT
Unable to deserialize the account blob.
N/A
CURRENCY_INFO_DOES_NOT_EXIST
The currency info was unable to be found.
N/A
INVALID_MODULE_PUBLISHER
The account sender doesn't have permissions to publish modules.
N/A
NO_ACCOUNT_ROLE
The sending account has no role.
N/A
BAD_CHAIN_ID
The transaction's chain_id does not match the one published on-chain.
Verify that your chain ID matches the chain ID for your network
SEQUENCE_NUMBER_TOO_BIG
The sequence number is too large and would overflow if the transaction were executed.
N/A
BAD_TRANSACTION_FEE_CURRENCY
The gas currency is not registered as a TransactionFee currency.
N/A
FEATURE_UNDER_GATING
The feature requested is intended for a future Endless version instead of the current one.
N/A
SECONDARY_KEYS_ADDRESSES_COUNT_MISMATCH
The number of secondary signer addresses is different from the number of secondary public keys provided.
Verify the multi-agent or multi-ed25519 secondary signer addresses match the secondary public keys
SIGNERS_CONTAIN_DUPLICATES
There are duplicates among signers, including the sender and all the secondary signers.
Remove any duplicate signers
SEQUENCE_NONCE_INVALID
The sequence nonce in the transaction is invalid (too new, too old, or already used).
N/A
CHAIN_ACCOUNT_INFO_DOES_NOT_EXIST
There was an error when accessing chain-specific account information.
N/A
MODULE_ADDRESS_DOES_NOT_MATCH_SENDER
the module publisher is not the account that will eventually hold the module.
Confirm the module address in the move contract matches the sender of the transaction
ZERO_SIZED_STRUCT
Reported when a struct has zero fields.
N/A
DUPLICATE_MODULE_NAME
The sender is trying to publish two modules with the same name in one transaction.
Confirm every module has a unique name
BACKWARD_INCOMPATIBLE_MODULE_UPDATE
The sender is trying to publish a module that breaks the compatibility checks.
Confirm your new modules being published don't break backwards compatibility
CYCLIC_MODULE_DEPENDENCY
The updated module introduces a cyclic dependency (i.e., A uses B and B also uses A).
Check for loops in your module dependencies in the modules being published
INVALID_FRIEND_DECL_WITH_SELF
Cannot mark the module itself as a friend.
Confirm no module has itself marked as a friend in the modules being published
INVALID_FRIEND_DECL_WITH_MODULES_OUTSIDE_ACCOUNT_ADDRESS
Cannot declare modules outside of account address as friends.
Confirm all friends are in the same account address in the modules being published
INVALID_FRIEND_DECL_WITH_MODULES_IN_DEPENDENCIES
Cannot declare modules that this module depends on as friends.
Check friend declarations of the modules being published
CYCLIC_MODULE_FRIENDSHIP
The updated module introduces a cyclic friendship (i.e., A friends B and B also friends A).
Check friend declarations of the modules being published
INVALID_PHANTOM_TYPE_PARAM_POSITION
A phantom type parameter was used in a non-phantom position.
Confirm phantom types are used only with generics
LOOP_MAX_DEPTH_REACHED
Loops are too deeply nested.
Check for many nested loops
TYPE_RESOLUTION_FAILURE
Failed to resolve type due to linking being broken after verification.
N/A
RESOURCE_DOES_NOT_EXIST
We tried to access a resource that does not exist under the account.
Check the contract and possibly change it to handle resources that don't exist
RESOURCE_ALREADY_EXISTS
We tried to create a resource under an account where that resource already exists.
Check the contract and possibly change it to handle resources that already exist
UNKNOWN_STATUS
A reserved status to represent an unknown vm status. This is std::u64::MAX, but we can't pattern match on that, so put the hardcoded value in.
N/A
LINKER_ERROR
This may be due to the function has not been published on chain or by trying to call an invalid function as the result of either an incorrect account address, module name, or function name. This might not happen locally if the sources are available locally but have yet to be published on-chain.
There are many reasons, but you should check your account addresses, module names, and function names to determine that they're correct and published
ABORTED
Concurrency conflict, such as read-modify-write conflict (HTTP: 409).
ALREADY_EXISTS
The resource that a client tried to create already exists (HTTP: 409).
RESOURCE_EXHAUSTED
Out of gas or other forms of quota (HTTP: 429).
CANCELLED
Request cancelled by the client (HTTP: 499).
INTERNAL
Internal error (HTTP: 500).
NOT_IMPLEMENTED
Feature not implemented (HTTP: 501).
UNAVAILABLE
The service is currently unavailable. Indicates that a retry could solve the issue (HTTP: 503).
Check your authentication key; it should be a 32-byte vector
ECANNOT_RESERVED_ADDRESS
Cannot create account because address is reserved.
N/A
EOUT_OF_GAS
Transaction exceeded its allocated max gas.
Increase the max gas amount
EWRONG_CURRENT_PUBLIC_KEY
Specified current public key is not correct.
Confirm the public key matches the account
EINVALID_PROOF_OF_KNOWLEDGE
Specified proof of knowledge required to prove ownership of a public key is invalid.
Check your proof of knowledge in key rotation to ensure it has proper signatures
ENO_CAPABILITY
The caller does not have a digital-signature-based capability to call this function.
Confirm you have the capability for the called functions
EINVALID_ACCEPT_ROTATION_CAPABILITY
The caller does not have a valid rotation capability offer from the other account.
Confirm the account being rotated is correct
ENO_VALID_FRAMEWORK_RESERVED_ADDRESS
Address to create is not a valid reserved address for Endless framework.
N/A
EINVALID_SCHEME
Specified scheme required to proceed with the smart contract operation - can only be ED25519_SCHEME(0) OR MULTI_ED25519_SCHEME(1).
Confirm the transaction was signed correctly when creating the account
EINVALID_ORIGINATING_ADDRESS
Abort the transaction if the expected originating address is different from the originating address on-chain.
Confirm you are rotating the correct account's key
ENO_SUCH_SIGNER_CAPABILITY
The signer capability doesn't exist at the given address.
Confirm the address is correct
N/A
ECOIN_STORE_NOT_PUBLISHED
Account hasn't registered CoinStore for CoinType.
Register the account for the CoinType
EINSUFFICIENT_BALANCE
Not enough coins to complete transaction.
Transfer less coins, or acquire more coins prior to the transfer
EDESTRUCTION_OF_NONZERO_TOKEN
Cannot destroy non-zero coins.
N/A
EZERO_COIN_AMOUNT
Coin amount cannot be zero.
Don't burn coins or conduct other actions with zero coins
EFROZEN
CoinStore is frozen. Coins cannot be deposited or withdrawn.
Account is frozen for this token; talk to the coin owner
ECOIN_SUPPLY_UPGRADE_NOT_SUPPORTED
Cannot upgrade the total supply of coins to different implementation.
N/A
ECOIN_NAME_TOO_LONG
Name of the coin is too long.
Coin name must be less than or equal to 32 characters
ECOIN_SYMBOL_TOO_LONG
Symbol of the coin is too long.
Coin symbol must be less than or equal to 10 characters
EINVALID_TOKEN_MERGE
Cannot merge the two tokens with different token IDs.
EMINT_WOULD_EXCEED_TOKEN_MAXIMUM
Exceed the token data maximal allowed.
ENO_BURN_CAPABILITY
No burn capability.
ETOKEN_DATA_ALREADY_EXISTS
TokenData already exists.
ETOKEN_DATA_NOT_PUBLISHED
TokenData not published.
ETOKEN_STORE_NOT_PUBLISHED
TokenStore doesn't exist.
ETOKEN_SPLIT_AMOUNT_LARGER_THAN_TOKEN_AMOUNT
Cannot split token to an amount larger than its amount.
EFIELD_NOT_MUTABLE
The field is not mutable.
ENO_MUTATE_CAPABILITY
Not authorized to mutate.
ENO_TOKEN_IN_TOKEN_STORE
Token not in the token store.
EUSER_NOT_OPT_IN_DIRECT_TRANSFER
User didn't opt-in direct transfer.
EWITHDRAW_ZERO
Cannot withdraw 0 token.
ENFT_NOT_SPLITABLE
Cannot split a token that only has 1 amount.
ENO_MINT_CAPABILITY
No mint capability
ECOLLECTION_NAME_TOO_LONG
The collection name is too long.
ENFT_NAME_TOO_LONG
The NFT name is too long.
EURI_TOO_LONG
The URI is too long.
ENO_DEPOSIT_TOKEN_WITH_ZERO_AMOUNT
Cannot deposit a token with 0 amount.
ENO_BURN_TOKEN_WITH_ZERO_AMOUNT
Cannot burn 0 token.
EWITHDRAW_PROOF_EXPIRES
Withdraw proof expires.
EOWNER_CANNOT_BURN_TOKEN
Token is not burnable by owner.
ECREATOR_CANNOT_BURN_TOKEN
Token is not burnable by creator.
ECANNOT_UPDATE_RESERVED_PROPERTY
Reserved fields for token contract. Cannot be updated by user.
EURI_TOO_SHORT
URI too short.
ETOKEN_OFFER_NOT_EXIST
Token offer doesn't exist.