DEV Community: darkvallen

Cross Contract Calls using AssemblyScript SDK

darkvallen — Fri, 31 Mar 2023 01:40:18 +0000

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:

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!

Account Authorization using Soroban AssemblyScript SDK

darkvallen — Thu, 30 Mar 2023 21:17:18 +0000

Hi! In my previous posts, i already covered many things such as storing data, logging contract, and defining error code. In this post I will take it to the next level, authorization. Authorization is one of security measure used in smart contracts, it can be used to various things such as allowing specific verified users to call a function, allowing specific users access stored data, and many more.

In this post i will explain Account authorization smart contract example that implements authorization control and updating account values stored in chain state.

The Contract Code

The contract code will be similar to my previous post with additional code to do account authorization. Let's dive into the code:

import {AddressObject, MapObject, RawVal, fromU32, toU32} from 'as-soroban-sdk/lib/value';
import {Map} from 'as-soroban-sdk/lib/map';
import * as ledger from 'as-soroban-sdk/lib/ledger';
import * as address from 'as-soroban-sdk/lib/address';

In this section, we import the necessary modules from the as-soroban-sdk library. The ledger module provides functions for interacting with the blockchain's storage. The RawVal, toU32, fromU32, AddressObject, and MapObject type is imported from the value module. Map imported from map module to act as stored data format. ledger and address module imported for any operation regarding ledger dan address operations.

export function increment(user: AddressObject, value: RawVal): MapObject {

  address.requireAuth(user);
  var counter = 0;

  if (ledger.hasData(user)) {
    let dataValue = ledger.getData(user);
    counter = toU32(dataValue);
  }

  counter += toU32(value);
  let counterVal = fromU32(counter);
  ledger.putData(user, counterVal);

  let map = new Map();
  map.put(user, counterVal);

  return map.getHostObject();
}

The purpose of this function is to increment a counter associated with a given user's address in the Soroban ledger. The address.requireAuth(user) call at the beginning of the function ensures that the user has authorized the transaction before it can proceed.

The next block of code checks whether the user already has data associated with their address in the ledger using the ledger.hasData(user) function. If the user has data, it retrieves the current value of the counter using ledger.getData(user) and converts it to a 32-bit unsigned integer using the toU32 function. If the user does not have data, the counter is initialized to zero.

The counter variable is then incremented by the value of value, which is also converted to a 32-bit unsigned integer using toU32. The updated value of counter is then converted back to a RawVal value using fromU32 and stored in the ledger using the ledger.putData(user, counterVal) function.

Finally, a new Map is created and the updated counter value is added to it using map.put(user, counterVal). The Map is then returned as a MapObjectusing map.getHostObject().

Next, create contract.json file in your project directory, this file contains metadata for the contract.

{
    "name": "Store and Retrieve Data Contract (Account Auth)",
    "version": "0.1.0",
    "description": "example",
    "host_functions_version": 29,
    "functions": [
        {
            "name" : "increment",
            "arguments": [
                {"name": "user", "type": "address"},
                {"name": "value", "type": "u32"}
            ],
            "returns" : "map[address, u32]"
        }
    ]
}

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.

Compiling the Contract

You need to compile it into WebAssembly first. To do this, you'll use the following command :

npx asc assembly/index.ts --target release

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

We will use 2 different account to invoke this contract.Let's run the contract to see if it's works, we're gonna run the contract using soroban-cli on sandbox using the following command :

soroban contract invoke \
    --account GABGWMODVCF3VQS5BYCJBWMJUIS466Q3WT3AKGZZAKLBW2NYHIWOEYQT \
    --id 1 \
    --wasm build/release.wasm \
    --fn increment \
    -- \
    --user GABGWMODVCF3VQS5BYCJBWMJUIS466Q3WT3AKGZZAKLBW2NYHIWOEYQT \
    --value 10

You can run it a couple of times with any desired --value. And invoke the function using another account :

soroban contract invoke \
    --account GBYXXOAIKZJHZKGR4W7ERYWLAJDEYIPQJNETH6FGFIJUUB4PBVPISTNL \
    --id 1 \
    --wasm build/release.wasm \
    --fn increment \
    -- \
    --user GBYXXOAIKZJHZKGR4W7ERYWLAJDEYIPQJNETH6FGFIJUUB4PBVPISTNL \
    --value 5

And after couple of times invoking the function with 2 different accounts, you can check all stored data on that contract using this command:

soroban contract read --id 1

You should get similar output to:

"""GABGWMODVCF3VQS5BYCJBWMJUIS466Q3WT3AKGZZAKLBW2NYHIWOEYQT""",15
"""GBYXXOAIKZJHZKGR4W7ERYWLAJDEYIPQJNETH6FGFIJUUB4PBVPISTNL""",25

Closing

Overall, this code provides a simple example of how Account Authorization works using the AssemblyScript SDK. By using the address.requireAuth and address.requireAuthForArgs functions, this code ensures that only authorized users can modify the counter associated with their address. Happy Sorobaning!

Defining Contract Error using Soroban Assembly Script SDK

darkvallen — Thu, 30 Mar 2023 10:39:52 +0000

Hi! in my previous post, i already illustrates how to use the Soroban AssemblyScript SDK to store and retrieve data in a simple smart contract, and now we will add error handler in that contract using Soroban Assembly Script SDK.

We will explore how to define and generate error for Soroban smart contract using AssemblyScript SDK, that allows contract caller to understand and handle the error. This example will showcase failWithErrorCode() function from context module provided by the as-soroban-sdk library.

The Contract Code

The contract code will be similar to my previous post with additional code to do error handling. Let's dive into the code:

import { RawVal, toU32, fromU32 } from "as-soroban-sdk/lib/value";
import * as ledger from "as-soroban-sdk/lib/ledger";
import * as context from "as-soroban-sdk/lib/context";

In this section, an additional modules added context module. These modules will give us functionality to define and handle error.

enum ERR_CODES {
  MAX_REACHED = 1
};

export function increment(): RawVal {

  let data = "COUNTER";
  var counter = 0;
  var max = 5;

  if (ledger.hasDataFor(data)) {
    let dataObj = ledger.getDataFor(data);
    counter = toU32(dataObj);
  }

  counter ++;

  if(counter > max) {
    context.failWithErrorCode(ERR_CODES.MAX_REACHED);
  }
  ledger.putDataFor(data, fromU32(counter));
  return ledger.getDataFor(data);
}

The code defines an ERR_CODES enum to represent possible error codes. It has a single error code: MAX_REACHED, indicating the counter has reached its maximum allowed value, and max variable is the maximum allowed value. increment function work similarly like the previous contract, check counter data in storage, increment it, and it checks if the new count is greater than the maximum allowed (set to 5). If so, it fails the transaction and returns an error code using the context.failWithErrorCode function. Otherwise, it updates the COUNTER data in the ledger with the new count value converted back to a RawVal with fromU32. It returns the final count value from the ledger.

Next, create contract.json file in your project directory, this file contains metadata for the contract.

{
    "name": "Store and Retrieve Data Contract (Error Handling)",
    "version": "0.1.0",
    "description": "example",
    "host_functions_version": 29,
    "functions": [
        {
            "name" : "increment",
            "arguments": [],
            "returns" : "u32"
        }
    ]
}

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.

