AVM Run Time Errors In Program

Abstract

This document introduces a convention for rising informative run time errors on the Algorand Virtual Machine (AVM) directly from the program bytecode.

Motivation

The AVM does not offer native opcodes to catch and raise run time errors.

The lack of native error handling semantics could lead to fragmentation of tooling and frictions for AVM clients, who are unable to retrieve informative and useful hints about the occurred run time failures.

This ARC formalizes a convention to rise AVM run time errors based just on the program bytecode.

Specification

The keywords “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in RFC 2119.

Notes like this are non-normative.

Error format

The AVM programs bytecode have limited sized. In this convention, the errors are part of the bytecode, therefore it is good to mind errors’ formatting and sizing.

Errors consist of a code and an optional short message.

Errors MUST be prefixed either with:

ERR: for custom errors;
AER: reserved for future ARC standard errors.

Errors MUST use : as domain separator.

It is RECOMMENDED to use UTF-8 for the error bytes string encoding.

It is RECOMMENDED to use short error messages.

It is RECOMMENDED to use camel case for alphanumeric error codes.

It is RECOMMENDED to avoid error byte strings of exactly 8 or 32 bytes.

In Program Errors

When a program wants to emit informative run time errors, directly from the bytecode, it MUST:

Push to the stack the bytes string containing the error;
Execute the log opcode to use the bytes from the top of the stack;
Execute the err opcode to immediately terminate the program.

Upon a program run time failure, the Algod API response contains both the failed program counter (pc) and the logs array with the errors.

The program MAY return multiple errors in the same failed execution.

The errors MUST be retrieved by:

Decoding the base64 elements of the logs array;
Validating the decoded elements against the error regexp.

Error examples

Error conforming this specification are always prefixed with ERR:.

Error with a numeric code: ERR:042.

Error with an alphanumeric code: ERR:BadRequest.

Error with a numeric code and short message: ERR:042:AFunnyError.

Program example

The following program example raises the error ERR:001:Invalid Method for any application call to methods different from m1()void.

1
#pragma version 10
2

3
txn ApplicationID
4
bz end
5

6
method "m1()void"
7
txn ApplicationArgs 0
8
match method1
9
byte "ERR:001:Invalid Method"
10
log
11
err
12

13
method1:
14
b end
15

16
end:
17
int 1

Full Algod API response of a failed execution:

1
{
2
    "data": {
3
        "app-index":1004,
4
        "eval-states": [
5
            {
6
                "logs": ["RVJSOjAwMTpJbnZhbGlkIE1ldGhvZA=="]
7
            }
8
        ],
9
        "group-index":0,
10
        "pc":41
11
    },
12
    "message":"TransactionPool.Remember: transaction ESI4GHAZY46MCUCLPBSB5HBRZPGO6V7DDUM5XKMNVPIRJK6DDAGQ: logic eval error: err opcode executed. Details: app=1004, pc=41"
13
}

The logs array contains the base64 encoded error ERR:001:Invalid Method.

The logs array MAY contain elements that are not errors (as specified by the regexp).

It is NOT RECOMMENDED to use the message field to retrieve errors.

AVM Compilers

AVM compilers (and related tools) SHOULD provide two error compiling options:

The one specified in this ARC as default;
The one specified in ARC-56 as fallback, if compiled bytecode size exceeds the AVM limits.

Compilers MAY optimize for program bytecode size by storing the error prefixes in the bytecblock and concatenating the error message at the cost of some extra opcodes.

Rationale

This convention for AVM run time errors presents the following PROS and CONS.

PROS:

No additional artifacts required to return informative run time errors;
Errors are directly returned in the Algod API response, which can be filtered with the specified error regexp.

CONS:

Errors consume program bytecode size.

Security Considerations

Not applicable.