webycash SDK

pip install webycash-sdk

from webycash_sdk import amount_parse, amount_format

wats = amount_parse("1.5")          # 150_000_000
print(amount_format(wats))          # "1.5"

from webycash_sdk import Wallet

# Open or create an HD wallet (SQLite storage)
with Wallet("wallet.db") as w:
    print("Balance:", w.balance())

from webycash_sdk import Wallet

# Create a deterministic wallet from a known 32-byte seed
seed = bytes.fromhex("ab" * 32)
with Wallet("wallet.db", seed=seed) as w:
    print("Master secret:", w.master_secret)

import json
from webycash_sdk import Wallet

with Wallet("wallet.db") as w:
    print("Balance:", w.balance())
    stats = json.loads(w.stats())
    print("Unspent outputs:", stats["unspent_webcash"])
    print("Total balance:", stats["total_balance"])

import json
from webycash_sdk import Wallet

with Wallet("wallet.db") as w:
    outputs = json.loads(w.list_webcash())
    print(f"{len(outputs)} unspent outputs")
    for wc in outputs:
        print(f"  {wc}")

from webycash_sdk import Wallet

with Wallet("wallet.db") as w:
    # 64-char hex — this is the recovery key. Back it up safely.
    secret = w.master_secret
    print(f"Master secret: {secret[:16]}…")

from webycash_sdk import Wallet

# Receive a payment: insert the bearer secret string
with Wallet("wallet.db") as w:
    w.insert("e1.00000000:secret:abcdef0123456789…")
    print("New balance:", w.balance())

from webycash_sdk import Wallet

# Send a payment: creates a bearer string for the recipient
with Wallet("wallet.db") as w:
    payment = w.pay("0.5", "coffee payment")
    print("Send this to recipient:", payment)

from webycash_sdk import Wallet

# Verify all outputs are still valid on the server
with Wallet("wallet.db") as w:
    w.check()
    print("All outputs verified")

from webycash_sdk import Wallet

# Consolidate many small outputs into fewer large ones
with Wallet("wallet.db") as w:
    result = w.merge(20)
    print(result)

from webycash_sdk import Wallet

# Recover outputs from a master secret hex (from backup)
with Wallet("new_wallet.db") as w:
    result = w.recover("aabb…64_hex_chars…", gap_limit=20)
    print(result)

# Or recover using the wallet's own stored master secret
with Wallet("wallet.db") as w:
    result = w.recover_from_wallet(gap_limit=20)
    print(result)

import json
from webycash_sdk import Wallet

with Wallet("wallet.db") as w:
    # Export full wallet state as JSON backup
    backup = w.export_snapshot()
    print(f"Backup: {len(backup)} bytes")

    # Restore into another wallet
    with Wallet("restored.db") as w2:
        w2.import_snapshot(backup)
        print("Restored balance:", w2.balance())

from webycash_sdk import Wallet

with Wallet("wallet.db") as w:
    # Encrypt wallet data with a password (Argon2id + AES-256-GCM)
    encrypted = w.encrypt_with_password("strongPassword123")
    print(f"Encrypted blob: {len(encrypted)} chars")

    # Decrypt and restore
    w.decrypt_with_password(encrypted, "strongPassword123")
    print("Balance after decrypt:", w.balance())

    # Legacy: encrypt the SQLite database seed
    w.encrypt_seed("strong-password")

npm install webycash-sdk

import { amountParse, amountFormat } from "webycash-sdk";

const wats = await amountParse("1.5");    // 150_000_000n (BigInt)
console.log(await amountFormat(wats));    // "1.5"

import { Wallet } from "webycash-sdk";

// Async factory — auto-detects FFI (Node.js) or WASM (browser)
const w = await Wallet.open("wallet.db");
try {
  console.log(await w.balance());
} finally {
  w.close();
}

import { Wallet } from "webycash-sdk";

// Deterministic wallet from a known seed
const seed = new Uint8Array(32).fill(0xab);
const w = await Wallet.open("wallet.db", { seed });
console.log(await w.masterSecret());
w.close();

import { Wallet } from "webycash-sdk";

// Force WASM backend (works in browser + Node.js)
const w = await Wallet.open("wallet", { backend: "wasm" });
console.log(await w.balance());
w.close();

