Connect

import { SCP } from '@secretarium/connector';

async function main() {
    
    // We create the new connector context
    const context = new SCP();
    
    // We create a new connection key or provide an existing one
    const myKey = await Key.createKey()

    // We start the connection to Klave
    const connection = await context.connect('wss://on.klave.network', myKey)
}

main()

import asyncio
from secretarium_connector import SCP, Key

async def main():

    #We create the new connector context
    context = SCP()

    #We create a new connection key or provide an existing one
    myKey = await Key.createKey()

    #We start the connection to Klave
    connection = await context.connect('wss://on.klave.network', myKey)

asyncio.run(main())

use klave_connector::{SCP};

#[tokio::main]
async fn main() {    
    let mut client = SCP::new("wss://on.klave.network", None, None);

    match client.connect().await {
        Ok(_) => println!("Connected to Klave successfully."),
        Err(e) => {
            eprintln!("Failed to connect to Klave: {}", e);
            return;
        }
    };

    match client.close().await {
        Ok(_) => println!("Connection closed successfully."),
        Err(e) => eprintln!("Failed to close connection: {}", e),
    };
}

import { SCP, Key } from '@secretarium/connector';

type MyValue = {
    success: boolean;
    value: string;
}

async function main() {

    const context = new SCP();
    const myKey = await Key.createKey()
    const connection = await context.connect('wss://on.klave.network', myKey)

    // We reference the name of our application deployment
    const myAppId = 'your_app.on.klave.network';

    // We load data in our application ledger with a transaction
    await connection.newTx(myAppId, 'storeValue', { key: 'myKey', value: 'myValue' }).send()

    // We retrieve the data with a query
    const result = await connection.newQuery<MyValue>(myAppId, 'fetchValue', { key: 'myKey' }).send()

    // We display the data we retreive and see it matches
    console.log(result); // { "success": true, "value": "myValue" }
}

main()

import asyncio
from secretarium_connector import SCP, Key

async def main():

    context = SCP()
    myKey = await Key.createKey()
    connection = await context.connect('wss://on.klave.network', myKey)

    #We reference the name of our application deployment
    myAppId = 'your_app.on.klave.network'

    #Create object to store
    keyValue1 = {'key':'key1', 'value':'myValue1'}

    #We store the data in our application ledger with the transaction storeValue defined in the application
    transactionResults = connection.newTx(myAppId, 'storeValue', 'requestId1', keyValue1)
    await transactionResults.send()

    #We retrieve the data with the query fetchValue defined in the application
    queryResults = connection.newTx(myAppId, 'fetchValue', 'requestId2', {'key':'key1'})

    #We define a callback function to print the result of the query
    queryResults.onResult(lambda message: print(f"Query result: {message}"))
    await queryResults.send()

asyncio.run(main())

#[tokio::main]
async fn main() {    
    let mut client = SCP::new("wss://on.klave.network", None, None);

    match client.connect().await {
        Ok(_) => println!("Connected to Klave successfully."),
        Err(e) => {
            eprintln!("Failed to connect to Klave: {}", e);
            return;
        }
    };

    // Send a transaction
    let mut tx = client.new_tx("<your-app>", "version", None, None).await;
    tx.on_error(|request_id, error_message| {
        eprintln!("Transaction error occurred. RequestId: {:?}, Error: {:?}", request_id, error_message);
    });
    tx.on_result(|request_id, result| {
        println!("Result received. RequestId: {:?}, Result: {:?}", request_id, result);
    });
    let _ = tx.send().await;

    match client.close().await {
        Ok(_) => println!("Connection closed successfully."),
        Err(e) => eprintln!("Failed to close connection: {}", e),
    };
}