@cfxdevkit/services

export declare const __packageName: "@cfxdevkit/services";
export declare const noopAuditLogger: AuditLogger;
 
export { MemoryNonceStoreOptions } from "./auth";
export { NonceEntry } from "./auth";
export { createMemoryNonceStore } from "./auth";
export { MemoryNonceStore } from "./auth";
export { SessionToken } from "./auth";
export { SessionTokenOptions } from "./auth";
export { VerifySessionTokenOptions } from "./auth";
export { readBearerToken } from "./auth";
export { signSessionToken } from "./auth";
export { verifySessionToken } from "./auth";
 
export { SecretRef, Capability, StoredSecret, KeystoreCapabilities, KeystoreListOptions, KeystoreCallOptions, KeystorePutInput, KeystoreProvider } from "./keystore";
export { AuditEntry, AuditLogger, Timestamp } from "./keystore-audit";
 
export { MemoryNonceStoreOptions, NonceEntry, createMemoryNonceStore, MemoryNonceStore } from "./keystore-memory";
 
export { KeystoreFileProvider, KeystoreFileProviderOptions } from "./keystore-file";
 
export { KeystoreLedgerProvider, LedgerKeyPath, LedgerKeyPathOptions } from "./keystore-ledger";
 
export { encryptData, decryptData, generateKey, deriveKeyFromPassword } from "./crypto";
 
export { EmbeddedWallet, EmbeddedWalletManagerOptions, EmbeddedWalletManager, KeystoreEmbeddedWalletManager, createEmbeddedWalletManager } from "./embedded-wallet";
 
export { createAppendOnlyAuditLogger, AppendOnlyAuditLoggerOptions } from "./keystore-audit";

export { MemoryNonceStoreOptions, NonceEntry, createMemoryNonceStore, MemoryNonceStore } from "./auth";
export { SessionToken, SessionTokenOptions, VerifySessionTokenOptions } from "./auth";
export { readBearerToken, signSessionToken, verifySessionToken } from "./auth";

export interface SecretRef {
  id: string;
  path: string[];
}
 
export interface Capability {
  name: string;
  args?: Record<string, unknown>;
}
 
export interface StoredSecret {
  id: string;
  path: string[];
  encryptedValue: Uint8Array;
  nonce: Uint8Array;
  capabilities: Capability[];
  createdAt: Timestamp;
  updatedAt: Timestamp;
}
 
export interface KeystoreCapabilities {
  list: boolean;
  get: boolean;
  put: boolean;
  delete: boolean;
}
 
export interface KeystoreListOptions {
  prefix?: string[];
}
 
export interface KeystoreCallOptions {
  capability: Capability;
}
 
export interface KeystorePutInput {
  id: string;
  path: string[];
  value: Uint8Array;
  capabilities: Capability[];
}
 
export interface KeystoreProvider {
  list(options?: KeystoreListOptions): Promise<StoredSecret[]>;
  get(id: string): Promise<StoredSecret | null>;
  put(input: KeystorePutInput): Promise<void>;
  delete(id: string): Promise<void>;
}

export interface AuditEntry {
  timestamp: Timestamp;
  operation: string;
  keystoreId?: string;
  secretId?: string;
  caller?: string;
  success: boolean;
  error?: string;
}
 
export interface AuditLogger {
  log(entry: AuditEntry): void;
}
 
export function createAppendOnlyAuditLogger(opts: AppendOnlyAuditLoggerOptions): AuditLogger;
 
export interface AppendOnlyAuditLoggerOptions {
  onLog?: (entry: AuditEntry) => void;
}

export { MemoryNonceStoreOptions, NonceEntry, createMemoryNonceStore, MemoryNonceStore } from "./keystore-memory";

export interface KeystoreFileProviderOptions {
  path: string;
  password: string | (() => string | Promise<string>);
}
 
export class KeystoreFileProvider implements KeystoreProvider {
  constructor(opts: KeystoreFileProviderOptions);
  list(options?: KeystoreListOptions): Promise<StoredSecret[]>;
  get(id: string): Promise<StoredSecret | null>;
  put(input: KeystorePutInput): Promise<void>;
  delete(id: string): Promise<void>;
}