const w = await Wallet.open("wallet.db");
console.log(await w.balance());
const stats = await w.stats();
console.log("Unspent:", stats.unspentWebcash);
console.log("Total:", stats.totalBalance);
w.close();

const w = await Wallet.open("wallet.db");
const outputs = await w.listWebcash();
console.log(`${outputs.length} unspent outputs`);
for (const wc of outputs) console.log(`  ${wc}`);
w.close();

const w = await Wallet.open("wallet.db");
// 64-char hex — back this up for recovery
const secret = await w.masterSecret();
console.log(`Master secret: ${secret.slice(0, 16)}…`);
w.close();

const w = await Wallet.open("wallet.db");
await w.insert("e1.00000000:secret:abcdef0123456789…");
console.log("Balance:", await w.balance());
w.close();

const w = await Wallet.open("wallet.db");
const payment = await w.pay("0.5", "coffee");
console.log("Send to recipient:", payment);
w.close();

const w = await Wallet.open("wallet.db");
const result = await w.check();
console.log(`Valid: ${result.validCount}, Spent: ${result.spentCount}`);
w.close();

const w = await Wallet.open("wallet.db");
const msg = await w.merge(20);
console.log(msg);
w.close();

const w = await Wallet.open("wallet.db");
// Recover using the wallet's own master secret
const result = await w.recoverFromWallet(20);
console.log(`Recovered: ${result.recoveredCount}`);
w.close();

const w = await Wallet.open("wallet.db");
const backup = await w.exportSnapshot();

const w2 = await Wallet.open("restored.db");
await w2.importSnapshot(backup);
console.log("Restored:", await w2.balance());
w.close(); w2.close();

const w = await Wallet.open("wallet.db");
const encrypted = await w.encryptWithPassword("strongPassword123");
await w.decryptWithPassword(encrypted, "strongPassword123");
console.log("Balance:", await w.balance());
w.close();

import { deriveSecret, generateMasterSecret, sha256Hex, secretToPublic,
         parseWebcash, formatWebcash } from "webycash-sdk";

const secret = await generateMasterSecret();     // 64-char hex
const derived = await deriveSecret(secret, 0, 0); // HD derivation
const hash = await sha256Hex("data");
const pub = await secretToPublic(derived);
const wc = await formatWebcash(derived, 100000000n); // "e1:secret:…"
const parsed = await parseWebcash(wc);           // { secret, amountWats, … }

cargo add webylib
# Tokio async runtime required — add tokio with "macros", "rt-multi-thread"

use webylib::Amount;
use std::str::FromStr;

let a = Amount::from_str("1.5")?;
assert_eq!(a.wats, 150_000_000);
println!("{}", a); // "1.5"

use webylib::Wallet;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let w = Wallet::open("wallet.db").await?;
    println!("{}", w.balance().await?);
    w.close().await?;
    Ok(())
}

let w = Wallet::open("wallet.db").await?;
println!("Balance: {}", w.balance().await?);
let s = w.stats().await?;
println!("Unspent: {}, Total: {}", s.unspent_webcash, s.total_balance);

let w = Wallet::open("wallet.db").await?;
let outputs = w.list_webcash().await?;
for wc in &outputs {
    println!("  {}", wc);
}

let w = Wallet::open("wallet.db").await?;
let secret = w.master_secret_hex()?;
println!("Master secret: {}…", &secret[..16]);

use webylib::{SecretWebcash, Wallet};

let w = Wallet::open("wallet.db").await?;
let wc = SecretWebcash::parse("e1.00000000:secret:…")?;
w.insert(wc).await?;
println!("Balance: {}", w.balance().await?);

use webylib::{Amount, Wallet};
use std::str::FromStr;

let w = Wallet::open("wallet.db").await?;
let payment = w.pay(Amount::from_str("0.5")?, "coffee").await?;
println!("Send to recipient: {}", payment);

let w = Wallet::open("wallet.db").await?;
let r = w.check().await?;
println!("Valid: {}, Spent: {}", r.valid_count, r.spent_count);

let w = Wallet::open("wallet.db").await?;
println!("{}", w.merge(20).await?);

let w = Wallet::open("wallet.db").await?;
// From external secret
let r = w.recover("aabb…64_hex…", 20).await?;
println!("Recovered: {}", r.recovered_count);

