Hi! In this post, we will explore an example of a cross-contract call using the AssemblyScript SDK in the Soroban Smart Contract Platform.

A cross-contract call occurs when one contract calls a function on another contract. In this example, we will use two contracts: Contract A and Contract B. Contract A will contain the function that will be called, and Contract B will be the contract that calls the function from Contract A.

The Contract Code

Contract A Code:

import * as val from 'as-soroban-sdk/lib/value';

export function double(num: val.RawVal): val.RawVal {

  let numi32 = val.toI32(num);

  return (val.fromI32(numi32 *2));
}

A quick explanation, this contract contain double() function that takes a single parameter, num, of type val.RawVal and will double the input value. The function returns a val.RawVal.
Next, create contract.json file in your project directory, this file contains metadata for the contract.

{
    "name": "Contract A",
    "version": "0.1.0",
    "description": "Example",
    "host_functions_version": 29,
    "functions": [
        {
            "name" : "double",
            "arguments": [
                {"name": "num", "type": "i32"}
            ],
            "returns" : "i32"
        }
    ]
}

Before compiling the contract, we need to edit the asconfig.json file of your project. Replace its content with the following:

{
  "extends": "as-soroban-sdk/sdkasconfig",
  "targets": {
    "release": {
      "outFile": "build/release.wasm",
      "textFile": "build/release.wat"
    },
    "debug": {
      "outFile": "build/debug.wasm",
      "textFile": "build/debug.wat"
    }
  }
}

The asconfig.json file is used by the AssemblyScript compiler (asc) to define the configuration for your project.

Contract B Code:

import * as val from 'as-soroban-sdk/lib/value';
import { Vec } from "as-soroban-sdk/lib/vec";
import * as contract from "as-soroban-sdk/lib/contract";

export function callc(): val.RawVal {

  let contractId = "80863e58acf6d02f12bb0c5ecd0a046f66a171c22070bd31242d9cff7c027b84";
  let func = "double";
  let args = new Vec();
  args.pushBack(val.fromI32(3));

  return contract.callContractById(contractId, func, args.getHostObject());

}

The callc function imports the val and Vec modules from the Soroban SDK, as well as the contract module. It also defines a function called callc that takes no parameters and returns a val.RawVal.

The purpose of this function is to call a function called double in another contract using its contract ID. The contractId variable stores the ID of the contract that we want to call, and the func variable stores the name of the function that we want to call in the other contract.

In the next line, we create a new Vec called args and add an argument to it using args.pushBack(val.fromI32(3)). This creates a vector of arguments that we will pass to the double function in the other contract when we make the cross-contract call.

Finally, we make the cross-contract call using the contract.callContractById function. This function takes the contract ID, the name of the function we want to call, and the arguments vector as parameters. The getHostObject function is used to convert the args vector to an object that can be passed as a parameter to the callContractById function.

The callc function returns the result of the cross-contract call as a val.RawVal.

Next you know the drill, create contract.json file:

{
    "name": "CrossContract",
    "version": "0.1.0",
    "description": "cross contract example",
    "host_functions_version": 29,
    "functions": [
        {
            "name" : "callc",
            "arguments": [],
            "returns" : "i32"
        }
    ]
}

Edit asconfig.json same as Contract A.

Compiling The Contract

You need to compile both contracts from each contract directory using this command:

npx asc assembly/index.ts --target release

Now you should see two new files in each contract build/ directory: release.wasm and release.wat.

Run The Contract

First, we will deploy Contract A wasm file, using this command :

soroban contract deploy --wasm build/release.wasm

You will get contract ID from your deployed contract, similar to this:

80863e58acf6d02f12bb0c5ecd0a046f66a171c22070bd31242d9cff7c027b84

This contract ID should be put in Contract B contractID value, after you put it there, compile the contract again.

Next, we will invoke Contract B wasm file from contract b directory, using this command:

soroban contract invoke --wasm build/release.wasm --id 1 --fn callc

You should get this output:

6

Closing

Overall, this code provides a simple example of how Cross Contract Calls works using the AssemblyScript SDK. By using the contract.callContractById function. Happy Sorobaning!