export interface LedgerKeyPath {
  purpose: number;
  coinType: number;
  account: number;
  change: number;
  index: number;
}
 
export interface LedgerKeyPathOptions {
  path: LedgerKeyPath;
}
 
export class KeystoreLedgerProvider implements KeystoreProvider {
  constructor(opts: LedgerKeyPathOptions);
  list(options?: KeystoreListOptions): Promise<StoredSecret[]>;
  get(id: string): Promise<StoredSecret | null>;
  put(input: KeystorePutInput): Promise<void>;
  delete(id: string): Promise<void>;
}

export function encryptData(plaintext: Uint8Array, key: Uint8Array, nonce?: Uint8Array): { ciphertext: Uint8Array; nonce: Uint8Array };
export function decryptData(ciphertext: Uint8Array, key: Uint8Array, nonce: Uint8Array): Uint8Array;
export function generateKey(): Uint8Array;
export function deriveKeyFromPassword(password: string, salt: Uint8Array): Uint8Array;

export interface EmbeddedWallet {
  id: string;
  address: string;
  createdAt: Timestamp;
}
 
export interface EmbeddedWalletManagerOptions {
  keystore: KeystoreProvider;
}
 
export interface EmbeddedWalletManager {
  createWallet(): Promise<EmbeddedWallet>;
  listWallets(): Promise<EmbeddedWallet[]>;
  getWallet(id: string): Promise<EmbeddedWallet | null>;
  deleteWallet(id: string): Promise<void>;
}
 
export class KeystoreEmbeddedWalletManager implements EmbeddedWalletManager {
  constructor(options: EmbeddedWalletManagerOptions);
  createWallet(): Promise<EmbeddedWallet>;
  listWallets(): Promise<EmbeddedWallet[]>;
  getWallet(id: string): Promise<EmbeddedWallet | null>;
  deleteWallet(id: string): Promise<void>;
}
 
export function createEmbeddedWalletManager(options: EmbeddedWalletManagerOptions): KeystoreEmbeddedWalletManager;

import { KeystoreFileProvider, encryptData, generateKey } from '@cfxdevkit/services';
 
// Derive encryption key from password
const salt = new Uint8Array(16);
const key = deriveKeyFromPassword('my-password', salt);
 
// Encrypt data
const plaintext = new TextEncoder().encode('secret data');
const { ciphertext, nonce } = encryptData(plaintext, key);
 
// Initialize file-backed keystore
const keystore = new KeystoreFileProvider({
  path: './keystore.json',
  password: () => 'my-password'
});
 
// Store encrypted secret
await keystore.put({
  id: 'my-secret',
  path: ['wallets', 'main'],
  value: ciphertext,
  capabilities: [{ name: 'sign' }]
});

// Manages wallet account key generation, storage, encryption, and secure retrieval.
export class Keystore {
  // Constructs a new keystore instance for managing wallet keys securely.
  constructor();
}

import { Keystore } from '@cfxdevkit/services/keystore';
 
// Create a new Keystore instance
const keystore = new Keystore();

// Provides utilities for cryptographic operations including ECDSA signing, SHA-256 hashing, and key derivation.
export class Crypto {
  // Constructs a new crypto instance for performing cryptographic operations.
  constructor();
}

import { Crypto } from '@cfxdevkit/services/crypto';
 
// Create a new Crypto instance
const crypto = new Crypto();

// Facilitates interaction with DEX protocols for token swaps, liquidity provision, and trade execution.
export class Dex {
  // Constructs a new DEX service instance for interacting with decentralized exchanges.
  constructor();
}

import { Dex } from '@cfxdevkit/services/dex';
 
// Create a new Dex instance
const dex = new Dex();

// Handles token discovery, balance tracking, metadata retrieval, and interaction with ERC-20/ERC-721 standards.
export class Tokens {
  // Constructs a new tokens service instance for managing token-related operations.
  constructor();
}

import { Tokens } from '@cfxdevkit/services/tokens';
 
// Create a new Tokens instance
const tokens = new Tokens();