// From wallet's own stored secret
let r = w.recover_from_wallet(20).await?;
println!("Recovered: {}", r.recovered_count);

let w = Wallet::open("wallet.db").await?;
let snap = w.export_snapshot()?;
let json = serde_json::to_string(&snap)?;

// Restore
let w2 = Wallet::open("restored.db").await?;
let snap2: WalletSnapshot = serde_json::from_str(&json)?;
w2.import_snapshot(&snap2)?;

let w = Wallet::open("wallet.db").await?;
// Full wallet encryption (Argon2id + AES-256-GCM)
let encrypted = w.encrypt_with_password("strong").await?;
w.decrypt_with_password(&encrypted, "strong").await?;

// SQLite database encryption
w.encrypt_database_with_password("strong").await?;

// Package.swift
.package(url: "https://github.com/webycash/webycash-sdk", from: "0.2.16")

import WebycashSDK

let w = try Wallet(path: "wallet.db")
defer { w.close() }
print(try w.balance())

print("Balance:", try w.balance())
print("Stats:", try w.stats())

let outputs = try w.listWebcash()
print("Outputs:", outputs)

let secret = try w.masterSecret()
print("Master secret: \(secret.prefix(16))…")

try w.insert("e1.00000000:secret:…")

let payment = try w.pay(amount: "0.5", memo: "coffee")
print("Send to recipient:", payment)

try w.check()

print(try w.merge(maxOutputs: 20))

// From external master secret hex
print(try w.recover(masterSecretHex: "aabb…64_hex…", gapLimit: 20))

// From wallet's own stored secret
print(try w.recoverFromWallet(gapLimit: 20))

let backup = try w.exportSnapshot()
// Restore into another wallet
let w2 = try Wallet(path: "restored.db")
try w2.importSnapshot(backup)
print("Restored:", try w2.balance())

let encrypted = try w.encryptWithPassword("strongPassword123")
try w.decryptWithPassword(encryptedJSON: encrypted, password: "strongPassword123")
print("Balance:", try w.balance())

implementation("cash.weby:webycash-sdk:0.2.16")

import cash.weby.sdk.Wallet

Wallet.open("wallet.db").use { w ->
    println(w.balance())
}

Wallet.open("wallet.db").use { w ->
    println("Balance: " + w.balance())
    println("Stats: " + w.stats())
}

Wallet.open("wallet.db").use { w ->
    println("Outputs: " + w.listWebcash())
}

Wallet.open("wallet.db").use { w ->
    val secret = w.masterSecret()
    println("Master secret: ${secret.take(16)}…")
}

w.insert("e1.00000000:secret:…")

val payment = w.pay("0.5", "coffee")
println("Send to recipient: $payment")

w.check()

println(w.merge(20))

// From external master secret
println(w.recover("aabb…64_hex…", 20))

// From wallet's own stored secret
println(w.recoverFromWallet(20))

val backup = w.exportSnapshot()
Wallet.open("restored.db").use { w2 ->
    w2.importSnapshot(backup)
    println("Restored: " + w2.balance())
}

val encrypted = w.encryptWithPassword("strongPassword123")
w.decryptWithPassword(encrypted, "strongPassword123")
println("Balance: " + w.balance())

<!-- Maven -->
<dependency>
  <groupId>cash.weby</groupId>
  <artifactId>webycash-sdk</artifactId>
  <version>0.2.16</version>
</dependency>

import cash.weby.sdk.WebycashSDK;

try (var w = new WebycashSDK.Wallet("wallet.db")) {
    System.out.println(w.balance());
}

System.out.println("Balance: " + w.balance());
System.out.println("Stats: " + w.stats());

System.out.println("Outputs: " + w.listWebcash());

String secret = w.masterSecret();
System.out.println("Master secret: " + secret.substring(0, 16) + "…");

w.insert("e1.00000000:secret:…");

String payment = w.pay("0.5", "coffee");
System.out.println("Send to recipient: " + payment);

w.check();

System.out.println(w.merge(20));

// From external master secret
System.out.println(w.recover("aabb…64_hex…", 20));

// From wallet's own stored secret
System.out.println(w.recoverFromWallet(20));

String backup = w.exportSnapshot();
try (var w2 = new WebycashSDK.Wallet("restored.db")) {
    w2.importSnapshot(backup);
    System.out.println("Restored: " + w2.balance());
}

