Cryptography API

static MessageDigest sha256Digest()

static byte[] sha256(byte[] input)

static byte[] sha256Twice(byte[] bytes)

static byte[] sha256Twice(byte[] bytes, int offset, int length)

static MessageDigest sha512Digest()

static byte[] h160(byte[] input)

import software.sava.core.crypto.Hash;

// SHA-256 hash
byte[] data = "Hello Solana".getBytes();
byte[] hash = Hash.sha256(data);

// Double SHA-256 (commonly used in Bitcoin)
byte[] doubleHash = Hash.sha256Twice(data);

// Hash160 for addresses
byte[] hash160 = Hash.h160(publicKeyBytes);

// Incremental hashing
var digest = Hash.sha256Digest();
digest.update(data1);
digest.update(data2);
byte[] result = digest.digest();

static void generatePublicKey(byte[] privateKey, byte[] publicKey)

static void generatePublicKey(
    byte[] privateKey,
    int privateKeyOffset,
    byte[] publicKey,
    int publicKeyOffset
)

static boolean isNotOnCurve(byte[] hash)

import software.sava.core.crypto.ed25519.Ed25519Util;

// Generate public key from private key
byte[] privateKey = new byte[32];
// ... initialize private key ...

byte[] publicKey = new byte[32];
Ed25519Util.generatePublicKey(privateKey, publicKey);

// Check if hash is off-curve (for PDA validation)
byte[] hash = Hash.sha256(someData);
if (Ed25519Util.isNotOnCurve(hash)) {
    System.out.println("Valid PDA address");
}

boolean verifySignature(byte[] msg, byte[] signature)
boolean verifySignature(String msg, byte[] signature)

static boolean verifySignature(
    java.security.PublicKey publicKey,
    byte[] msg,
    byte[] signature
)

static boolean verifySignature(
    byte[] publicKey,
    int publicKeyOffset,
    byte[] msg,
    int msgOffset,
    int msgLength,
    byte[] signature
)

import software.sava.core.accounts.PublicKey;
import software.sava.core.accounts.Signer;

// Create signer and sign message
var signer = Signer.createFromKeyPair(keyPairBytes);
byte[] message = "Sign this message".getBytes();
byte[] signature = signer.sign(message);

// Verify with PublicKey instance
var pubKey = signer.publicKey();
boolean valid = pubKey.verifySignature(message, signature);

// Verify with raw bytes
boolean valid2 = PublicKey.verifySignature(
    pubKey.toByteArray(),
    0,
    message,
    0,
    message.length,
    signature
);

// Verify with Java security PublicKey
java.security.PublicKey javaPubKey = pubKey.toJavaPublicKey();
boolean valid3 = PublicKey.verifySignature(
    javaPubKey,
    message,
    signature
);

static final Provider SUN_SECURITY_PROVIDER
static final KeyFactory ED_25519_KEY_FACTORY
static final SecureRandom SECURE_RANDOM

import software.sava.core.crypto.SunCrypto;

// Get secure random bytes
byte[] randomBytes = new byte[32];
SunCrypto.SECURE_RANDOM.nextBytes(randomBytes);

// Use in key generation
import software.sava.core.accounts.Signer;

byte[] privateKey = new byte[32];
SunCrypto.SECURE_RANDOM.nextBytes(privateKey);
var signer = Signer.createFromPrivateKey(privateKey);

import software.sava.core.accounts.Signer;
import software.sava.core.accounts.PublicKey;

// Generate keypair
var keyPair = Signer.generatePrivateKeyPairBytes();
var signer = Signer.createFromKeyPair(keyPair);

// Get public key
PublicKey pubKey = signer.publicKey();
System.out.println("Address: " + pubKey.toBase58());

// Sign message
byte[] message = "Hello Solana".getBytes();
byte[] signature = signer.sign(message);

// Verify
boolean valid = pubKey.verifySignature(message, signature);
assert valid;

import software.sava.core.accounts.PublicKey;
import software.sava.core.crypto.Hash;
import software.sava.core.crypto.ed25519.Ed25519Util;
import java.util.List;

// Create PDA seeds
var seeds = List.of(
    "metadata".getBytes(),
    programId.toByteArray(),
    mint.toByteArray()
);

// Find valid PDA
var pda = PublicKey.findProgramAddress(seeds, programId);

// The process internally uses:
// 1. Concatenate seeds + program ID + nonce
// 2. SHA-256 hash
// 3. Check if off-curve with Ed25519Util.isNotOnCurve()
// 4. Repeat with decremented nonce until valid

import software.sava.core.tx.Transaction;
import software.sava.core.accounts.Signer;

// Create transaction
var tx = Transaction.createTx(feePayer, instructions);

// Sign (internally uses Ed25519)
var signer = Signer.createFromKeyPair(keyPairBytes);
tx.sign(blockHash, signer);

// Get signature (transaction ID)
byte[] txId = tx.getId();
String txIdBase58 = tx.getBase58Id();

// Signature is first 64 bytes of serialized transaction

// Extract signature and message from transaction
byte[] serializedTx = tx.serialized();
byte[] signature = Arrays.copyOfRange(serializedTx, 1, 65);

int sigLen = 1 + (64 * tx.numSigners());
byte[] message = Arrays.copyOfRange(
    serializedTx,
    sigLen,
    serializedTx.length
);

// Verify signature
boolean valid = signer.publicKey().verifySignature(
    message,
    signature
);