A payment rail
AI agents can be
trusted with.

// 1. A key you generate, and keep. It never leaves this process.
const phrase = generateRecoveryPhrase();
const { privateKeyHex } = derivePrivateKeyFromPhrase(phrase);

// 2. Onboard it. Signed here, posted straight to a chain node.
const client = await VarnirClient.onboard({ privateKeyHex });

// 3. Claim a wallet, then prove ownership on-chain.
const wallet = await client.getWallet('niles');

// 4. Attach a scoped key — a real authority on your ledger identity.
const scoped = VarnirClient.generateKey();
await client.addKey({
  publicKeyHex: scoped.publicKeyHex,
  role: 'offledger',
  scopes: ['invoices:create'],
});

// 5. Raise an invoice — signed request, no bearer token.
const invoice = await client.createInvoice({
  wallets: [wallet.id],
  amount: '10',
  currency: 'native',
  name: 'Order 4021',
});

# 1. A key you generate, and keep. It never leaves this process.
key = generate_key()              # falcon-512, the onboarding default

# 2. Onboard it. Signed here, posted straight to a chain node.
client = VarnirClient.onboard(key.private_key)

# 3. Claim a wallet, then prove ownership on-chain.
wallet = client.get_wallet('niles')

# 4. Attach a scoped key — a real authority on your ledger identity.
scoped = generate_key(KeyType.SECP256K1)
client.add_key(AddKeyOptions(
    public_key=scoped.public_key,
    role=KeyRole.OFFLEDGER,
    scopes=['invoices:create'],
))

# 5. Raise an invoice — signed request, no bearer token.
invoice = client.create_invoice(
    wallet_ids=[wallet.id],
    amount='10',
    currency='native',
    name='Order 4021',
)

// 1. A key you generate, and keep. It never leaves this process.
var key = Signing.GenerateKey();   // falcon-512, the onboarding default

// 2. Onboard it. Signed here, posted straight to a chain node.
using var client = VarnirClient.ForKeyPair(key);
await client.OnboardAsync();

// 3. Claim a wallet, then prove ownership on-chain.
var wallet = await client.GetWalletAsync("niles");

// 4. Attach a scoped key — a real authority on your ledger identity.
var scoped = Signing.GenerateKey(Keys.Secp256k1);
await client.AddKeyAsync(new AddKeyOptions {
    PublicKey = scoped.PublicKey,
    Role      = KeyRole.OffLedger,
    Scopes    = new[] { "invoices:create" },
});

// 5. Raise an invoice — signed request, no bearer token.
var invoice = await client.CreateInvoiceAsync(
    walletIds: new[] { wallet.Id },
    amount: "10",
    currency: "native",
    name: "Order 4021");

// 1. A key you generate, and keep. It never leaves this process.
val key = Signing.generateKey()   // falcon-512, the onboarding default

// 2. Onboard it. Signed here, posted straight to a chain node.
val client = VarnirClient.forKeyPair(key)
client.onboard()

// 3. Claim a wallet, then prove ownership on-chain.
val wallet = client.getWallet("niles")

// 4. Attach a scoped key — a real authority on your ledger identity.
val scoped = Signing.generateKey(Keys.SECP256K1)
client.addKey(AddKeyOptions(
    publicKey = scoped.publicKey,
    role      = KeyRole.OFFLEDGER,
    scopes    = listOf("invoices:create"),
))

// 5. Raise an invoice — signed request, no bearer token.
val invoice = client.createInvoice(
    walletIds = listOf(wallet.id),
    amount    = "10",
    currency  = "native",
    name      = "Order 4021",
)

// 1. A key you generate, and keep. No phrase — nothing upstream mints one,
//    so hang onto the private string. Falcon-512 isn't signable by the Go
//    SDK, so the default here is ml-dsa-65, the post-quantum type it is.
key, _ := varnir.GenerateKey("") // "ml-dsa-65" (default) or "secp256k1"

// 2. Onboard it — the identity is a pure function of the key, computed
//    here and posted straight to a chain node.
client, _ := varnir.Onboard(ctx, varnir.Options{
    PrivateKey:       key.PrivateKey,
    Nodes:            []string{gateway},
    ApiBaseUrl:       apiBase,
    TransferContract: transferContract,
    KeysContract:     keysContract,
    OnboardContract:  onboardContract,
})

// 3. Claim a wallet, then prove ownership on-chain.
wallet, _ := client.CreateWallet(ctx, "niles", "standard")

// 4. Attach a scoped key — a real authority on your ledger identity.
scoped, _ := varnir.GenerateKey(varnir.Secp256k1)
_, _ = client.AddKey(ctx, scoped.PublicKey, varnir.Secp256k1)

// 5. Raise an invoice — signed request, no bearer token.
invoice, _ := client.CreateInvoice(ctx, varnir.CreateInvoiceOptions{
    Wallets: []string{wallet.ID},
    Name:    "Order 4021",
    Amount:  "10",
})

// 1. A key you generate, and keep. No phrase — nothing upstream mints one.
//    Falcon-512 isn't signable by PHP's pqcrypto_compat, so the default is
//    ml-dsa-65, the post-quantum type PHP can use.
$key = Keys::generateKey(); // ml-dsa-65 (default) or Keys::SECP256K1

// 2. Onboard it — the identity is a pure function of the key, computed
//    here and posted straight to a chain node.
$client = Client::onboard(
    privateKey:       $key->privateKey,
    nodes:            [$gateway],
    onboardContract:  $onboardContract,
    apiBaseUrl:       $apiBase,
    transferContract: $transferContract,
    keysContract:     $keysContract,
);

// 3. Claim a wallet, then prove ownership on-chain.
$wallet = $client->createWallet('niles');

// 4. Attach a scoped key — a real authority on your ledger identity.
$scoped = Keys::generateKey(Keys::SECP256K1);
$client->addKey($scoped->publicKey, 'secp256k1');

// 5. Raise an invoice — signed request, no bearer token.
$invoice = $client->createInvoice(
    [$wallet->id],
    'Order 4021',
    '10',
);

// 1. A key you generate, and keep. No phrase — nothing upstream mints one.
//    Falcon-512 isn't signable by the Rust SDK, so None defaults to
//    ml-dsa-65, the post-quantum type Rust can use.
let key = generate_key(None)?; // None = ml-dsa-65; Some(SECP256K1) for classical

// 2. Onboard it — the identity is a pure function of the key, computed
//    here and posted straight to a chain node.
let mut options = ClientOptions::new("", key.private_key);
options.gateways = vec![gateway];
options.api_base_url = Some(api_base);
options.transfer_contract = Some(transfer_contract);
options.keys_contract = Some(keys_contract);
options.onboard_contract = Some(onboard_contract);
let client = Client::onboard(options)?;

// 3. Claim a wallet, then prove ownership on-chain.
let wallet = client.create_wallet("niles", "standard")?;

// 4. Attach a scoped key — a real authority on your ledger identity.
let scoped = generate_key(Some(SECP256K1))?;
client.add_key(&scoped.public_key, "secp256k1")?;

// 5. Raise an invoice — signed request, no bearer token.
let invoice = client.create_invoice(&NewInvoice {
    wallet_ids: vec![wallet.id],
    name: "Order 4021".into(),
    amount: "10".into(),
    ..Default::default()
})?;