Compiling the Contract

You need to compile it into WebAssembly first. To do this, you'll use the following command :

npx asc assembly/index.ts --target release

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

Running The Contract on Sandbox

Let's run the contract to see if it's works, we're gonna run the contract using soroban-cli on sandbox using the following command :

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

You should get the output:

Run it a couple of times, and in 6th run you will get this output:

error: HostError
Value: Status(ContractError(1))

Closing

This example demonstrates how to define and handle error on soroban smart contract using the Soroban AssemblyScript SDK. By knowing the exact error code, contract caller will know what's wrong with the contract or the invocation. With this foundation, you can move on to build more advanced and feature-rich smart contracts on the Soroban platform. Happy Sorobaning!

Logging Contract using Soroban AssemblyScript SDK

darkvallen — Thu, 30 Mar 2023 01:47:57 +0000

Hi! in my previous post, i already illustrates how to use the Soroban AssemblyScript SDK to store and retrieve data in a simple smart contract, and now we will dive into the realm of contract logging in a Soroban smart contract using Soroban Assembly Script SDK.

We will explore how to log a Soroban smart contract using AssemblyScript SDK. This example will showcase logFtm function from context module provided by the as-soroban-sdk library.

The Contract Code

The contract code will be similar to my previous post with additional code to do logging each time it is called. Let's dive into the code:

import {RawVal, fromU32, fromSymbolStr, toU32} from 'as-soroban-sdk/lib/value';
import * as ledger from "as-soroban-sdk/lib/ledger";
import {Vec} from 'as-soroban-sdk/lib/vec';
import * as context from 'as-soroban-sdk/lib/context';

In this section, two additional modules added vec and context module. These modules will give us functionality to do logging.

export function increment(): RawVal {

  let data = "COUNTER";
  var counter = 0;
  let args = new Vec();

  if (ledger.hasDataFor(data)) {
    let dataObj = ledger.getDataFor(data);
    counter = toU32(dataObj);
  }
  args.pushBack(fromU32(counter));
  counter ++;
  ledger.putDataFor(data, fromU32(counter));
  args.pushBack(fromU32(counter));
  context.logFtm("Before Increment = {} and After increment = {}", args);
  return ledger.getDataFor(data);

}

The increment function works exactly like the code before with additional args.pushBack() function to add logged arguments, and context.logFtm() to create the logs. A new Vec instance to store the log's arguments. Two arguments are added to to the Vec: counter value before increment and counter value after increment. Both are converted to their RawVal representation using the fromU32 function. The context.logFtm function called to print the before and after value log. Finally, the updated counter value is retrieved from the ledger and returned as the function's output.

Next, create contract.json file in your project directory, this file contains metadata for the contract.

{
    "name": "Store and Retrieve Data Contract (Logging)",
    "version": "0.1.0",
    "description": "example",
    "host_functions_version": 29,
    "functions": [
        {
            "name" : "increment",
            "arguments": [],
            "returns" : "u32"
        }
    ]
}

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.

Compiling the Contract

You need to compile it into WebAssembly first. To do this, you'll use the following command :

npx asc assembly/index.ts --target release

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

Running The Contract on Sandbox

Let's run the contract to see if it's works, we're gonna run the contract using soroban-cli on sandbox using the following command :

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

You should get the output:

1
#0: debug: Before Increment = U32(0) and After increment = U32(1)

Run it once more, you should get output:

2
#0: debug: Before Increment = U32(1) and After increment = U32(2)

Closing

This example demonstrates how to log a soroban smart contract using the Soroban AssemblyScript SDK. By leveraging the ledger, context, value, and vec modules, we can easily interact with the blockchain storage, manage data, and do logging. With this foundation, you can move on to build more advanced and feature-rich smart contracts on the Soroban platform. Happy Sorobaning!

Event-Driven Smart Contract using Soroban AssemblyScript SDK

darkvallen — Thu, 30 Mar 2023 00:48:42 +0000

Hi! in my previous post, i already illustrates how to use the Soroban AssemblyScript SDK to store and retrieve data in a simple smart contract, and now we will dive into the realm of contract events in a Soroban smart contract using Soroban Assembly Script SDK.

We will explore how to create an event-driven smart contract on the Soroban smart contract platform using AssemblyScript SDK. This example will showcase publishEvent function provided by the as-soroban-sdk library.

The Contract Code

The contract code will be similar to my previous post with additional code to emits an event each time it is called.Let's dive into the code:

import {RawVal, fromU32, fromSymbolStr, toU32} from 'as-soroban-sdk/lib/value';
import * as ledger from "as-soroban-sdk/lib/ledger";
import {Vec} from 'as-soroban-sdk/lib/vec';
import {publishEvent} from 'as-soroban-sdk/lib/context';

In this section, two additional modules added vec and context module. These modules will give us functionality to emits event.

export function increment(): RawVal {

  let data = "COUNTER";
  var counter = 0;
  if (ledger.hasDataFor(data)) {
    let dataObj = ledger.getDataFor(data);
    counter = toU32(dataObj);
  }
  counter ++;
  ledger.putDataFor(data, fromU32(counter));

  let topics = new Vec();
  topics.pushBack(fromSymbolStr(data));
  topics.pushBack(fromSymbolStr("increment"));
  publishEvent(topics, fromU32(counter));

  return ledger.getDataFor(data);

}

The increment function works exactly like the code before with additional topics.pushBack() function to add topics to the events, and publishEvent() function to publish the event. A new Vec instance to store the event's topics. Two topics are added to the Vec: the COUNTER data and an "increment" label. Both are converted to their RawVal representation using the fromSymbolStr function. The publishEvent function is then called with the topics and the updated counter value as arguments. Finally, the updated counter value is retrieved from the ledger and returned as the function's output.

Next, create contract.json file in your project directory, this file contains metadata for the contract.

{
    "name": "Store and Retrieve Data Contract (With Events)",
    "version": "0.1.0",
    "description": "example",
    "host_functions_version": 29,
    "functions": [
        {
            "name" : "increment",
            "arguments": [],
            "returns" : "u32"
        }
    ]
}

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.

Compiling the Contract

You need to compile it into WebAssembly first. To do this, you'll use the following command :

npx asc assembly/index.ts --target release

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

Running The Contract on Sandbox

Let's run the contract to see if it's works, we're gonna run the contract using soroban-cli on sandbox using the following command :

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

You should get the output:

1
#0: event: {"ext":"v0","contract_id":"0000000000000000000000000000000000000000000000000000000000000009","type_":"contract","body":{"v0":{"topics":[{"symbol":"COUNTER"},{"symbol":"increment"}],"data":{"u32":1}}}}

Run it once more, you should get output:

2
#0: event: {"ext":"v0","contract_id":"0000000000000000000000000000000000000000000000000000000000000009","type_":"contract","body":{"v0":{"topics":[{"symbol":"COUNTER"},{"symbol":"increment"}],"data":{"u32":2}}}}

Closing

This example demonstrates how to create an event-driven smart contract using the Soroban AssemblyScript SDK. By leveraging the ledger, context, value, and vec modules, we can easily interact with the blockchain storage, manage data, and publish events. With this foundation, you can move on to build more advanced and feature-rich smart contracts on the Soroban platform. Happy coding!

