Recipes

Converting App Argument to Integer

All arguments passed to the application in the ApplicationCall transaction are converted to bytes. If you passed an integer and want to use it as integer in the contract, you have to convert it to integer using btoi opcode.

bytes input_as_bytes = Txn.ApplicationArgs[0]
int input_as_int = btoi(input_as_bytes)

# Example: Total sum of all app arguments
int app_args_count = Txn.NumAppArgs
int total = 0

for index in 0:app_args_count:
    total = total + btoi(Txn.ApplicationArgs[index])
end

Opting in the application to an asset

int asset_id

int is_opted_in
is_opted_in, _ = asset_holding_get(AssetBalance, Global.CurrentApplicationAddress, asset_id)

if is_opted_in == 0:
    inner_txn:
        TypeEnum: Axfer
        Sender: Global.CurrentApplicationAddress
        AssetReceiver: Global.CurrentApplicationAddress
        AssetAmount: 0
        XferAsset: asset_id
        Fee: 0
    end
end

Inner app call

inner_txn:
    TypeEnum: Appl
    OnCompletion: NoOp
    ApplicationID: THE_APP_ID
    ApplicationArgs[0]: "arg1"
    ApplicationArgs[1]: "arg2"
    Accounts[0]: Txn.Sender
    Accounts[1]: Txn.Accounts[1]
    Fee: 0
end

Calling another application with an inner transaction

inner_txn:
    TypeEnum: Appl
    OnCompletion: NoOp
    ApplicationID: THE_APP_ID
    ApplicationArgs[0]: "arg1"
    ApplicationArgs[1]: "arg2"
    Accounts[0]: Txn.Sender
    Accounts[1]: Txn.Accounts[1]
    Fee: 0
end

Handling Integer Overflow

Converting integers to big-endian unsigned integers and using byte arithmetics allows handling integers up to 512 bits without overflow. Note that these b* and others have a higher opcode cost than the normal integer operators.

const int MAX_INT_64 = 18446744073709551615

# a and b are very big numbers and multiplication of them doesn't fit in to uint 64.
int a = MAX_INT_64
int b = MAX_INT_64 / 2

bytes mul = itob(a) b* itob(b)
bytes sum = itob(a) b+ itob(b)
int result = btoi(mul b/ sum)

Optimizing the generated TEAL code partially

Teal allows using raw TEAL directly, see Inline Teal. Decreasing the size and computational cost using TEAL and custom stack management is possible.

Reformatting the Tealish code may result a small gain. Reducing the variable usage help you ascetically if you are on the limit of budget cost. Variable assignment generates store, and usages generates load opcodes. So, you can remove the variables used one time.

int a = get_int()
int b = get_int()
int c = get_int()

int result = (a + b) + c

# Dummy function
func get_int() int:
    return 2
end

int result = (get_int() + get_int()) + get_int()

# Dummy function
func get_int() int:
    return 2
end

Increasing the budget

The opcode budget of an application call is 700. Most TEAL Opcodes have a cost of 1 but some are much higher. For example b+ is 20 times more costly than b If the transaction group has multiple application calls, the budget is pooled. The details are explained in the Algorand Developer Documentation.

Similar to OpUp utility of PyTeal, you can increase the cost budget by adding another app call using inner transactions. Each app call adds an extra 700 to the budget.

increase_cost_budget creates and deletes an app with single transactions. This is the most portable and efficient way to achieve the goal.

func increase_cost_budget():
    inner_txn:
        TypeEnum: Appl
        OnCompletion: DeleteApplication
        ApprovalProgram: "\x06\x81\x01"
        ClearStateProgram: "\x06\x81\x01"
        Fee: 0
    end
    return
end

Testing & Debugging

After compiling the Tealish code into TEAL, you can use all the testing, and debugging tools that are compatible with TEAL. Using Sandbox node for testing and developing as explained on Algorand Developer Documentation is also an option.

Algojig

“ AlgoJig is a development and testing jig for Algorand. It allows developers to run transactions and write tests starting from a known Algorand ledger state. It is suitable for testing all kinds of transactions, including application calls and logic signatures.”

Counter Prize and Auction example contracts implemented by Tealish contains unit-tests and they use AlgoJig.

Example:

        stxn = txn.sign(self.app_creator_sk)

        block = self.ledger.eval_transactions(transactions=[stxn])
        block_txns = block[b"txns"]

        self.assertEqual(len(block_txns), 1)
        txn = block_txns[0]

        app_id = txn[b"apid"]
        self.assertIsNotNone(app_id)

        # check final state
        final_global_state = self.ledger.get_global_state(
            app_id=app_id,
        )
        self.assertDictEqual(
            final_global_state,
            {b"counter": 0},
        )

        # check delta
        global_delta = txn[b"dt"][b"gd"]
        self.assertDictEqual(
            global_delta,
            {b"counter": {b"at": 2}},
        )