String encrypted = w.encryptWithPassword("strongPassword123");
w.decryptWithPassword(encrypted, "strongPassword123");
System.out.println("Balance: " + w.balance());

go get github.com/webycash/webycash-sdk/go

package main

import (
    "fmt"
    webcash "github.com/webycash/webycash-sdk/go"
)

func main() {
    w, _ := webcash.Open("wallet.db")
    defer w.Close()
    b, _ := w.Balance()
    fmt.Println(b)
}

b, _ := w.Balance()
fmt.Println("Balance:", b)
s, _ := w.Stats()
fmt.Println("Stats:", s)

outputs, _ := w.ListWebcash()
fmt.Println("Outputs:", outputs)

secret, _ := w.MasterSecret()
fmt.Printf("Master secret: %s…\n", secret[:16])

_ = w.Insert("e1.00000000:secret:…")

payment, _ := w.Pay("0.5", "coffee")
fmt.Println("Send to recipient:", payment)

_ = w.Check()

out, _ := w.Merge(20)
fmt.Println(out)

// From external master secret
out, _ := w.Recover("aabb…64_hex…", 20)
fmt.Println(out)

// From wallet's own stored secret
out, _ = w.RecoverFromWallet(20)
fmt.Println(out)

snap, _ := w.ExportSnapshot()
w2, _ := webcash.Open("restored.db")
_ = w2.ImportSnapshot(snap)
b, _ := w2.Balance()
fmt.Println("Restored:", b)
w2.Close()

encrypted, _ := w.EncryptWithPassword("strongPassword123")
_ = w.DecryptWithPassword(encrypted, "strongPassword123")
b, _ := w.Balance()
fmt.Println("Balance:", b)

dotnet add package Webycash.SDK

using WebycashSDK;

using var w = new Wallet("wallet.db");
Console.WriteLine(w.Balance());

Console.WriteLine("Balance: " + w.Balance());
Console.WriteLine("Stats: " + w.Stats());

Console.WriteLine("Outputs: " + w.ListWebcash());

var secret = w.MasterSecret();
Console.WriteLine($"Master secret: {secret[..16]}…");

w.Insert("e1.00000000:secret:…");

var payment = w.Pay("0.5", "coffee");
Console.WriteLine($"Send to recipient: {payment}");

w.Check();

Console.WriteLine(w.Merge(20));

// From external master secret
Console.WriteLine(w.Recover("aabb…64_hex…", 20));

// From wallet's own stored secret
Console.WriteLine(w.RecoverFromWallet(20));

var backup = w.ExportSnapshot();
using var w2 = new Wallet("restored.db");
w2.ImportSnapshot(backup);
Console.WriteLine($"Restored: {w2.Balance()}");

var encrypted = w.EncryptWithPassword("strongPassword123");
w.DecryptWithPassword(encrypted, "strongPassword123");
Console.WriteLine($"Balance: {w.Balance()}");

# Link libwebycash_sdk + include webycash.h / webycash_sdk.hpp
# See webycash-sdk/examples/cpp

#include <webycash_sdk.hpp>

webcash::Wallet w("wallet.db");
std::cout << w.balance() << "\n";

std::cout << "Balance: " << w.balance() << "\n";
std::cout << "Stats: " << w.stats() << "\n";

std::cout << "Outputs: " << w.list_webcash() << "\n";

auto secret = w.master_secret();
std::cout << "Master secret: " << secret.substr(0, 16) << "…\n";

w.insert("e1.00000000:secret:…");

auto payment = w.pay("0.5", "coffee");
std::cout << "Send to recipient: " << payment << "\n";

w.check_wallet();

std::cout << w.merge(20) << "\n";

// From external master secret
std::cout << w.recover("aabb…64_hex…", 20) << "\n";

// From wallet's own stored secret
std::cout << w.recover_from_wallet(20) << "\n";

auto backup = w.export_snapshot();
webcash::Wallet w2("restored.db");
w2.import_snapshot(backup);
std::cout << "Restored: " << w2.balance() << "\n";

auto encrypted = w.encrypt_with_password("strongPassword123");
w.decrypt_with_password(encrypted, "strongPassword123");
std::cout << "Balance: " << w.balance() << "\n";