Storing and Retrieving Data using Soroban Assembly Script SDK

darkvallen — Wed, 29 Mar 2023 23:08:00 +0000

Hi! in my previous post, i already covered how to initialize an assembly script directory, install soroban assembly script SDK and write simple "Hello World" contract, and now we will dive into the realm of storing data in a Soroban smart contract using Soroban Assembly Script SDK.

We will explore a simple example that demonstrates how to store in a Soroban smart contract. This example will showcase key functions provided by the as-soroban-sdk library, such as getDataFor, hasDataFor, and putDataFor.

The Contract Code

Let's begin by examining the code block:

import { RawVal, toU32, fromU32 } from "as-soroban-sdk/lib/value";
import * as ledger from "as-soroban-sdk/lib/ledger";

export function increment(): RawVal {

  let data = "COUNTER";
  var counter = 0;
  if (ledger.hasDataFor(data)) {
    let dataObj = ledger.getDataFor(data);
    counter = toU32(dataObj);
  }
  counter ++;
  ledger.putDataFor(data, fromU32(counter));
  return ledger.getDataFor(data);

}

Next, increment()function will be our smart contract entry point. Inside, it will check if there is already data stored under the key "COUNTER" using ledger.hasDataFor(). If so, retrieve it using ledger.getDataFor() and convert it to a number using toU32(). Otherwise, initialize the counter to 0.

Then increment the counter and store the new value using ledger.putDataFor(), converting the number to a RawVal using fromU32(). Finally, return the updated counter value.

Next, create contract.json file in your project directory, this file contains metadata for the contract.

{
    "name": "Store and Retrieve Data Contract",
    "version": "0.1.0",
    "description": "example",
    "host_functions_version": 29,
    "functions": [
        {
            "name" : "increment",
            "arguments": [],
            "returns" : "u32"
        }
    ]
}

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.

Compiling the Contract

You need to compile it into WebAssembly first. To do this, you'll use the following command :

npx asc assembly/index.ts --target release

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

Running The Contract on Sandbox

Let's run the contract to see if it's works, we're gonna run the contract using soroban-cli on sandbox using the following command :

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

You should get the output:

Run it once more, you should get output:

Closing

This example illustrates how to use the Soroban AssemblyScript SDK to store and retrieve data in a simple smart contract. By utilizing the ledger and value modules, we can easily interact with the blockchain storage and retrieve data. With this foundation, you can move on to build more complex and feature-rich smart contracts on the Soroban platform. Happy coding!

Performing Atomic Swap using Soroban Python SDK

darkvallen — Tue, 28 Mar 2023 16:26:58 +0000

In my previous post, I showed you how to check token balance using the Soroban Python SDK. In this post, we'll use Soroban Python SDK to invoke atomic swap example contract. To know more about soroban atomic swap example contract, you can check this post written by yuzurush.

Preparation

The python script that we're going to use is soroban_auth_atomic_swap.py from Soroban Python SDK Examples Github Repository

We need 3 accounts:

An account to act as the transaction submitter
An account that wants to swap native tokens for CAT tokens (Alice)
An account that wants to swap CAT tokens for native tokens (Bob)

Transaction Submitter

Public Key  GAERW3OYAVYMZMPMVKHSCDS4ORFPLT5Z3YXA4VM3BVYEA2W7CG3V6YYB
Secret Key  SBPTTA3D3QYQ6E2GSACAZDUFH2UILBNG3EBJCK3NNP7BE4O757KGZUGA

Alice

Public Key  GDAT5HWTGIU4TSSZ4752OUC4SABDLTLZFRPZUJ3D6LKBNEPA7V2CIG54
Secret Key  SAAPYAPTTRZMCUZFPG3G66V4ZMHTK4TWA6NS7U4F7Z3IMUD52EK4DDEV

Public Key  GBMLPRFCZDZJPKUPHUSHCKA737GOZL7ERZLGGMJ6YGHBFJZ6ZKMKCZTM
Secret Key  SAEZSI6DY7AXJFIYA4PM6SIBNEYYXIEM2MSOTHFGKHDW32MBQ7KVO6EN

Checking Tokens Balance Before Swap

First, we will check both tokens (native & CAT) balance on both accounts (Alice & Bob). To check the balances you can read my post here. Here's both tokens balance on both accounts before swap:

Alice

Native Token (Lumen in `stroop`): 97999955005
CAT Token: 100000117450

GBMLPRFCZDZJPKUPHUSHCKA737GOZL7ERZLGGMJ6YGHBFJZ6ZKMKCZTM
Native Token (Lumen in `stroop`): 102000023295
CAT Token: 199999882550

Swapping The Tokens

To swap the tokens, open the soroban_auth_atomic_swap.py file and you can adjust some of following parameters:

submitter_kp = Keypair.from_secret(
    "SBPTTA3D3QYQ6E2GSACAZDUFH2UILBNG3EBJCK3NNP7BE4O757KGZUGA"
)  # GAERW3OYAVYMZMPMVKHSCDS4ORFPLT5Z3YXA4VM3BVYEA2W7CG3V6YYB
alice_kp = Keypair.from_secret(
    "SAAPYAPTTRZMCUZFPG3G66V4ZMHTK4TWA6NS7U4F7Z3IMUD52EK4DDEV"
)  # GDAT5HWTGIU4TSSZ4752OUC4SABDLTLZFRPZUJ3D6LKBNEPA7V2CIG54
bob_kp = Keypair.from_secret(
    "SAEZSI6DY7AXJFIYA4PM6SIBNEYYXIEM2MSOTHFGKHDW32MBQ7KVO6EN"
)  # GBMLPRFCZDZJPKUPHUSHCKA737GOZL7ERZLGGMJ6YGHBFJZ6ZKMKCZTM
atomic_swap_contract_id = (
    "828e7031194ec4fb9461d8283b448d3eaf5e36357cf465d8db6021ded6eff05c"
)
native_token_contract_id = (
    "d93f5c7bb0ebc4a9c8f727c5cebc4e41194d38257e1d0d910356b43bfc528813"
)
cat_token_contract_id = (
    "8dc97b166bd98c755b0e881ee9bd6d0b45e797ec73671f30e026f14a0f1cce67"
)

submitter_kp - Transaction Submitter Secret Key
alice_kp - Alice Secret Key
bob_kp - Bob Secret Key
atomic_swap_contract_id - Contract ID of Atomic Swap Contract
native_token_contract_id - Native Token's Contract ID
cat_token_contract_id - CAT Token's Contract ID

Note: You can use any accounts as long as they hold both tokens, you can deploy your own atomic swap contract and you can use any token pair (even your own deployed token).

    Int128(1000),  # amount_a
    Int128(4500),  # min_b_for_a
    Int128(5000),  # amount_b
    Int128(950),  # min_a_for_b

You can adjust amount and minimal amount swapped for the tokens, by adjusting these lines of code.

Save soroban_auth_atomic_swap.py file with your changes and then run the script in a command prompt using this command :

python soroban_auth_atomic_swap.py

If the transaction resulted successful, then the next step is to check balance of both token on both accounts.

