Skip to content

InnerTx: ContractCallTx


The whole script is located in the repository and this page explains in detail how to:

  • Create and sign a ContractCallTx with the innerTx option for an account that has no balance.
  • Wrap the signed ContractCallTx in a PayingForTx using an account with balance to pay the fees of the inner transaction.


  • This can be done for any transaction type!


This functionality allows every service to let their users interact with their decentralized aepp without having them to buy AE by covering their fees.


  • Game developers that want to quickly onboard new users.
  • Governance æpps that want people to vote on important proposals without having them to pay anything.
  • Custodians that want to offer an additional services to cover the transaction fees of their clients.
  • ... many more!

1. Specify imports

You need to import AeSdk, Node and MemoryAccount classes from the SDK. Additionally you import the generateKeyPair utility function to generate a new keypair.

const {
  AeSdk, Node, MemoryAccount, generateKeyPair, Tag,
} = require('@aeternity/aepp-sdk');

  • You need to have the SDK installed via npm i @aetenity/aepp-sdk -g to run that example code.

2. Define constants

The following constants are used in the subsequent code snippets.

  publicKey: 'ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR',
  secretKey: 'bf66e1c256931870908a649572ed0257876bb84e3cdf71efb12f56c7335fad54d5cf08400e988222f26eb4b02c8f89077457467211a6e6d955edb70749c6a33b',
const NODE_URL = '';
const COMPILER_URL = '';
const CONTRACT_ADDRESS = 'ct_iy86kak8GGt4U5VjDFNQf1a9qjbyxKpmGVNe3UuKwnmcM6LW8';
@compiler >= 6

contract PayingForTxExample =

    record state = { last_caller: option(address) }

    entrypoint init() =
        { last_caller = None }

    stateful entrypoint set_last_caller() =
        put(state{last_caller = Some(Call.caller)})

    entrypoint get_last_caller() : option(address) =
const NEW_USER_KEYPAIR = generateKeyPair();

  • The keypair of the account is pre-funded and only used for demonstration purpose
    • You can replace it with your own keypair (see Create a Keypair)
    • In case the account runs out of funds you can always request AE using the Faucet
  • The contract is already deployed at the defined address.
  • The NEW_USER_KEYPAIR is used to call the contract. The PayingForTx allows the new user to perform a contract call without having any funds.

3. Open async codeblock

Most functions of the SDK return Promises, so the recommended way of dealing with subsequent actions is running them one by one using await. Therefore we are putting our logic into an async code block

(async () => {

4. Create object instances

  const payerAccount = new MemoryAccount({ keypair: PAYER_ACCOUNT_KEYPAIR });
  const newUserAccount = new MemoryAccount({ keypair: NEW_USER_KEYPAIR });
  const node = new Node(NODE_URL);
  const aeSdk = new AeSdk({
    nodes: [{ name: 'testnet', instance: node }],
    compilerUrl: COMPILER_URL,
  await aeSdk.addAccount(payerAccount, { select: true });
  await aeSdk.addAccount(newUserAccount);

5. Create and sign ContractCallTx on behalf of new user

Currently there is no high-level API available that allows you to create and sign the ContractCallTx by invoking the generated contract method on the contract instance that you typically use for contract calls.

Following 4 steps need to be done:

  1. Initialize a contract instance by the source code and the contract address.
  2. Create calldata by calling the encode function providing the contract name, the name of the entrypoint to call as well as the required params.
    • The entrypoint with the name set_latest_caller doesn't require any params so you can provide an empty array
  3. Create the ContractCreateTx by providing all required params.
    • You could omit amount, gasLimit and gasPrice if you choose to stick to the default values (see transaction options)
  4. Sign the transaction by providing innerTx: true as transaction option.
    • The transaction will be signed in a special way that is required for inner transactions.
  const contract = await aeSdk.getContractInstance(
    { source: CONTRACT_SOURCE, contractAddress: CONTRACT_ADDRESS },
  const calldata = contract.calldata.encode('PayingForTxExample', 'set_last_caller', []);
  const contractCallTx = await aeSdk.buildTx(Tag.ContractCallTx, {
    callerId: await newUserAccount.address(),
    contractId: CONTRACT_ADDRESS,
    amount: 0,
    gasLimit: 1000000,
    gasPrice: 1500000000,
    callData: calldata,
  const signedContractCallTx = await aeSdk.signTransaction(
    { onAccount: newUserAccount, innerTx: true },

6. Create, sign & broadcast the PayingForTx as payer

  const payForTx = await aeSdk.payForTransaction(signedContractCallTx, { onAccount: payerAccount });

7. Check that last caller is the new user

Contract instance allows interacting with the contract in a convenient way.

  const dryRunTx = await contract.methods.get_last_caller();
  console.log(`New user: ${await newUserAccount.address()}`);
  console.log('Last caller:', dryRunTx.decodedResult);

  • Last caller should now be the address of the new user.
  • For regular (non-stateful) entrypoints the SDK automatically performs a dry-run which allows to perform read-only calls for free, see Contract guide.

8. Close and run async codeblock

Now you can close the async codeblock and execute it at the same time.