Privora

import { Privora } from '@privora/sdk';

const privora = await Privora.connect('http://localhost:8899');

static async connect(url: string): Promise<Privora>

static withoutKey(url: string): Privora

get connection(): Connection

encrypt<T extends EncryptedType>(value: number, type: T): PendingEncrypted<T>

encryptBatch<T extends EncryptedType>(
  inputs: Array<{ value: number; type: T }>
): Array<PendingEncrypted<T>>

async submit<T extends EncryptedType>(
  encrypted: Encrypted<T> | PendingEncrypted<T>
): Promise<string>

async submitBatch<T extends EncryptedType>(
  encrypted: Array<Encrypted<T> | PendingEncrypted<T>>
): Promise<string[]>

async getFheData(hash: string): Promise<Uint8Array>

userCrypto(keypair: Keypair): UserCrypto

transaction(): TransactionBuilder

async getLatestBlockhash(): Promise<{ blockhash: string; lastValidBlockHeight: number }>

async getBalance(pubkey: PublicKey | string): Promise<number>

async requestAirdrop(pubkey: PublicKey | string, lamports: number): Promise<string>

async getMinimumBalanceForRentExemption(dataLength: number): Promise<number>

import { FheEncryptor } from '@privora/sdk';

class FheEncryptor {
  encrypt<T extends EncryptedType>(value: number, type: T): PendingEncrypted<T>;
  encryptBatch<T extends EncryptedType>(
    inputs: Array<{ value: number; type: T }>
  ): Array<PendingEncrypted<T>>;
}

import { RpcClient } from '@privora/sdk';

class RpcClient {
  constructor(url: string);

  async submitFheData(data: Uint8Array): Promise<string>;
  async getFheData(hash: string): Promise<Uint8Array>;
  async getPublicKey(): Promise<Uint8Array>;
  async sendTransaction(
    transaction: Transaction,
    config?: SendTransactionConfig
  ): Promise<string>;
}

import { SignedTransactionSender } from '@privora/sdk';

class SignedTransactionSender {
  constructor(rpcClient: RpcClient, transaction: Transaction, fheHashes: string[]);

  async send(config?: SendTransactionConfig): Promise<string>;
}

import {
  toBase64,
  fromBase64,
  toHex,
  fromHex,
  toBs58,
  fromBs58
} from '@privora/sdk';

function toBase64(data: Uint8Array): string

function fromBase64(data: string): Uint8Array

function toHex(data: Uint8Array): string

function fromHex(data: string): Uint8Array

function toBs58(data: Uint8Array): string

function fromBs58(data: string): Uint8Array

import {
  buildCreateAccountInstruction,
  createAccountWithRent,
  deriveKeypairFromSignature
} from '@privora/sdk';

function buildCreateAccountInstruction(
  params: BuildCreateAccountInstructionParams
): TransactionInstruction

async function createAccountWithRent(
  params: CreateAccountParams
): Promise<TransactionInstruction>

function deriveKeypairFromSignature(signature: Uint8Array): Keypair

// Example: derive keypair from wallet signature
const message = new TextEncoder().encode('Sign to derive Privora encryption keys');
const signature = await wallet.signMessage(message);
const userKeypair = deriveKeypairFromSignature(signature);