Checking Tokens Balance After Swap

After checking balance both tokens on both accounts using the same way when we check before the swap, Here's both tokens balance on both accounts after swap:

Alice

Native Token (Lumen in `stroop`): 97999953855
CAT Token: 100000121950

After the Swap Alice's Native Token decreased by 1150 (950 from the swap, 200 for checking both token balances) and her CAT Token increased by 4500.

GBMLPRFCZDZJPKUPHUSHCKA737GOZL7ERZLGGMJ6YGHBFJZ6ZKMKCZTM
Native Token (Lumen in `stroop`): 102000024045
CAT Token: 199999878050

After the Swap Bob's Native Token increased by 750 (950 from the swap, decreased by 200 for checking both token balances) and his CAT Token decreased by 4500.

Note: The fee for checking token balances is 100 Lumens for one time.

So, the swap performed using minimum tokens amount.

Closing

In this blog post, we have gone over the steps to perform an atomic swap using the Soroban Python SDK. Cheers!

Checking Token Balance using Soroban Python SDK

darkvallen — Fri, 24 Mar 2023 22:12:14 +0000

In my Sending Payment using Soroban Python SDK blog post, I wrote how to check token balance using Soroban-CLI, after few hours i'm start to thinking "How to check token balance using Soroban SDK?" so after that i tried to write the script. So in this post, we'll use Soroban Python SDK to check token balance.

Preparation

First, create a Futurenet account, this account will be used to invoke balance function from the token contract using Soroban Python SDK. Create account at Stellar Laboratory and make sure to fund them. The account that i will be using :

Public Key  GATQFKA7BV7LYYE6UJ2LRL56W3BZRRSWTINA6TG2EM5CCDORFIERAKWV
Secret Key  SCHKLGAGY7QGWUKUFDGHEQMSCPFZNMLEHQE6Y6WPGYGHQIM23T3NJE3C

The file that we're gonna use :

check_token_balance.py - The python script to check the token balance.

Checking the Token Balance

To check the token balance, open the check_token_balance.py file and adjust the following parameters:

contract_id = "d93f5c7bb0ebc4a9c8f727c5cebc4e41194d38257e1d0d910356b43bfc528813"
tx_submitter_kp = Keypair.from_secret(
    "SCHKLGAGY7QGWUKUFDGHEQMSCPFZNMLEHQE6Y6WPGYGHQIM23T3NJE3C"
)

tx_submitter_kp: The secret key of the account whose balance you want to check. The contract ID that i'm using is native token contract(XLM Lumens)
contract_id: Token Contract ID of the token that you want to check.

Save the check_token_balance file with your changes.

Before running the script, i want to explain this specific codes :

func_name = "balance"
args = [Address(tx_submitter_kp.public_key)]

invocation = AuthorizedInvocation(
    contract_id=contract_id,
    function_name=func_name,
    args=args,
    sub_invocations=[],
)

contract_auth = ContractAuth(
    address=None,
    nonce=None,
    root_invocation=invocation,
)

source = soroban_server.load_account(tx_submitter_kp.public_key)
tx = (
    TransactionBuilder(source, network_passphrase)
    .add_time_bounds(0, 0)
    .append_invoke_contract_function_op(
        contract_id=contract_id,
        function_name=func_name,
        parameters=args,
        auth=[contract_auth],
    )
    .build()
)

From the script above the function of the token contract that we're going to invoke is balance function, for more info about Token contract functions check here. This script utilizing transaction invoker authorization to invoke the function.

Now we will run the script using this command :

python check_token_balance.py

We will get result:

Your token Balance: 99999999400

