Web React

package.json

{
  "name": "my-react-app",
  "dependencies": {
    // This path is relative
    "casper-rust-wasm-sdk": "file:pkg", // [TODO] Npm package
    ...
}
Copy

The React app needs to load the Wasm file through a dedicated init() method as per this example:

App.tsx

import init, {
  SDK,
  Verbosity,
} from 'casper-rust-wasm-sdk';

const rpc_address = 'https://node.testnet.casper.networko';
const verbosity = Verbosity.High;

function App() {
  const [wasm, setWasm] = useState(false);
  const fetchWasm = async () => {
    await init();
    setWasm(true);
  };

  useEffect(() => {
    initApp(); // take care here to initiate app only once and not on every effect
  }, []);

  const initApp = async () => {
  if (!wasm) {
    await fetchWasm();
  };

  const sdk = new SDK(rpc_address, verbosity);
  console.log(sdk);
  ...
}
Copy

Frontend React example

You can look at a very basic example of usage in the React example app.

$ cd ./examples/frontend/react
$ npm install
$ npm start
Copy

Web Angular

The full in-repo Angular example is the Casper WebClient. Try the hosted build at https://casper-webclient.interchouette.net/, or run it locally from examples/frontend/angular.

package.json

{
  "name": "my-angular-app",
  "dependencies": {
    // This path is relative
    "casper-rust-wasm-sdk": "file:pkg", // [TODO] Npm package
    ...
}
Copy

The Angular app needs to load the Wasm file through a dedicated init() method as per this example. You can import it into a component through a service but it is advised to import it through a factory with the injection token APP_INITIALIZER.

wasm.factory.ts

import init, { SDK, Verbosity } from 'casper-rust-wasm-sdk';

export const SDK_TOKEN = new InjectionToken() < SDK > 'SDK';
export const WASM_ASSET_PATH =
  new InjectionToken() < string > 'wasm_asset_path';
export const RPC_ADDRESS = new InjectionToken() < string > 'rpc_address';
export const VERBOSITY = new InjectionToken() < Verbosity > 'verbosity';

type Params = {
  wasm_asset_path: string,
  rpc_address: string,
  verbosity: Verbosity,
};

export const fetchWasmFactory = async (params: Params): Promise<SDK> => {
  const wasm = await init(params.wasm_asset_path);
  return new SDK(params.rpc_address, params.verbosity);
};
Copy

wasm.module.ts

import { NgModule } from "@angular/core";
import { CommonModule } from "@angular/common";
import { SDK_TOKEN, fetchWasmFactory, provideSafeAsync } from "./wasm.factory";

const providers = provideSafeAsync(SDK_TOKEN, fetchWasmFactory);

@NgModule({
  imports: [CommonModule],
  providers,
})
export class WasmModule {}
Copy

You can look at a basic example of factory usage in the Angular example app.

Add the SDK Wasm file to the assets of your project with the path parameter being wasm_asset_path:'assets/casper_rust_wasm_sdk_bg.wasm'. Angular copies it into assets on build for the fetch Wasm factory. From Angular 21.2 the asset input must stay inside the workspace root, so point at the installed package (for example file:../../../pkg → node_modules/casper-rust-wasm-sdk), not at ../../../pkg directly.

project.json

"assets": [
  ...,
  {
    "input": "node_modules/casper-rust-wasm-sdk",
    "glob": "casper_rust_wasm_sdk_bg.wasm",
    "output": "assets"
  }
]
Copy

Frontend Angular example

Try the hosted Casper WebClient, or look at a more advanced example of usage in the Angular example app.

$ cd ./examples/frontend/angular
$ npm install
$ npm start
$ npm build
Copy

Desktop Node

package.json

{
  "name": "my-node-app",
  "dependencies": {
    // This path is relative
    "casper-rust-wasm-sdk": "file:pkg-nodejs", // [TODO] Npm package
    ...
}
Copy

The Node app loads the SDK with require(). You can find more details about building the SDK for Node with wasm-pack. Note that this method requires a version of Node.js with WebAssembly support, which is currently Node 8 and above.

index.ts

// with require
const casper_sdk = require("casper-rust-wasm-sdk");
const { SDK } = casper_sdk;

// or with import
import { SDK } from "casper-rust-wasm-sdk";

const rpc_address = "https://node.testnet.casper.network";
const sdk = new SDK(rpc_address);
console.log(sdk);
Copy

Desktop Node example

You can look at a very basic example of usage in the Node example app.

$ cd ./examples/desktop/node
$ npm install
$ npm start
Copy

Rust

use casper_rust_wasm_sdk::types::transaction_params::transaction_str_params::TransactionStrParams;

pub const CHAIN_NAME: &str = "integration-test";
pub const PUBLIC_KEY: &str =
    "0169d8d607f3ba04c578140398ceb1bd5296c653f965256bd7097982b9026c5129";
pub const PAYMENT_AMOUNT: &str = "100000000";
pub const TRANSFER_AMOUNT: &str = "2500000000";
pub const TTL: &str = "1h";
pub const TARGET_ACCOUNT: &str =
    "01868e06026ba9c8695f6f3bb10d44782004dbc144ff65017cf484436f9cf7b0f6";

let transaction_params = TransactionStrParams::default();
transaction_params.set_chain_name(CHAIN_NAME);
transaction_params.set_initiator_addr(PUBLIC_KEY);
transaction_params.set_ttl(Some(TTL.to_string()));
transaction_params.set_payment_amount(PAYMENT_AMOUNT);

let make_transfer_transaction = sdk
    .make_transfer_transaction(
        None, // optional maybe_source
        TARGET_ACCOUNT,
        TRANSFER_AMOUNT,
        transaction_params,
        None, // optional transfer_id
    )
    .unwrap();
println!("{:?}", make_transfer_transaction.timestamp());
Copy

Typescript

import { TransactionStrParams } from "casper-rust-wasm-sdk";

const chain_name = "integration-test";
const public_key =
  "0169d8d607f3ba04c578140398ceb1bd5296c653f965256bd7097982b9026c5129";
const secret_key = undefined;
const timestamp = getTimestamp(); // or Date.now().toString(); // or undefined
const ttl = "1h"; // or undefined
const payment_amount = "100000000";
const transfer_amount = "2500000000";
const target_account =
  "0187adb3e0f60a983ecc2ddb48d32b3deaa09388ad3bc41e14aeb19959ecc60b54";

const transaction_params = new TransactionStrParams(
  chain_name,
  public_key,
  secret_key,
  timestamp,
  ttl,
);

transaction_params.payment_amount = payment_amount;

const make_transfer_transaction = sdk.make_transfer_transaction(
  undefined, // Optional maybe_source
  target_account,
  transfer_amount,
  transaction_params,
);
const make_transfer_transaction_as_json = make_transfer_transaction.toJson();
console.log(make_transfer_transaction_as_json);
Copy

Python

import json
import casper_rust_wasm_sdk_py as casper

chain_name = "integration-test"
payment_amount = "100000000"
transfer_amount = "2500000000"
target_account = (
    "0187adb3e0f60a983ecc2ddb48d32b3deaa09388ad3bc41e14aeb19959ecc60b54"
)
pem = casper.secret_key_generate()  # treat as secret

params = json.dumps(
    {
        "chain_name": chain_name,
        "payment_amount": payment_amount,
        "secret_key": pem,
    }
)
unsigned = casper.make_transfer_transaction(target_account, transfer_amount, params)
signed = casper.sign_transaction(unsigned, pem)
print(signed[:120], "...")
Copy

Sends a [Transfer Transaction] to the network for execution. (Alias for make_transfer_transaction + put_transaction)

Rust

use casper_rust_wasm_sdk::types::transaction_params::transaction_str_params::TransactionStrParams;

pub const CHAIN_NAME: &str = "integration-test";
pub const PUBLIC_KEY: &str =
    "0169d8d607f3ba04c578140398ceb1bd5296c653f965256bd7097982b9026c5129";
pub const SECRET_KEY: &str = r#"-----BEGIN PRIVATE KEY-----
-----END PRIVATE KEY-----"#;
pub const PAYMENT_AMOUNT: &str = "100000000";
pub const TRANSFER_AMOUNT: &str = "2500000000";
pub const TTL: &str = "1h";
pub const TARGET_ACCOUNT: &str =
    "01868e06026ba9c8695f6f3bb10d44782004dbc144ff65017cf484436f9cf7b0f6";

let transaction_params = TransactionStrParams::default();
transaction_params.set_chain_name(CHAIN_NAME);
transaction_params.set_secret_key(SECRET_KEY);
transaction_params.set_ttl(Some(TTL.to_string()));
transaction_params.set_payment_amount(PAYMENT_AMOUNT);

let transfer = sdk
    .transfer_transaction(
        None, // optional maybe_source
        TARGET_ACCOUNT,
        TRANSFER_AMOUNT,
        transaction_params,
        None, // optional transfer_id
        None,
        None,
    )
    .await;
println!("{:?}", transfer.as_ref().unwrap().result.transaction_hash.to_hex_string());
Copy

Typescript

import { TransactionStrParams, getTimestamp } from "casper-rust-wasm-sdk";

const chain_name = "casper-net-1";
const public_key =
  "0169d8d607f3ba04c578140398ceb1bd5296c653f965256bd7097982b9026c5129";
const secret_key = `-----BEGIN PRIVATE KEY-----
-----END PRIVATE KEY-----`;
const timestamp = getTimestamp(); // or Date.now().toString(); // or undefined
const ttl = "1h"; // or undefined
const payment_amount = "100000000";
const transfer_amount = "2500000000";
const target_account =
  "0187adb3e0f60a983ecc2ddb48d32b3deaa09388ad3bc41e14aeb19959ecc60b54";

const transaction_params = new TransactionStrParams(
  chain_name,
  public_key,
  secret_key,
  timestamp,
  ttl,
);

transaction_params.payment_amount = payment_amount;

const transfer_transaction_result = await sdk.transfer_transaction(
  undefined, // Optional maybe_source
  target_account,
  transfer_amount,
  transaction_params,
);
const transfer_transaction_result_as_json =
  transfer_transaction_result.toJson();
console.log(transfer_transaction_result_as_json);
const transaction_hash =
  transfer_transaction_result.transaction_hash.toString();
console.log(transaction_hash);
Copy

Python

import json
import casper_rust_wasm_sdk_py as casper

RPC = "http://127.0.0.1:11101/rpc"
chain_name = "casper-net-1"
payment_amount = "100000000"
transfer_amount = "2500000000"
target_account = (
    "0187adb3e0f60a983ecc2ddb48d32b3deaa09388ad3bc41e14aeb19959ecc60b54"
)
# Load a funded secret key PEM (do not commit real secrets)
pem = open("secret_key.pem", encoding="utf-8").read()

params = json.dumps(
    {
        "chain_name": chain_name,
        "payment_amount": payment_amount,
        "secret_key": pem,
    }
)
put = json.loads(
    casper.transfer_transaction(
        target_account,
        transfer_amount,
        params,
        None,
        None,
        RPC,
    )
)
print(put.get("transaction_hash") or put)
Copy

Rust

use casper_rust_wasm_sdk::types::{
    addr::entity_addr::EntityAddr,
    hash::addressable_entity_hash::AddressableEntityHash,
    transaction_params::{
        transaction_builder_params::TransactionBuilderParams,
        transaction_str_params::TransactionStrParams,
    },
};

pub const CHAIN_NAME: &str = "integration-test";
pub const PUBLIC_KEY: &str =
    "0169d8d607f3ba04c578140398ceb1bd5296c653f965256bd7097982b9026c5129";
pub const PAYMENT_AMOUNT: &str = "5000000000";
pub const ENTITY_ADDR: &str =
    "entity-contract-5be5b0ef09a7016e11292848d77f539e55791cb07a7012fbc336b1f92a4fe743";
pub const ENTRY_POINT: &str = "set_variables";
pub const TTL: &str = "1h";

let transaction_params = TransactionStrParams::default();
transaction_params.set_chain_name(CHAIN_NAME);
transaction_params.set_initiator_addr(PUBLIC_KEY);
transaction_params.set_ttl(Some(TTL.to_string()));
transaction_params.set_payment_amount(PAYMENT_AMOUNT);

let entity_addr = EntityAddr::from_formatted_str(ENTITY_ADDR).unwrap();
let builder_params = TransactionBuilderParams::new_invocable_entity(entity_addr.into(), ENTRY_POINT);

let transaction = sdk
    .make_transaction(builder_params, transaction_params)
    .unwrap();
println!("{:?}", transaction.timestamp());
Copy

Typescript

import {
  TransactionStrParams,
  TransactionBuilderParams,
  AddressableEntityHash,
} from "casper-rust-wasm-sdk";

const chain_name = "integration-test";
const public_key =
  "0169d8d607f3ba04c578140398ceb1bd5296c653f965256bd7097982b9026c5129";
const payment_amount = "5000000000";
const entity_hash_hex_string =
  "5be5b0ef09a7016e11292848d77f539e55791cb07a7012fbc336b1f92a4fe743";
const entry_point = "set_variables";

const transaction_params = new TransactionStrParams(chain_name, public_key);
transaction_params.payment_amount = payment_amount;

let entity_hash = new AddressableEntityHash(entity_hash_formatted_string);
let builder_params = TransactionBuilderParams.newInvocableEntity(
  entity_hash,
  entry_point,
);

const transaction = sdk.make_transaction(builder_params, transaction_params);
const transaction_as_json = transaction.toJson();
console.log(transaction_as_json);
Copy

Sends a [Transaction] to the network for execution. (Alias for make_transaction + put_transaction)

Rust

let sdk = SDK::new(
    Some("http://127.0.0.1:11101".to_string()),
    Some(Verbosity::High),
);

use casper_rust_wasm_sdk::types::{
    hash::addressable_entity_hash::AddressableEntityHash,
    transaction_params::{
        transaction_builder_params::TransactionBuilderParams,
        transaction_str_params::TransactionStrParams,
    },
};

pub const CHAIN_NAME: &str = "casper-net-1";
pub const PUBLIC_KEY: &str =
    "0169d8d607f3ba04c578140398ceb1bd5296c653f965256bd7097982b9026c5129";
pub const SECRET_KEY: &str = r#"-----BEGIN PRIVATE KEY-----
-----END PRIVATE KEY-----"#;
pub const PAYMENT_AMOUNT: &str = "5000000000";
pub const ENTITY_ADDR: &str =
    "entity-contract-5be5b0ef09a7016e11292848d77f539e55791cb07a7012fbc336b1f92a4fe743";
pub const ENTRY_POINT: &str = "set_variables";
pub const TTL: &str = "1h";

let transaction_params = TransactionStrParams::default();
transaction_params.set_chain_name(CHAIN_NAME);
transaction_params.set_initiator_addr(PUBLIC_KEY);
transaction_params.set_secret_key(SECRET_KEY);
transaction_params.set_ttl(Some(TTL.to_string()));
transaction_params.set_payment_amount(PAYMENT_AMOUNT);

let entity_addr = EntityAddr::from_formatted_str(ENTITY_ADDR).unwrap();
let builder_params = TransactionBuilderParams::new_invocable_entity(entity_addr.into(), ENTRY_POINT);

let transaction = sdk.transaction(builder_params, transaction_params, None, None).await;
println!(
    "{:?}",
    transaction.as_ref().unwrap().result.transaction_hash
);
Copy

Typescript

import {
  TransactionStrParams,
  TransactionBuilderParams,
  AddressableEntityHash,
} from "casper-rust-wasm-sdk";

const chain_name = "casper-net-1";
const public_key =
  "0169d8d607f3ba04c578140398ceb1bd5296c653f965256bd7097982b9026c5129";
const secret_key = `-----BEGIN PRIVATE KEY-----
-----END PRIVATE KEY-----`;
const payment_amount = "5000000000";
const entity_hash_hex_string =
  "5be5b0ef09a7016e11292848d77f539e55791cb07a7012fbc336b1f92a4fe743";
const entry_point = "set_variables";

const transaction_params = new TransactionStrParams(
  chain_name,
  public_key,
  secret_key,
);
transaction_params.payment_amount = payment_amount;

let entity_hash = new AddressableEntityHash(entity_hash_hex_string);
let builder_params = TransactionBuilderParams.newInvocableEntity(
  entity_hash,
  entry_point,
);

const transaction_result = await sdk.transaction(
  builder_params,
  transaction_params,
);
const transaction_result_as_json = transaction_result.toJson();
console.log(transaction_result_as_json);
Copy

Rust

Puts a [Transaction] to the network for execution.

use casper_rust_wasm_sdk::types::{
    hash::addressable_entity_hash::AddressableEntityHash,
    transaction_params::{
        transaction_builder_params::TransactionBuilderParams,
        transaction_str_params::TransactionStrParams,
    },
};

pub const CHAIN_NAME: &str = "casper-net-1";
pub const SECRET_KEY: &str = r#"-----BEGIN PRIVATE KEY-----
-----END PRIVATE KEY-----"#;
let initiator_addr: &str = &public_key_from_secret_key(SECRET_KEY).unwrap();
pub const PAYMENT_AMOUNT: &str = "5000000000";
pub const ENTITY_ADDR: &str =
    "entity-contract-5be5b0ef09a7016e11292848d77f539e55791cb07a7012fbc336b1f92a4fe743";
pub const ENTRY_POINT: &str = "set_variables";
pub const TTL: &str = "1h";

let transaction_params = TransactionStrParams::default();
transaction_params.set_chain_name(CHAIN_NAME);
transaction_params.set_initiator_addr(initiator_addr); // sender account
transaction_params.set_secret_key(SECRET_KEY);
transaction_params.set_ttl(Some(TTL.to_string())); // optional TTL
transaction_params.set_payment_amount(PAYMENT_AMOUNT);

let entity_addr = EntityAddr::from_formatted_str(ENTITY_ADDR).unwrap();
let builder_params = TransactionBuilderParams::new_invocable_entity(entity_addr.into(), ENTRY_POINT);

let transaction = Transaction::new_session(builder_params, transaction_params).unwrap();

let put_transaction = sdk.put_transaction(transaction, None, None).await;
println!(
    "{:?}",
    put_transaction.as_ref().unwrap().result.transaction_hash
);
Copy

Puts a [Transfer Transaction] to the network for execution.

use casper_rust_wasm_sdk::types::transaction_params::transaction_str_params::TransactionStrParams;

pub const CHAIN_NAME: &str = "casper-net-1";
pub const SECRET_KEY: &str = r#"-----BEGIN PRIVATE KEY-----
-----END PRIVATE KEY-----"#;
let initiator_addr: &str = &public_key_from_secret_key(SECRET_KEY).unwrap();
pub const PAYMENT_AMOUNT: &str = "100000000";
pub const TRANSFER_AMOUNT: &str = "2500000000";
pub const TARGET_ACCOUNT: &str =
    "01868e06026ba9c8695f6f3bb10d44782004dbc144ff65017cf484436f9cf7b0f6";
pub const TTL: &str = "1h";

let transaction_params = TransactionStrParams::default();
transaction_params.set_chain_name(CHAIN_NAME);
transaction_params.set_initiator_addr(initiator_addr);
transaction_params.set_secret_key(SECRET_KEY);
transaction_params.set_payment_amount(PAYMENT_AMOUNT);
transaction_params.set_ttl(Some(TTL.to_string()));

let transfer_transaction = Transaction::new_transfer(
    None,
    TARGET_ACCOUNT,
    TRANSFER_AMOUNT,
    transaction_params,
    None,
)
.unwrap();

let put_transaction = sdk.put_transaction(transfer_transaction, None, None).await;
println!(
    "{:?}",
    put_transaction.as_ref().unwrap().result.transaction_hash
);
Copy

Typescript

Puts a [Transaction] to the network for execution.

import {
  TransactionStrParams,
  TransactionBuilderParams,
  AddressableEntityHash,
} from "casper-rust-wasm-sdk";

const chain_name = "casper-net-1";
const public_key =
  "0169d8d607f3ba04c578140398ceb1bd5296c653f965256bd7097982b9026c5129";
const secret_key = `-----BEGIN PRIVATE KEY-----
-----END PRIVATE KEY-----`;
const payment_amount = "5000000000";
const entity_hash_formatted_string =
  "addressable-entity-5be5b0ef09a7016e11292848d77f539e55791cb07a7012fbc336b1f92a4fe743";
const entry_point = "set_variables";

const transaction_params = new TransactionStrParams(
  chain_name,
  public_key,
  secret_key,
);
transaction_params.payment_amount = payment_amount;

let entity_hash = AddressableEntityHash.fromFormattedStr(
  entity_hash_formatted_string,
);
let builder_params = TransactionBuilderParams.newInvocableEntity(
  entity_hash,
  entry_point,
);

const transaction = Transaction.newSession(builder_params, transaction_params);
const put_transaction_result = await sdk.put_transaction(transaction);
const put_transaction_result_as_json = put_transaction_result.toJson();
console.log(put_transaction_result_as_json);
Copy

Puts a [Transfer Transaction] to the network for execution.

import { Transaction, TransactionStrParams } from "casper-rust-wasm-sdk";

const chain_name = "casper-net-1";
const public_key =
  "0169d8d607f3ba04c578140398ceb1bd5296c653f965256bd7097982b9026c5129";
const secret_key = `-----BEGIN PRIVATE KEY-----
-----END PRIVATE KEY-----`;
const payment_amount = "100000000";
const transfer_amount = "2500000000";
const target_account =
  "0187adb3e0f60a983ecc2ddb48d32b3deaa09388ad3bc41e14aeb19959ecc60b54";

const transfer_params = new TransactionStrParams(
  chain_name,
  public_key,
  secret_key,
);

transfer_params.payment_amount = payment_amount;

const transfer_transaction = Transaction.newTransfer(
  undefined, // optional maybe_source
  target_account,
  transfer_amount,
  transfer_params,
);

const put_transaction_result = await sdk.put_transaction(transfer_transaction);
const put_transaction_result_as_json = put_transaction_result.toJson();
console.log(put_transaction_result_as_json);
Copy

Rust

pub const SECRET_KEY: &str = "MC4CAQAwBQYDK2VwBCIEII8ULlk1CJ12ZQ+bScjBt/IxMAZNggClWqK56D1/7CbI";
... //  same code as 'Making a Session/Transfer Transaction' example
let unsigned_transaction = sdk.make_transaction(builder_params, transaction_params).unwrap();
let signed_transaction = unsigned_transaction.sign(SECRET_KEY);
Copy

Typescript

const secret_key = 'MC4CAQAwBQYDK2VwBCIEII8ULlk1CJ12ZQ+bScjBt/IxMAZNggClWqK56D1/7CbI';
... //  same code as 'Making a Session/Transfer Transaction' example
const unsigned_transaction = sdk.make_transaction(builder_params, transaction_params);
const signed_transaction = unsigned_transaction.sign(secret_key);
Copy

Feature SSE (enables watcher) adds a JS-SDK-style node SSE client and a CES contract-event decoder. Cargo default / full includes watcher only (wait_transaction / watch_transaction). Enable SSE in Rust dependencies when you need SSEClient or CESParser. Wasm packs from make web / make nodejs already include SSE, so browser pkg and Node pkg-nodejs expose the full surface.

How the pieces relate:

• Watcher (feature = "watcher"): wait or watch until a given transaction or deploy is processed. Included in Cargo full.
• SSEClient (feature = "SSE"): subscribe to or collect the node event stream (ApiVersion, BlockAdded, TransactionProcessed, …). Prefer this for continuous streams or bounded collects.
• CESParser (feature = "SSE"): decode Casper Event Standard payloads from an execution result (__events / __events_schema). It does not replace the watcher; it consumes execution results you already obtained (for example from wait_transaction or get_transaction).

CES only applies to contracts that publish CES schema named keys. For CEP-78 that means install-time events_mode = 2 (CES). Mode 0 is no events; mode 1 is CEP47 (events dictionary) and is not readable by CESParser.

Rust — SSEClient

Developers using Rust can open an SSE client against a node events URL, subscribe by event name, and either run until stop() or collect a bounded batch (useful for scripts and MCP).

use casper_rust_wasm_sdk::SSE::{EventName, SSEClient};

let client = sdk.SSE_client("http://127.0.0.1:18101/events");
client
    .subscribe(EventName::BlockAdded, |raw| {
        println!("{} {}", raw.event_type, raw.last_event_id);
    })
    .unwrap();
client
    .subscribe(EventName::TransactionProcessed, |raw| {
        let payload = raw.parse_as_transaction_processed().unwrap();
        println!("{}", payload.name);
    })
    .unwrap();
// client.start(None).await.unwrap(); // runs until client.stop()
Copy

Bounded collect:

let events = client
    .collect(&[EventName::ApiVersion, EventName::BlockAdded], 5, 15_000, None)
    .await
    .unwrap();
Copy

start_from / collect Some(0) requests the stream from the beginning of the node's retained buffer (same framing as the watcher).

TypeScript — SSEClient

import init, { SDK, EventName } from "casper-rust-wasm-sdk";

await init();
const sdk = new SDK("http://127.0.0.1:11101/rpc");
const client = sdk.SSE_client("http://127.0.0.1:18101/events");

client.subscribe("BlockAdded", (raw) => {
  console.log(raw.eventType, raw.lastEventId, raw.data);
});
client.subscribe("TransactionProcessed", (raw) => {
  const body = JSON.parse(raw.data).TransactionProcessed;
  console.log(body);
});
// await client.start(); // until client.stop()
Copy

Rust — CESParser

Load contract metadata (including __events_schema) via query_global_state, then parse transforms from an execution-result JSON string. Pass a hash-…, bare hex, or entity-contract-… named key: CESParser::create remaps via helpers::contract_hash_key_for_global_state when addressable entities are disabled and global state expects hash-… → StoredValue::Contract.

use casper_rust_wasm_sdk::SSE::CESParser;

let parser = CESParser::create(&sdk, &["<contract-hash-hex>".into()], None, None)
    .await
    .unwrap();
let results = parser
    .parse_execution_result_json(&execution_result_json)
    .unwrap();
for r in results {
    println!("{} {:?}", r.event.name, r.error);
}
Copy

Typical flow with the watcher: wait_transaction → take execution_result from the processed payload or from get_transaction → parse_execution_result_json. Prefer a mint (or other state-changing entry point) execution over a bare install when you need a CES event such as Mint.

TypeScript — CESParser

import init, { SDK } from "casper-rust-wasm-sdk";

await init();
const sdk = new SDK("http://127.0.0.1:11101/rpc");

const parser = await sdk.CES_parser(
  ["hash-<contract-hash-hex>"],
  null,
  "http://127.0.0.1:11101/rpc",
);
console.log(parser.contractCount());

const events = parser.parseExecutionResultJson(JSON.stringify(executionResult));
for (const row of events) {
  if (!row.error && row.event?.name) {
    console.log(row.event.name, row.event);
  }
}
Copy

See also examples/desktop/node/sse-ces.ts.

Rust

Developers using Rust can utilize the wait_transaction function to wait for a specific transaction event. This is achieved by providing the desired event URL, transaction hash, and an optional timeout duration. Once the transaction is processed, the resulting data, such as the transaction's cost, can be easily accessed and utilized in subsequent logic.

pub const DEFAULT_EVENTS_ADDRESS: &str = "http://127.0.0.1:18101/events";

let transaction_hash = "c94ff7a9f86592681e69c1d8c2d7d2fed89fd1a922faa0ae74481f8458af2ee4";

let timeout_duration = None; // Some(30000) for 30s instead of default timeout duration of 60s

// Wait for transaction
let event_parse_result = sdk
    .wait_transaction(DEFAULT_EVENTS_ADDRESS, &transaction_hash, timeout_duration)
    .await
    .unwrap();
let transaction_processed = event_parse_result.body.unwrap().get_transaction_processed();
println!("{:?}", transaction_processed);
Copy

Typescript

In TypeScript, the waitTransaction function provides a similar capability to wait for a specific transaction event. Developers can leverage this function by specifying the event address, transaction hash, and an optional timeout duration. The received EventParseResult object can then be processed to extract valuable information, such as the cost of the transaction.

const events_address = "http://127.0.0.1:18101/events";

const transaction_hash =
  "c94ff7a9f86592681e69c1d8c2d7d2fed89fd1a922faa0ae74481f8458af2ee4";

const timeout_duration = undefined; // 30000 for 30s instead of default timeout duration of 60s

// Wait for transaction
const eventParseResult: EventParseResult = await sdk.waitTransaction(
  events_address,
  transaction_hash,
  timeout_duration,
);
console.log(eventParseResult.body.transaction_processed);
const cost =
  eventParseResult.body?.transaction_processed?.execution_result.Success?.cost;
console.log(`transaction cost ${cost}`);
Copy

Python

import json
import casper_rust_wasm_sdk_py as casper

events_url = "http://127.0.0.1:18101/events"
transaction_hash = (
    "c94ff7a9f86592681e69c1d8c2d7d2fed89fd1a922faa0ae74481f8458af2ee4"
)
timeout_ms = None  # or 30_000 for 30s; default is 60s when omitted

waited = casper.wait_transaction(events_url, transaction_hash, timeout_ms)
body = json.loads(waited)
print(body.get("body"))
Copy

Rust

The watch_transaction functionality facilitates actively monitoring transaction events. By creating a transaction watcher, developers can subscribe to specific transaction hashes and define custom callback functions to handle these events. The watcher is then started, and as transaction events occur, the specified callback functions are executed. This mechanism enables real-time responsiveness to transaction events within Rust applications.

use casper_rust_wasm_sdk::watcher::{
    Subscription, EventHandlerFn,
};

pub const DEFAULT_EVENTS_ADDRESS: &str = "http://127.0.0.1:18101/events";

let transaction_hash = "c94ff7a9f86592681e69c1d8c2d7d2fed89fd1a922faa0ae74481f8458af2ee4";

let timeout_duration = None; // Some(30000) for 30s instead of default timeout duration of 60s

// Creates a watcher instance
let mut watcher = sdk.watch_transaction(DEFAULT_EVENTS_ADDRESS, timeout_duration);

// Create a callback function handler of your design
let event_handler_fn = get_event_handler_fn(transaction_hash.to_string());

let mut subscriptions: Vec<Subscription> = vec![];
subscriptions.push(Subscription::new(
    transaction_hash.to_string(),
    EventHandlerFn::new(event_handler_fn),
));

// Subscribe and start watching
let _ = watcher.subscribe(subscriptions);
let results = watcher.start().await;
watcher.stop();
println!("{:?}", results);
Copy

Typescript

Similarly, TypeScript developers can utilize the watchTransaction function to actively watch for transaction events on the Casper blockchain. By creating a transaction watcher and defining callback functions, developers can subscribe to specific transaction hashes and respond dynamically as events unfold.

import { EventParseResult, Subscription } from "casper-rust-wasm-sdk";

const events_address = "http://127.0.0.1:18101/events";

const transaction_hash =
  "c94ff7a9f86592681e69c1d8c2d7d2fed89fd1a922faa0ae74481f8458af2ee4";

// Creates a watcher instance
const watcher = sdk.watchTransaction(events_address);

// Create a callback function handler of your design
const getEventHandlerFn = (transactionHash: string) => {
  const eventHandlerFn = (eventParseResult: EventParseResult) => {
    console.log(`callback for ${transactionHash}`);
    if (eventParseResult.err) {
      return false;
    } else if (
      eventParseResult.body?.transaction_processed?.execution_result.Success
    ) {
      console.log(
        eventParseResult.body?.transaction_processed?.execution_result.Success,
      );
      return true;
    } else {
      console.error(
        eventParseResult.body?.transaction_processed?.execution_result.Failure,
      );
      return false;
    }
  };
  return eventHandlerFn;
};

const eventHandlerFn = getEventHandlerFn(transaction_hash);

const subscription: Subscription = new Subscription(
  transaction_hash,
  eventHandlerFn,
);
const subscriptions: Subscription[] = [subscription];

// Subscribe and start watching
watcher.subscribe(subscriptions);
const results = await watcher.start();
watcher.stop();
console.log(results);
Copy

Rust

use casper_rust_wasm_sdk::types::deploy_params::{
    deploy_str_params::DeployStrParams, payment_str_params::PaymentStrParams,
};

pub const CHAIN_NAME: &str = "integration-test";
pub const PUBLIC_KEY: &str =
    "0169d8d607f3ba04c578140398ceb1bd5296c653f965256bd7097982b9026c5129";
pub const PAYMENT_AMOUNT: &str = "100000000";
pub const TRANSFER_AMOUNT: &str = "2500000000";
pub const TTL: &str = "1h";
pub const TARGET_ACCOUNT: &str =
    "01868e06026ba9c8695f6f3bb10d44782004dbc144ff65017cf484436f9cf7b0f6";

let deploy_params = DeployStrParams::new(
    CHAIN_NAME,
    PUBLIC_KEY,            // sender account
    None,                  // optional secret key to sign transfer deploy
    None,                  // optional timestamp
    Some(TTL.to_string()), // optional TTL
);

let payment_params = PaymentStrParams::default();
payment_params.set_payment_amount(PAYMENT_AMOUNT);

let make_transfer = sdk
    .make_transfer(
        TRANSFER_AMOUNT,
        TARGET_ACCOUNT, // target account
        None,           // optional transfer_id
        deploy_params,
        payment_params,
    )
    .unwrap();
println!("{:?}", make_transfer.header().timestamp());
Copy

Typescript

import {
  DeployStrParams,
  PaymentStrParams,
  getTimestamp,
} from "casper-rust-wasm-sdk";

const chain_name = "integration-test";
const public_key =
  "0169d8d607f3ba04c578140398ceb1bd5296c653f965256bd7097982b9026c5129";
const secret_key = undefined;
const timestamp = getTimestamp(); // or Date.now().toString(); // or undefined
const ttl = "1h"; // or undefined
const payment_amount = "100000000";
const transfer_amount = "2500000000";
const target_account =
  "0187adb3e0f60a983ecc2ddb48d32b3deaa09388ad3bc41e14aeb19959ecc60b54";

const deploy_params = new DeployStrParams(
  chain_name,
  public_key,
  secret_key,
  timestamp,
  ttl,
);

const payment_params = new PaymentStrParams(payment_amount);

const transfer_deploy = sdk.make_transfer(
  transfer_amount,
  target_account,
  undefined, // transfer_id
  deploy_params,
  payment_params,
);
const transfer_deploy_as_json = transfer_deploy.toJson();
console.log(transfer_deploy_as_json);
Copy

Sends a [Transfer Deploy] to the network for execution. (Alias for make_transfer + put_deploy)

Rust

use casper_rust_wasm_sdk::types::deploy_params::{
    deploy_str_params::DeployStrParams, payment_str_params::PaymentStrParams,
};

pub const CHAIN_NAME: &str = "integration-test";
pub const PUBLIC_KEY: &str =
    "0169d8d607f3ba04c578140398ceb1bd5296c653f965256bd7097982b9026c5129";
pub const SECRET_KEY: &str = r#"-----BEGIN PRIVATE KEY-----
-----END PRIVATE KEY-----"#;
pub const PAYMENT_AMOUNT: &str = "100000000";
pub const TRANSFER_AMOUNT: &str = "2500000000";
pub const TTL: &str = "1h";
pub const TARGET_ACCOUNT: &str =
    "01868e06026ba9c8695f6f3bb10d44782004dbc144ff65017cf484436f9cf7b0f6";

let deploy_params = DeployStrParams::new(
    CHAIN_NAME,
    PUBLIC_KEY, // sender account
    Some(SECRET_KEY.to_string()),
    None,                  // optional timestamp
    Some(TTL.to_string()), // optional TTL
);

let payment_params = PaymentStrParams::default();
payment_params.set_payment_amount(PAYMENT_AMOUNT);

let transfer = sdk
    .transfer(
        TRANSFER_AMOUNT,
        TARGET_ACCOUNT,
        None, // optional transfer_id
        deploy_params,
        payment_params,
        None,
        None,
    )
    .await;
println!("{:?}", transfer.as_ref().unwrap().result.deploy_hash.to_hex_string());
Copy

Typescript

import {
  DeployStrParams,
  PaymentStrParams,
  getTimestamp,
} from "casper-rust-wasm-sdk";

const chain_name = "casper-net-1";
const public_key =
  "0169d8d607f3ba04c578140398ceb1bd5296c653f965256bd7097982b9026c5129";
const secret_key = `-----BEGIN PRIVATE KEY-----
-----END PRIVATE KEY-----`;
const timestamp = getTimestamp(); // or Date.now().toString(); // or undefined
const ttl = "1h"; // or undefined
const payment_amount = "100000000";
const transfer_amount = "2500000000";
const target_account =
  "0187adb3e0f60a983ecc2ddb48d32b3deaa09388ad3bc41e14aeb19959ecc60b54";

const deploy_params = new DeployStrParams(
  chain_name,
  public_key,
  secret_key,
  timestamp,
  ttl,
);

const payment_params = new PaymentStrParams(payment_amount);

const transfer_result = await sdk.transfer(
  transfer_amount,
  target_account,
  undefined, // transfer_id
  deploy_params,
  payment_params,
);
const transfer_result_as_json = transfer_result.toJson();
console.log(transfer_result_as_json);
console.log(transfer_result.deploy_hash.toString());
Copy

Rust

use casper_rust_wasm_sdk::types::deploy_params::{
    deploy_str_params::DeployStrParams, payment_str_params::PaymentStrParams,
    session_str_params::SessionStrParams,
};

pub const CHAIN_NAME: &str = "integration-test";
pub const PUBLIC_KEY: &str =
    "0169d8d607f3ba04c578140398ceb1bd5296c653f965256bd7097982b9026c5129";
pub const PAYMENT_AMOUNT: &str = "5000000000";
pub const CONTRACT_HASH: &str =
    "hash-5be5b0ef09a7016e11292848d77f539e55791cb07a7012fbc336b1f92a4fe743";
pub const ENTRY_POINT: &str = "set_variables";
pub const TTL: &str = "1h";

let deploy_params = DeployStrParams::new(
    CHAIN_NAME,
    PUBLIC_KEY,            // sender account
    None,                  // optional secret key to sign deploy
    None,                  // optional timestamp
    Some(TTL.to_string()), // optional TTL
);

let session_params = SessionStrParams::default();
session_params.set_session_hash(CONTRACT_HASH);
session_params.set_session_entry_point(ENTRY_POINT);

let payment_params = PaymentStrParams::default();
payment_params.set_payment_amount(PAYMENT_AMOUNT);

let deploy = awaitsdk
    .make_deploy(deploy_params, session_params, payment_params)
    .unwrap();
println!("{:?}", deploy.header().timestamp());
Copy

Typescript

import {
  DeployStrParams,
  PaymentStrParams,
  SessionStrParams,
} from "casper-rust-wasm-sdk";

const chain_name = "integration-test";
const public_key =
  "0169d8d607f3ba04c578140398ceb1bd5296c653f965256bd7097982b9026c5129";
const payment_amount = "5000000000";
const contract_hash =
  "hash-5be5b0ef09a7016e11292848d77f539e55791cb07a7012fbc336b1f92a4fe743";

const deploy_params = new DeployStrParams(chain_name, public_key);

const session_params = new SessionStrParams();
session_params.session_hash = contract_hash;
session_params.session_entry_point = "set_variables";

const payment_params = new PaymentStrParams(payment_amount);

const deploy = sdk.make_deploy(deploy_params, session_params, payment_params);
const deploy_as_json = deploy.toJson();
console.log(deploy_as_json);
Copy