To cross-check it, we can use Stellar Laboratory`s explore endpoints tools.

Closing

In this blog post, we have gone over the steps to Check Token Balance using Soroban Python SDK. From the script you will get an insight how to check token balance using Soroban Python SDK.

Invoking An Auth Contract with Transaction Invoker Authorization using Soroban Python SDK

darkvallen — Fri, 24 Mar 2023 13:40:18 +0000

In my previous post, I showed you how to deploy and invoke an auth contract with stellar account authorization using Soroban Python SDK. In this post, we'll use Soroban Python SDK to invoke an auth contract with transaction invoker authorization. I will use auth contract that already deployed in previous post, so i dont need to deploy it again.

Preparation

First, create a Futurenet account, this account will be used to deploy the auth contract and invoke the contract using Soroban Python SDK. Create account at Stellar Laboratory and make sure to fund them. The account that i will be using :

Public Key  GATQFKA7BV7LYYE6UJ2LRL56W3BZRRSWTINA6TG2EM5CCDORFIERAKWV
Secret Key  SCHKLGAGY7QGWUKUFDGHEQMSCPFZNMLEHQE6Y6WPGYGHQIM23T3NJE3C

The files that we're gonna use :

soroban_auth_with_transaction_invoke.py - The python script to invoke the auth contract with transaction invoker authorization.

Invoking the Contract

To invoke the auth contract, open the soroban_auth_with_transaction_invoke.py file and adjust the following parameters:

contract_id = "af0aadafacc6bcb73b6ec9aeee03350ca0c6a3430e099d4b5dd371c6e07cc214"
tx_submitter_kp = Keypair.from_secret(
    "SCHKLGAGY7QGWUKUFDGHEQMSCPFZNMLEHQE6Y6WPGYGHQIM23T3NJE3C"
)

tx_submitter_kp: the secret key of the account you'll use to submit the transaction and invoke the function.
contract_id: the contract ID of the auth contract you want to invoke. Replace the value with the contract ID you received from deploying contract before.

Save the soroban_auth_with_transaction_invoke.py file with your changes.

Before running the script, i want to explain this specific codes :

func_name = "increment"
args = [Address(tx_submitter_kp.public_key), Uint32(10)]

invocation = AuthorizedInvocation(
    contract_id=contract_id,
    function_name=func_name,
    args=args,
    sub_invocations=[],
)

contract_auth = ContractAuth(
    address=None,
    nonce=None,
    root_invocation=invocation,
)

source = soroban_server.load_account(tx_submitter_kp.public_key)
tx = (
    TransactionBuilder(source, network_passphrase)
    .add_time_bounds(0, 0)
    .append_invoke_contract_function_op(
        contract_id=contract_id,
        function_name=func_name,
        parameters=args,
        auth=[contract_auth],
    )
    .build()
)

From the script above the function of the contract that we're going to invoke is increment function and It sets address and nonce to None in the ContractAuth. This is for transaction invoker authorization, where the transaction sender is the authorizer.

Now we will run the script using this command :

python soroban_auth_with_transaction_invoke.py

We will get result:

transaction result: <SCVal [type=1, u32=<Uint32 [uint32=10]>]>

Closing

In this blog post, we have gone over the steps to Deploy and Invoke Auth Contract with Transaction Invoker Authorization using Soroban Python SDK. From the script you will get an insight how basic Transaction Invoker Authorization implemented in Soroban Python SDK.

Deploying and Invoking An Auth Contract with Stellar Account Authorization using Soroban Python SDK

darkvallen — Fri, 24 Mar 2023 08:43:42 +0000

In my previous post, I showed you how to deploy a wrapped token contract using Soroban Python SDK. In this post, we'll use Soroban Python SDK to deploy and invoke an auth contract with stellar account authorization.

Preparation

Public Key  GATQFKA7BV7LYYE6UJ2LRL56W3BZRRSWTINA6TG2EM5CCDORFIERAKWV
Secret Key  SCHKLGAGY7QGWUKUFDGHEQMSCPFZNMLEHQE6Y6WPGYGHQIM23T3NJE3C

The files that we're gonna use :

soroban_auth_contract.wasm - The Auth Contract
soroban_deploy_contract.py - Python Script to Deploy the contract.
soroban_auth_with_stellar_account - Python script to invoke the auth contract with Stellar Account authorization.

Deploying The Contract

To deploy a contract, open the soroban_deploy_contract.py file and adjust the following parameters:

secret = "SCHKLGAGY7QGWUKUFDGHEQMSCPFZNMLEHQE6Y6WPGYGHQIM23T3NJE3C" #Put your Account Secret Key here
rpc_server_url = "https://horizon-futurenet.stellar.cash:443/soroban/rpc"
network_passphrase = Network.FUTURENET_NETWORK_PASSPHRASE
contract_file_path = "./soroban_auth_contract.wasm"

secret: the Secret Key of the Account that we're gonna use to deploy the auth contract. Replace the value with your own account secret key.
rpc_server_url: the URL of the RPC server you'll use to interact with the Soroban Futurenet network.
network_passphrase: the passphrase you'll use to select the network. This can be changed depending on the network you're interacting with; in this case, we'll use Futurenet.
contract_file_path: the path to the auth contract file.

Save the soroban_deploy_contract.py file with your changes and then run the script in a command prompt using this command:

python `soroban_deploy_contract.py`

Once the script has finished running, you'll receive a contract ID. Be sure to save this for later.

contract id: af0aadafacc6bcb73b6ec9aeee03350ca0c6a3430e099d4b5dd371c6e07cc214

Invoking the Contract

To invoke the auth contract, open the soroban_auth_with_stellar_account.py file and adjust the following parameters:

contract_id = "af0aadafacc6bcb73b6ec9aeee03350ca0c6a3430e099d4b5dd371c6e07cc214"
tx_submitter_kp = Keypair.from_secret(
    "SAAPYAPTTRZMCUZFPG3G66V4ZMHTK4TWA6NS7U4F7Z3IMUD52EK4DDEV"
)
# If tx_submitter_kp and op_invoker_kp use the same account, the submission will fail, a bug?
op_invoker_kp = Keypair.from_secret(
    "SCHKLGAGY7QGWUKUFDGHEQMSCPFZNMLEHQE6Y6WPGYGHQIM23T3NJE3C"
)

tx_submitter_kp: the secret key of the account you'll use to submit the transaction.
op_invoker_kp: the secret key of the account you'll use to invoke the contract function. Replace the value with your own account secret key.
contract_id: the contract ID of the auth contract you want to invoke. Replace the value with the contract ID you received from deploying contract before.

Save the soroban_auth_with_account file with your changes. Note : somehow using the same keypair for tx_submitter_kp and op_invoker_kp makes the transaction failed to be sumbited, maybe this is a bug. If it is a bug, this is expected since Soroban is still in development.

Before running the script, i want to explain this specific codes :

nonce = soroban_server.get_nonce(contract_id, op_invoker_kp.public_key)
func_name = "increment"
args = [Address(op_invoker_kp.public_key), Uint32(10)]

invocation = AuthorizedInvocation(
    contract_id=contract_id,
    function_name=func_name,
    args=args,
    sub_invocations=[],
)

contract_auth = ContractAuth(
    address=Address(op_invoker_kp.public_key),
    nonce=nonce,
    root_invocation=invocation,
)

contract_auth.sign(op_invoker_kp, network_passphrase)

From the script above the function of the contract that we're going to invoke is increment function with Stellar Account keypair as the argument, and uses it to get a nonce and set the address and sign the ContractAuth. This is for account authorization, where a specific account address authorizes the invocation.

Now we will run the script using this command :

python soroban_auth_with_account.py

We will get result:

transaction result: <SCVal [type=1, u32=<Uint32 [uint32=10]>]>

run the script once more, we will get result :

transaction result: <SCVal [type=1, u32=<Uint32 [uint32=20]>]>

The increment function that we called worked as intended.

Closing

In this blog post, we have gone over the steps to Deploy and Invoke Auth Contract with Account Authorization using Soroban Python SDK. From the script you will get an insight how basic Soroban Account Authorization implemented in Soroban Python SDK.

Deploying a Wrapped Token Contract using Soroban Python SDK

darkvallen — Thu, 23 Mar 2023 15:53:04 +0000

In my previous post, I showed you how to send payment using Soroban Python SDK. In this post, we'll use Soroban Python SDK to deploy a wrapped token contract.

Preparation

First, create a Futurenet account, this account will be used to deploy and act as an admin of the token contract. Create account at Stellar Laboratory and make sure to fund them. The account that i will be using :

Public Key  GATQFKA7BV7LYYE6UJ2LRL56W3BZRRSWTINA6TG2EM5CCDORFIERAKWV
Secret Key  SCHKLGAGY7QGWUKUFDGHEQMSCPFZNMLEHQE6Y6WPGYGHQIM23T3NJE3C

Then, the python script that we're going to use is soroban_deploy_create_wrapped_token_contract.py from Soroban Python SDK Examples Github Repository. These examples written by overcat, the maintainer of Soroban Python SDK.

Deploying the Wrapped Token Contract

To deploy the contract, open the soroban_deploy_create_wrapped_token_contract.py file and you can adjust some of following parameters:

secret = "SCHKLGAGY7QGWUKUFDGHEQMSCPFZNMLEHQE6Y6WPGYGHQIM23T3NJE3C"
rpc_server_url = "https://horizon-futurenet.stellar.cash:443/soroban/rpc"
network_passphrase = Network.FUTURENET_NETWORK_PASSPHRASE
hello_asset = Asset("HELLO", "GATQFKA7BV7LYYE6UJ2LRL56W3BZRRSWTINA6TG2EM5CCDORFIERAKWV")

secret - Secret key for deploying contract
rpc_server_url - RPC Server URL used to deploy the contract
network_passphrase - Futurenet Network Passphrase
hello_asset - Symbol of the asset and Account Public Key for Asset Issuer(admin)

Save the soroban_deploy_create_wrapped_token_contract.py file with your changes and then run the script in a command prompt using this command :

python soroban_deploy_create_wrapped_token_contract.py

Result :

$ python soroban_deploy_create_wrapped_token_contract.py
simulated transaction: error=None results=[SimulateTransactionResult(auth=None, footprint='AAAAAAAAAAMAAAAGrAPyVAexHS7Lfq1Dh8TlMLNLMSrdfI/FPXD9Brh90u8AAAADAAAAAwAAAAasA/JUB7EdLst+rUOHxOUws0sxKt18j8U9cP0GuH3S7wAAAAQAAAABAAAAAAAAAAEAAAAFAAAABUFkbWluAAAAAAAABqwD8lQHsR0uy36tQ4fE5TCzSzEq3XyPxT1w/Qa4fdLvAAAABAAAAAEAAAAAAAAAAQAAAAUAAAAITWV0YWRhdGE=', xdr='AAAABAAAAAEAAAAGAAAAIKwD8lQHsR0uy36tQ4fE5TCzSzEq3XyPxT1w/Qa4fdLv')] cost=SimulateTransactionCost(cpu_insns=110198, mem_bytes=6463) latest_ledger=572498
setting footprint and signing transaction...
sent transaction: id='eaf6b55ae79ae6202aaff6eecbd9f69b017608ff73a719c89e8929def19ddddd' status=<TransactionStatus.PENDING: 'pending'> error=None
waiting for transaction to be confirmed...
waiting for transaction to be confirmed...
waiting for transaction to be confirmed...
transaction status: id='eaf6b55ae79ae6202aaff6eecbd9f69b017608ff73a719c89e8929def19ddddd' status=<TransactionStatus.SUCCESS: 'success'> envelope_xdr='AAAAAgAAAABtb05lTpeOTUrHyRo/keRPQ+/Rp4LYwgi2VXWHWl4XYAAAAGQACLppAAAABQAAAAEAAAAAAAAAAAAAAABkHHKJAAAAAAAAAAEAAAABAAAAAG1vTmVOl45NSsfJGj+R5E9D79GngtjCCLZVdYdaXhdgAAAAGAAAAAEAAAACAAAAAkhFTExPAAAAAAAAAAAAAABtb05lTpeOTUrHyRo/keRPQ+/Rp4LYwgi2VXWHWl4XYAAAAAEAAAAAAAAAAwAAAAasA/JUB7EdLst+rUOHxOUws0sxKt18j8U9cP0GuH3S7wAAAAMAAAADAAAABqwD8lQHsR0uy36tQ4fE5TCzSzEq3XyPxT1w/Qa4fdLvAAAABAAAAAEAAAAAAAAAAQAAAAUAAAAFQWRtaW4AAAAAAAAGrAPyVAexHS7Lfq1Dh8TlMLNLMSrdfI/FPXD9Brh90u8AAAAEAAAAAQAAAAAAAAABAAAABQAAAAhNZXRhZGF0YQAAAAAAAAAAAAAAAVpeF2AAAABAdx8pRxv6iGWD0ma0uuFV3oKebeDuaC7j80frOO7vKDwP49aWa2sFKVJ2fjph3Xj52lgSs/mNycYXJeSI8OSAAQ==' result_xdr='AAAAAAAAAGQAAAAAAAAAAQAAAAAAAAAYAAAAAAAAAAQAAAABAAAABgAAACCsA/JUB7EdLst+rUOHxOUws0sxKt18j8U9cP0GuH3S7wAAAAA=' result_meta_xdr='AAAAAwAAAAIAAAADAAi8UwAAAAAAAAAAbW9OZU6Xjk1Kx8kaP5HkT0Pv0aeC2MIItlV1h1peF2AAAAAXSHbmDAAIumkAAAAEAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAwAAAAAACLxPAAAAAGQccUwAAAAAAAAAAQAIvFMAAAAAAAAAAG1vTmVOl45NSsfJGj+R5E9D79GngtjCCLZVdYdaXhdgAAAAF0h25gwACLppAAAABQAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAMAAAAAAAi8UwAAAABkHHFhAAAAAAAAAAEAAAADAAAAAAAIvFMAAAAGrAPyVAexHS7Lfq1Dh8TlMLNLMSrdfI/FPXD9Brh90u8AAAADAAAAAwAAAAQAAAABAAAABwAAAAEAAAAAAAAAAAAIvFMAAAAGrAPyVAexHS7Lfq1Dh8TlMLNLMSrdfI/FPXD9Brh90u8AAAAEAAAAAQAAAAAAAAABAAAABQAAAAVBZG1pbgAAAAAAAAQAAAABAAAACAAAAAAAAAAAbW9OZU6Xjk1Kx8kaP5HkT0Pv0aeC2MIItlV1h1peF2AAAAAAAAAAAAAIvFMAAAAGrAPyVAexHS7Lfq1Dh8TlMLNLMSrdfI/FPXD9Brh90u8AAAAEAAAAAQAAAAAAAAABAAAABQAAAAhNZXRhZGF0YQAAAAQAAAABAAAAAAAAAAIAAAAFAAAACkFscGhhTnVtMTIAAAAAAAQAAAABAAAAAQAAAAIAAAAFAAAACmFzc2V0X2NvZGUAAAAAAAQAAAABAAAABgAAAAxIRUxMTwAAAAAAAAAAAAAFAAAABmlzc3VlcgAAAAAABAAAAAEAAAAGAAAAIG1vTmVOl45NSsfJGj+R5E9D79GngtjCCLZVdYdaXhdgAAAAAAAAAAAAAAABAAAAAAAAAAAAAABkAAAAAAAAAAEAAAAAAAAAGAAAAAAAAAAEAAAAAQAAAAYAAAAgrAPyVAexHS7Lfq1Dh8TlMLNLMSrdfI/FPXD9Brh90u8AAAAA02fs2dDFBdR8GlynM9VeTwbQ7ckYHpu6eEGF9i75+6LLvEh1Deu4U1CTs96viKx/TP+HQlV2pY3iusdUrNtGFiH5L17VhmgoiSxLNEvY5WWYvlN1y13OW61N4hIpVn6q' results=[SCVal(xdr='AAAABAAAAAEAAAAGAAAAIKwD8lQHsR0uy36tQ4fE5TCzSzEq3XyPxT1w/Qa4fdLv')] error=None
contract id: ac03f25407b11d2ecb7ead4387c4e530b34b312add7c8fc53d70fd06b87dd2ef

From the result above we get a contract id of our deployed token contract which is ac03f25407b11d2ecb7ead4387c4e530b34b312add7c8fc53d70fd06b87dd2ef.

From the contract id, admin can do various token operation such as mint, burn, set admin, and more. For more information of token operations, you can check here.

Now, we will check symbol of our token-wrapped contract using the Soroban CLI. We will use this command :

$ soroban contract invoke --id ac03f25407b11d2ecb7ead4387c4e530b34b312add7c8fc53d70fd06b87dd2ef --secret-key SAM7O4V6QBSBQPM64IWSTCUOGN34QK6VI4RGWZERNE2OBXHVRCH2VU2V --fn symbol
success
"48454c4c4f"

From the returned value, we get 48454c4c4f, is in hex. When converted to a string, it becomes "HELLO".

Closing

In this blog post, we have gone over the steps to Deploy a Wrapped Token Contract using Soroban Python SDK. You can try to deploy your own token, and try other token operation such as mint, burn, and more using Soroban-CLI.

Sending Payment using Soroban Python SDK

darkvallen — Thu, 23 Mar 2023 07:03:51 +0000

In my previous post, I showed you how to Deploying and Invoking Soroban Smart Contract using Soroban Python SDK. In this post, we'll use Soroban Python SDK to send payment from an account to another account.

Preparation

First, create 2 Futurenet account, one act as the sender, and the other one acts as the receipient. Create accounts at Stellar Laboratory and make sure to fund them.

The accounts that i will be using in this guide:

Sender Account :

Public Key: GDVHH3WBEXOBQMK3FLIWTCRQTC3RQFG7JJXI65IVIJYCU6LXFHPB4MHN
Secret Key: SD45JGK4S6NCORR6GK66BBRDWNDU322ZT5RQK6RT6D2T7HNFYK3M63DS

Receipient Account :

Public Key: GAZK3F5U26FIRD6RHMH34LT7N6I4BYCV4K3LBMVPFCMIYSAHLHCPV3EL
Secret Key: SANHLH2IOJMJIHE7XA6VG64GOIQRWDVXD4A77LDW2JAAWHOAZMRVBM3S

Then, the python script that we're going to use is soroban_payment.py from Soroban Python SDK Examples Github Repository. These examples written by overcat, the maintainer of Soroban Python SDK.

Sending Payment

To send a contract, open the soroban_payment.py file and you can adjust the following parameters:

alice_kp = Keypair.from_secret(
    "SD45JGK4S6NCORR6GK66BBRDWNDU322ZT5RQK6RT6D2T7HNFYK3M63DS"
)  # GDVHH3WBEXOBQMK3FLIWTCRQTC3RQFG7JJXI65IVIJYCU6LXFHPB4MHN
bob_kp = Keypair.from_secret(
    "SANHLH2IOJMJIHE7XA6VG64GOIQRWDVXD4A77LDW2JAAWHOAZMRVBM3S"
)  # GAZK3F5U26FIRD6RHMH34LT7N6I4BYCV4K3LBMVPFCMIYSAHLHCPV3EL
native_token_contract_id = (
    "d93f5c7bb0ebc4a9c8f727c5cebc4e41194d38257e1d0d910356b43bfc528813"
)

alice_kp- Sender Secret Key
bob_kp - Receipient Secret Key
native_token_contract_id - Native token contract id. You can adjust this depends on what asset that you want to send.

    Int128(1000 * 10**7),  # amount, 1000 XLM

You can adjust this line to adjust amount of the asset that you want to send. Note that the amount is in stroops, and a stroop is a 10 millionth of a Lumen.

Quick brief for the changes that i made before :

Sender Account : GDVHH3WBEXOBQMK3FLIWTCRQTC3RQFG7JJXI65IVIJYCU6LXFHPB4MHN
Receipient Account : GAZK3F5U26FIRD6RHMH34LT7N6I4BYCV4K3LBMVPFCMIYSAHLHCPV3EL
Native Token amount : 1000 XLM (1000.0000000 in stroop)

Save the soroban_payment.py file with your changes.

Before running the script, we will check native token balance of each account using Soroban-CLI .

Account 1:

$ soroban contract invoke --id d93f5c7bb0ebc4a9c8f727c5cebc4e41194d38257e1d0d910356b43bfc528813 --secret-key SD45JGK4S6NCORR6GK66BBRDWNDU322ZT5RQK6RT6D2T7HNFYK3M63DS --fn balance -- --id GDVHH3WBEXOBQMK3FLIWTCRQTC3RQFG7JJXI65IVIJYCU6LXFHPB4MHN
success
"99999999900"

Account 2:

soroban contract invoke --id d93f5c7bb0ebc4a9c8f727c5cebc4e41194d38257e1d0d910356b43bfc528813 --secret-key SANHLH2IOJMJIHE7XA6VG64GOIQRWDVXD4A77LDW2JAAWHOAZMRVBM3S --fn balance -- --id GAZK3F5U26FIRD6RHMH34LT7N6I4BYCV4K3LBMVPFCMIYSAHLHCPV3EL
success
"99999999900"

So both account native token balance now is "99999999900" in stroop.

Then we will send the payment, to send the payment run the script using this command :

python soroban_payment.py

Output :

$ python soroban_payment.py 
simulated transaction: error=None results=[SimulateTransactionResult(auth=['AAAAANk/XHuw68SpyPcnxc68TkEZTTglfh0NkQNWtDv8UogTAAAABHhmZXIAAAADAAAABAAAAAEAAAAIAAAAAAAAAADqc+7BJdwYMVsq0WmKMJi3GBTfSm6PdRVCcCp5dyneHgAAAAQAAAABAAAACAAAAAAAAAAAMq2XtNeKiI/ROw++Ln9vkcDgVeK2sLKvKJiMSAdZxPoAAAAEAAAAAQAAAAUAAAACVAvkAAAAAAAAAAAAAAAAAAAAAAA='], footprint='AAAAAgAAAAbZP1x7sOvEqcj3J8XOvE5BGU04JX4dDZEDVrQ7/FKIEwAAAAMAAAADAAAABtk/XHuw68SpyPcnxc68TkEZTTglfh0NkQNWtDv8UogTAAAABAAAAAEAAAAAAAAAAQAAAAUAAAAITWV0YWRhdGEAAAACAAAAAAAAAAAyrZe014qIj9E7D74uf2+RwOBV4rawsq8omIxIB1nE+gAAAAAAAAAA6nPuwSXcGDFbKtFpijCYtxgU30puj3UVQnAqeXcp3h4=', xdr='AAAAAwAAAAA=')] cost=SimulateTransactionCost(cpu_insns=145027, mem_bytes=7805) latest_ledger=566548
setting footprint and signing transaction...
Signed XDR:
AAAAAgAAAADqc+7BJdwYMVsq0WmKMJi3GBTfSm6PdRVCcCp5dyneHgAAAGQACKKAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAGAAAAAAAAAAFAAAABAAAAAEAAAAGAAAAINk/XHuw68SpyPcnxc68TkEZTTglfh0NkQNWtDv8UogTAAAABQAAAAR4ZmVyAAAABAAAAAEAAAAIAAAAAAAAAADqc+7BJdwYMVsq0WmKMJi3GBTfSm6PdRVCcCp5dyneHgAAAAQAAAABAAAACAAAAAAAAAAAMq2XtNeKiI/ROw++Ln9vkcDgVeK2sLKvKJiMSAdZxPoAAAAEAAAAAQAAAAUAAAACVAvkAAAAAAAAAAAAAAAAAgAAAAbZP1x7sOvEqcj3J8XOvE5BGU04JX4dDZEDVrQ7/FKIEwAAAAMAAAADAAAABtk/XHuw68SpyPcnxc68TkEZTTglfh0NkQNWtDv8UogTAAAABAAAAAEAAAAAAAAAAQAAAAUAAAAITWV0YWRhdGEAAAACAAAAAAAAAAAyrZe014qIj9E7D74uf2+RwOBV4rawsq8omIxIB1nE+gAAAAAAAAAA6nPuwSXcGDFbKtFpijCYtxgU30puj3UVQnAqeXcp3h4AAAABAAAAANk/XHuw68SpyPcnxc68TkEZTTglfh0NkQNWtDv8UogTAAAABHhmZXIAAAADAAAABAAAAAEAAAAIAAAAAAAAAADqc+7BJdwYMVsq0WmKMJi3GBTfSm6PdRVCcCp5dyneHgAAAAQAAAABAAAACAAAAAAAAAAAMq2XtNeKiI/ROw++Ln9vkcDgVeK2sLKvKJiMSAdZxPoAAAAEAAAAAQAAAAUAAAACVAvkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXcp3h4AAABAimiMyJxLhDdPb25fNl+bKfkkI8RD0ychZkUgVgPwheLVkCE6bw71To868CLD4KJr8ebUE1ZNOut03MLZ6jPFAg==
sent transaction: id='57dd82dc6e43c8d7b311520786e36166db0ab4a5527501293ce29d4dd012d1b4' status=<TransactionStatus.PENDING: 'pending'> error=None
waiting for transaction to be confirmed...
waiting for transaction to be confirmed...
waiting for transaction to be confirmed...
transaction status: id='57dd82dc6e43c8d7b311520786e36166db0ab4a5527501293ce29d4dd012d1b4' status=<TransactionStatus.SUCCESS: 'success'> envelope_xdr='AAAAAgAAAADqc+7BJdwYMVsq0WmKMJi3GBTfSm6PdRVCcCp5dyneHgAAAGQACKKAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAGAAAAAAAAAAFAAAABAAAAAEAAAAGAAAAINk/XHuw68SpyPcnxc68TkEZTTglfh0NkQNWtDv8UogTAAAABQAAAAR4ZmVyAAAABAAAAAEAAAAIAAAAAAAAAADqc+7BJdwYMVsq0WmKMJi3GBTfSm6PdRVCcCp5dyneHgAAAAQAAAABAAAACAAAAAAAAAAAMq2XtNeKiI/ROw++Ln9vkcDgVeK2sLKvKJiMSAdZxPoAAAAEAAAAAQAAAAUAAAACVAvkAAAAAAAAAAAAAAAAAgAAAAbZP1x7sOvEqcj3J8XOvE5BGU04JX4dDZEDVrQ7/FKIEwAAAAMAAAADAAAABtk/XHuw68SpyPcnxc68TkEZTTglfh0NkQNWtDv8UogTAAAABAAAAAEAAAAAAAAAAQAAAAUAAAAITWV0YWRhdGEAAAACAAAAAAAAAAAyrZe014qIj9E7D74uf2+RwOBV4rawsq8omIxIB1nE+gAAAAAAAAAA6nPuwSXcGDFbKtFpijCYtxgU30puj3UVQnAqeXcp3h4AAAABAAAAANk/XHuw68SpyPcnxc68TkEZTTglfh0NkQNWtDv8UogTAAAABHhmZXIAAAADAAAABAAAAAEAAAAIAAAAAAAAAADqc+7BJdwYMVsq0WmKMJi3GBTfSm6PdRVCcCp5dyneHgAAAAQAAAABAAAACAAAAAAAAAAAMq2XtNeKiI/ROw++Ln9vkcDgVeK2sLKvKJiMSAdZxPoAAAAEAAAAAQAAAAUAAAACVAvkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXcp3h4AAABAimiMyJxLhDdPb25fNl+bKfkkI8RD0ychZkUgVgPwheLVkCE6bw71To868CLD4KJr8ebUE1ZNOut03MLZ6jPFAg==' result_xdr='AAAAAAAAAGQAAAAAAAAAAQAAAAAAAAAYAAAAAAAAAAMAAAAAAAAAAA==' result_meta_xdr='AAAAAwAAAAIAAAADAAilFQAAAAAAAAAA6nPuwSXcGDFbKtFpijCYtxgU30puj3UVQnAqeXcp3h4AAAAXSHbnOAAIooAAAAABAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAwAAAAAACKR9AAAAAGQb8/wAAAAAAAAAAQAIpRUAAAAAAAAAAOpz7sEl3BgxWyrRaYowmLcYFN9Kbo91FUJwKnl3Kd4eAAAAF0h25zgACKKAAAAAAgAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAMAAAAAAAilFQAAAABkG/cfAAAAAAAAAAEAAAAEAAAAAwAIpH8AAAAAAAAAADKtl7TXioiP0TsPvi5/b5HA4FXitrCyryiYjEgHWcT6AAAAF0h255wACKKzAAAAAQAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAMAAAAAAAikfwAAAABkG/QHAAAAAAAAAAEACKUVAAAAAAAAAAAyrZe014qIj9E7D74uf2+RwOBV4rawsq8omIxIB1nE+gAAABmcgsucAAiiswAAAAEAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAADAAAAAAAIpH8AAAAAZBv0BwAAAAAAAAADAAilFQAAAAAAAAAA6nPuwSXcGDFbKtFpijCYtxgU30puj3UVQnAqeXcp3h4AAAAXSHbnOAAIooAAAAACAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAwAAAAAACKUVAAAAAGQb9x8AAAAAAAAAAQAIpRUAAAAAAAAAAOpz7sEl3BgxWyrRaYowmLcYFN9Kbo91FUJwKnl3Kd4eAAAAFPRrAzgACKKAAAAAAgAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAMAAAAAAAilFQAAAABkG/cfAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAB2T9ce7DrxKnI9yfFzrxOQRlNOCV+HQ2RA1a0O/xSiBMAAAABAAAAAAAAAAMAAAAFAAAACHRyYW5zZmVyAAAABAAAAAEAAAAIAAAAAAAAAADqc+7BJdwYMVsq0WmKMJi3GBTfSm6PdRVCcCp5dyneHgAAAAQAAAABAAAACAAAAAAAAAAAMq2XtNeKiI/ROw++Ln9vkcDgVeK2sLKvKJiMSAdZxPoAAAAEAAAAAQAAAAUAAAACVAvkAAAAAAAAAAAAAAAAAAAAAGQAAAAAAAAAAQAAAAAAAAAYAAAAAAAAAAMAAAAAAAAAAPejOvigTHFs10VgYF7dqNoGlLeGkdjW4rEN4y5/XBZ7G5FOWbTC6I0AebcVUsKYFFB6ixX9jAQ6NqpHwVSltsMzhhDHHyug9wgX+sGGnfU5/niQQOWCkHZShBN5TwmwBA==' results=[SCVal(xdr='AAAAAwAAAAA=')] error=None
transaction result: <SCVal [type=3, ic=0]>

From above we can see that transaction is success. Let's check the balance of both account again using the same command before.

Sender Account:

$ soroban contract invoke --id d93f5c7bb0ebc4a9c8f727c5cebc4e41194d38257e1d0d910356b43bfc528813 --secret-key SD45JGK4S6NCORR6GK66BBRDWNDU322ZT5RQK6RT6D2T7HNFYK3M63DS --fn balance -- --id GDVHH3WBEXOBQMK3FLIWTCRQTC3RQFG7JJXI65IVIJYCU6LXFHPB4MHN

success
"89999999700"

Receipient:

$ soroban contract invoke --id d93f5c7bb0ebc4a9c8f727c5cebc4e41194d38257e1d0d910356b43bfc528813 --secret-key SANHLH2IOJMJIHE7XA6VG64GOIQRWDVXD4A77LDW2JAAWHOAZMRVBM3S --fn balance -- --id GAZK3F5U26FIRD6RHMH34LT7N6I4BYCV4K3LBMVPFCMIYSAHLHCPV3EL

success
"109999999800"

From the results above we can see 1000XLM(10000000000 in stroop) from Sender Account has been sent to Receipient Account.

Closing

In this blog post, we have gone over the steps to Send Payment using Soroban Python SDK. You can send your own payments modifying the scripts.