@lobstercove/lichen-sdk 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+export { PublicKey } from './publickey.js';
+export { PublicKey as Address } from './publickey.js';
+export { Keypair } from './keypair.js';
+export { Connection } from './connection.js';
+export { LichenIdClient, LICHEN_ID_DELEGATE_PERMISSIONS, estimateLichenIdNameRegistrationCost, } from './lichenid.js';
+export { ThallLendClient } from './thalllend.js';
+export { LichenSwapClient } from './lichenswap.js';
+export { SporePayClient } from './sporepay.js';
+export { SporeVaultClient } from './sporevault.js';
+export { BountyBoardClient } from './bountyboard.js';
+export { ML_DSA_65_PUBLIC_KEY_BYTES, ML_DSA_65_SIGNATURE_BYTES, PQ_SCHEME_ML_DSA_65, PqPublicKey, PqSignature, } from './pq.js';
+export { Transaction, TransactionBuilder, Instruction, Message, } from './transaction.js';
+export type { Balance, Account, Block, Validator, NetworkInfo, ChainStatus, Metrics, ProofStep, ReadonlyContractResult, TransactionProof, } from './connection.js';
+export type { AddSkillParams, ApproveRecoveryParams, AttestSkillParams, BidNameAuctionParams, LichenIdAgentDirectory, LichenIdAgentDirectoryEntry, LichenIdAgentDirectoryOptions, LichenIdAvailabilityInput, LichenIdAvailabilityStatus, LichenIdDelegatePermissionKey, LichenIdDelegateRecord, LichenIdGivenVouch, LichenIdMetadata, LichenIdNameAuction, LichenIdNameResolution, LichenIdProfile, LichenIdReputation, LichenIdReceivedVouch, LichenIdSkill, LichenIdStats, LichenIdVouches, CreateNameAuctionParams, ExecuteRecoveryParams, FinalizeNameAuctionParams, RegisterIdentityParams, RegisterNameParams, RevokeAttestationParams, SetAvailabilityParams, SetAvailabilityAsParams, SetDelegateParams, SetEndpointParams, SetEndpointAsParams, SetMetadataParams, SetMetadataAsParams, SetRateParams, SetRateAsParams, SetRecoveryGuardiansParams, UpdateAgentTypeAsParams, } from './lichenid.js';
+export type { LiquidateParams, ThallLendAccountInfo, ThallLendInterestRate, ThallLendProtocolStats, ThallLendStats, } from './thalllend.js';
+export type { AddLiquidityParams, CreatePoolParams, LichenSwapPoolInfo, LichenSwapProtocolFees, LichenSwapStats, LichenSwapSwapStats, LichenSwapTwapCumulatives, LichenSwapVolumeTotals, SwapParams, SwapWithDeadlineParams, } from './lichenswap.js';
+export type { CreateStreamParams, CreateStreamWithCliffParams, SporePayStats, SporePayStream, SporePayStreamInfo, TransferStreamParams, WithdrawFromStreamParams, } from './sporepay.js';
+export type { SporeVaultStats, SporeVaultStrategyInfo, SporeVaultUserPosition, SporeVaultVaultStats, } from './sporevault.js';
+export type { ApproveWorkParams, BountyBoardBountyInfo, BountyBoardPlatformStats, BountyBoardStats, CreateBountyParams, SubmitWorkParams, } from './bountyboard.js';
+export { BOUNTY_STATUS_OPEN, BOUNTY_STATUS_COMPLETED, BOUNTY_STATUS_CANCELLED, } from './bountyboard.js';
+/**
+ * SDK version
+ */
+export declare const VERSION = "1.0.0";
+/**
+ * Default RPC URL (override with LICHEN_RPC_URL env var)
+ */
+export declare const DEFAULT_RPC_URL: string;
+/**
+ * Default WebSocket URL (override with LICHEN_WS_URL env var)
+ */
+export declare const DEFAULT_WS_URL: string;

package/dist/index.js

@@ -0,0 +1,27 @@
+// Lichen JavaScript/TypeScript SDK
+// Official SDK for interacting with Lichen blockchain
+export { PublicKey } from './publickey.js';
+export { PublicKey as Address } from './publickey.js';
+export { Keypair } from './keypair.js';
+export { Connection } from './connection.js';
+export { LichenIdClient, LICHEN_ID_DELEGATE_PERMISSIONS, estimateLichenIdNameRegistrationCost, } from './lichenid.js';
+export { ThallLendClient } from './thalllend.js';
+export { LichenSwapClient } from './lichenswap.js';
+export { SporePayClient } from './sporepay.js';
+export { SporeVaultClient } from './sporevault.js';
+export { BountyBoardClient } from './bountyboard.js';
+export { ML_DSA_65_PUBLIC_KEY_BYTES, ML_DSA_65_SIGNATURE_BYTES, PQ_SCHEME_ML_DSA_65, PqPublicKey, PqSignature, } from './pq.js';
+export { TransactionBuilder, } from './transaction.js';
+export { BOUNTY_STATUS_OPEN, BOUNTY_STATUS_COMPLETED, BOUNTY_STATUS_CANCELLED, } from './bountyboard.js';
+/**
+ * SDK version
+ */
+export const VERSION = '1.0.0';
+/**
+ * Default RPC URL (override with LICHEN_RPC_URL env var)
+ */
+export const DEFAULT_RPC_URL = (typeof process !== 'undefined' && process.env?.LICHEN_RPC_URL) || 'http://localhost:8899';
+/**
+ * Default WebSocket URL (override with LICHEN_WS_URL env var)
+ */
+export const DEFAULT_WS_URL = (typeof process !== 'undefined' && process.env?.LICHEN_WS_URL) || 'ws://localhost:8900';

package/dist/keypair.d.ts

@@ -0,0 +1,40 @@
+import { PublicKey } from './publickey.js';
+import { PqPublicKey, PqSignature } from './pq.js';
+export declare class Keypair {
+    readonly publicKey: PqPublicKey;
+    /**
+     * The secret key is stored privately to prevent accidental leakage via
+     * toString(), JSON.stringify(), or console.log(). Use getSecretKey()
+     * when you explicitly need the raw secret key bytes.
+     */
+    private readonly _secretKey;
+    private readonly _seed;
+    private constructor();
+    static generate(): Keypair;
+    static fromSeed(seed: Uint8Array): Keypair;
+    pubkey(): PublicKey;
+    address(): PublicKey;
+    /**
+     * Returns the 32-byte seed used to derive the PQ keypair.
+     *
+     * **WARNING**: Handle with extreme care. Never log, serialize, or transmit
+     * the returned value. Prefer using sign() instead of accessing key material
+     * directly.
+     */
+    getSecretKey(): Uint8Array;
+    toSeed(): Uint8Array;
+    sign(message: Uint8Array): PqSignature;
+    static verify(address: PublicKey, message: Uint8Array, signature: PqSignature): boolean;
+    /**
+     * Returns a safe string representation containing only the address.
+     */
+    toString(): string;
+    /**
+     * Returns a JSON-safe representation containing only the address and verifying key.
+     * Prevents secret key leakage via JSON.stringify().
+     */
+    toJSON(): {
+        address: string;
+        publicKey: ReturnType<PqPublicKey['toJSON']>;
+    };
+}

package/dist/keypair.js

@@ -0,0 +1,69 @@
+// Lichen SDK - Keypair utilities
+// AUDIT-FIX H1-01: Private key protected from accidental exposure via
+// toString(), toJSON(), and console.log(). Use getSecretKey() explicitly.
+import { generateMlDsa65Seed, PqPublicKey, PqSignature } from './pq.js';
+import { ml_dsa65 } from '@noble/post-quantum/ml-dsa.js';
+export class Keypair {
+    constructor(publicKey, secretKey, seed) {
+        this.publicKey = PqPublicKey.mlDsa65(publicKey);
+        this._secretKey = new Uint8Array(secretKey);
+        this._seed = new Uint8Array(seed);
+    }
+    static generate() {
+        return Keypair.fromSeed(generateMlDsa65Seed());
+    }
+    static fromSeed(seed) {
+        if (seed.length !== 32) {
+            throw new Error('Seed must be 32 bytes');
+        }
+        const keypair = ml_dsa65.keygen(seed);
+        return new Keypair(keypair.publicKey, keypair.secretKey, seed);
+    }
+    pubkey() {
+        return this.publicKey.address();
+    }
+    address() {
+        return this.pubkey();
+    }
+    /**
+     * Returns the 32-byte seed used to derive the PQ keypair.
+     *
+     * **WARNING**: Handle with extreme care. Never log, serialize, or transmit
+     * the returned value. Prefer using sign() instead of accessing key material
+     * directly.
+     */
+    getSecretKey() {
+        return this.toSeed();
+    }
+    toSeed() {
+        return new Uint8Array(this._seed);
+    }
+    sign(message) {
+        return PqSignature.mlDsa65(this.publicKey, ml_dsa65.sign(message, this._secretKey));
+    }
+    static verify(address, message, signature) {
+        return address.equals(signature.signerAddress()) && signature.verify(message);
+    }
+    /**
+     * Returns a safe string representation containing only the address.
+     */
+    toString() {
+        return `Keypair(address: ${this.pubkey().toBase58()})`;
+    }
+    /**
+     * Returns a JSON-safe representation containing only the address and verifying key.
+     * Prevents secret key leakage via JSON.stringify().
+     */
+    toJSON() {
+        return {
+            address: this.pubkey().toBase58(),
+            publicKey: this.publicKey.toJSON(),
+        };
+    }
+    /**
+     * Custom inspect for Node.js console.log() — never reveals secret key.
+     */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return this.toString();
+    }
+}

package/dist/lichenid.d.ts

@@ -0,0 +1,271 @@
+import { Connection } from './connection.js';
+import { Keypair } from './keypair.js';
+import { PublicKey } from './publickey.js';
+export declare const LICHEN_ID_DELEGATE_PERMISSIONS: {
+    readonly PROFILE: 1;
+    readonly AGENT_TYPE: 2;
+    readonly SKILLS: 4;
+    readonly NAMING: 8;
+};
+declare const AVAILABILITY_BY_NAME: {
+    readonly offline: 0;
+    readonly available: 1;
+    readonly busy: 2;
+    readonly online: 1;
+};
+export type LichenIdAvailabilityStatus = 0 | 1 | 2;
+export type LichenIdAvailabilityInput = LichenIdAvailabilityStatus | keyof typeof AVAILABILITY_BY_NAME;
+export type LichenIdDelegatePermissionKey = keyof typeof LICHEN_ID_DELEGATE_PERMISSIONS;
+export type LichenIdMetadata = Record<string, unknown> | unknown[] | string;
+export interface LichenIdReputation {
+    address: string;
+    score: number;
+    tier: number;
+    tier_name: string;
+}
+export interface LichenIdNameResolution {
+    name: string;
+    owner: string;
+    registered_slot: number;
+    expiry_slot: number;
+}
+export interface LichenIdSkill {
+    index: number;
+    name: string;
+    proficiency: number;
+    attestation_count: number;
+    timestamp: number;
+}
+export interface LichenIdReceivedVouch {
+    voucher: string;
+    voucher_name: string | null;
+    timestamp: number;
+}
+export interface LichenIdGivenVouch {
+    vouchee: string;
+    vouchee_name: string | null;
+    timestamp: number;
+}
+export interface LichenIdVouches {
+    received: LichenIdReceivedVouch[];
+    given: LichenIdGivenVouch[];
+}
+export interface LichenIdNameAuction {
+    name: string;
+    active: boolean;
+    start_slot: number;
+    end_slot: number;
+    reserve_bid: number;
+    highest_bid: number;
+    highest_bidder: string;
+    current_slot: number;
+    ended: boolean;
+}
+export interface LichenIdAgentDirectoryEntry {
+    address: string;
+    name: string;
+    licn_name: string | null;
+    agent_type: number;
+    agent_type_name: string;
+    reputation: number;
+    trust_tier: number;
+    trust_tier_name: string;
+    availability: number;
+    available: boolean;
+    rate: number;
+    endpoint: string | null;
+    skill_count: number;
+    vouch_count: number;
+    created_at: number;
+    updated_at: number;
+}
+export interface LichenIdAgentDirectory {
+    agents: LichenIdAgentDirectoryEntry[];
+    count: number;
+    total: number;
+}
+export interface LichenIdStats {
+    total_identities: number;
+    total_names: number;
+    total_skills: number;
+    total_vouches: number;
+    total_attestations: number;
+    tier_distribution: Record<string, number>;
+}
+export interface LichenIdDelegateRecord {
+    owner: string;
+    delegate: string;
+    permissions: number;
+    expiresAtMs: number;
+    createdAtMs: number;
+    active: boolean;
+    canProfile: boolean;
+    canAgentType: boolean;
+    canSkills: boolean;
+    canNaming: boolean;
+}
+export interface LichenIdProfile {
+    identity: {
+        address: string;
+        owner: string;
+        name: string;
+        agent_type: number;
+        agent_type_name: string;
+        reputation: number;
+        created_at: number;
+        updated_at: number;
+        skill_count: number;
+        vouch_count: number;
+        is_active: boolean;
+    };
+    licn_name: string | null;
+    reputation: {
+        score: number;
+        tier: number;
+        tier_name: string;
+    };
+    skills: LichenIdSkill[];
+    vouches: LichenIdVouches;
+    achievements: Array<Record<string, unknown>>;
+    agent: {
+        endpoint: string | null;
+        metadata: LichenIdMetadata | null;
+        availability: number;
+        availability_name: string;
+        rate: number;
+    };
+    contributions: Record<string, number>;
+}
+export interface RegisterIdentityParams {
+    agentType: number;
+    name: string;
+}
+export interface RegisterNameParams {
+    name: string;
+    durationYears?: number;
+    valueSpores?: number | bigint;
+}
+export interface AddSkillParams {
+    name: string;
+    proficiency?: number;
+}
+export interface SetEndpointParams {
+    url: string;
+}
+export interface SetMetadataParams {
+    metadata: LichenIdMetadata;
+}
+export interface SetRateParams {
+    rateSpores: number | bigint;
+}
+export interface SetAvailabilityParams {
+    status: LichenIdAvailabilityInput;
+}
+export interface SetDelegateParams {
+    delegate: PublicKey | string;
+    permissions: number;
+    expiresAtMs: number | bigint;
+}
+export interface SetEndpointAsParams {
+    owner: PublicKey | string;
+    url: string;
+}
+export interface SetMetadataAsParams {
+    owner: PublicKey | string;
+    metadata: LichenIdMetadata;
+}
+export interface SetAvailabilityAsParams {
+    owner: PublicKey | string;
+    status: LichenIdAvailabilityInput;
+}
+export interface SetRateAsParams {
+    owner: PublicKey | string;
+    rateSpores: number | bigint;
+}
+export interface UpdateAgentTypeAsParams {
+    owner: PublicKey | string;
+    agentType: number;
+}
+export interface SetRecoveryGuardiansParams {
+    guardians: Array<PublicKey | string>;
+}
+export interface ApproveRecoveryParams {
+    target: PublicKey | string;
+    newOwner: PublicKey | string;
+}
+export interface ExecuteRecoveryParams {
+    target: PublicKey | string;
+    newOwner: PublicKey | string;
+}
+export interface AttestSkillParams {
+    identity: PublicKey | string;
+    name: string;
+    level?: number;
+}
+export interface RevokeAttestationParams {
+    identity: PublicKey | string;
+    name: string;
+}
+export interface CreateNameAuctionParams {
+    name: string;
+    reserveBidSpores: number | bigint;
+    endSlot: number | bigint;
+}
+export interface BidNameAuctionParams {
+    name: string;
+    bidAmountSpores: number | bigint;
+}
+export interface FinalizeNameAuctionParams {
+    name: string;
+    durationYears?: number;
+}
+export interface LichenIdAgentDirectoryOptions {
+    type?: number;
+    available?: boolean;
+    min_reputation?: number;
+    limit?: number;
+    offset?: number;
+}
+export declare function estimateLichenIdNameRegistrationCost(name: string, durationYears?: number): bigint;
+export declare class LichenIdClient {
+    private readonly connection;
+    private resolvedProgram?;
+    constructor(connection: Connection, programId?: PublicKey);
+    private callReadonly;
+    getProgramId(): Promise<PublicKey>;
+    getProfile(address: PublicKey | string): Promise<LichenIdProfile | null>;
+    getReputation(address: PublicKey | string): Promise<LichenIdReputation | null>;
+    getSkills(address: PublicKey | string): Promise<LichenIdSkill[]>;
+    getVouches(address: PublicKey | string): Promise<LichenIdVouches>;
+    resolveName(name: string): Promise<LichenIdNameResolution | null>;
+    getMetadata(address: PublicKey | string): Promise<LichenIdMetadata | null>;
+    getDelegate(owner: PublicKey | string, delegate: PublicKey | string): Promise<LichenIdDelegateRecord | null>;
+    getAttestations(identity: PublicKey | string, skillName: string): Promise<number>;
+    getNameAuction(name: string): Promise<LichenIdNameAuction | null>;
+    getAgentDirectory(options?: LichenIdAgentDirectoryOptions): Promise<LichenIdAgentDirectory>;
+    getStats(): Promise<LichenIdStats>;
+    registerIdentity(owner: Keypair, params: RegisterIdentityParams): Promise<string>;
+    registerName(owner: Keypair, params: RegisterNameParams): Promise<string>;
+    addSkill(owner: Keypair, params: AddSkillParams): Promise<string>;
+    vouch(owner: Keypair, vouchee: PublicKey | string): Promise<string>;
+    setEndpoint(owner: Keypair, params: SetEndpointParams): Promise<string>;
+    setMetadata(owner: Keypair, params: SetMetadataParams): Promise<string>;
+    setRate(owner: Keypair, params: SetRateParams): Promise<string>;
+    setAvailability(owner: Keypair, params: SetAvailabilityParams): Promise<string>;
+    setDelegate(owner: Keypair, params: SetDelegateParams): Promise<string>;
+    revokeDelegate(owner: Keypair, delegate: PublicKey | string): Promise<string>;
+    setEndpointAs(delegate: Keypair, params: SetEndpointAsParams): Promise<string>;
+    setMetadataAs(delegate: Keypair, params: SetMetadataAsParams): Promise<string>;
+    setAvailabilityAs(delegate: Keypair, params: SetAvailabilityAsParams): Promise<string>;
+    setRateAs(delegate: Keypair, params: SetRateAsParams): Promise<string>;
+    updateAgentTypeAs(delegate: Keypair, params: UpdateAgentTypeAsParams): Promise<string>;
+    setRecoveryGuardians(owner: Keypair, params: SetRecoveryGuardiansParams): Promise<string>;
+    approveRecovery(guardian: Keypair, params: ApproveRecoveryParams): Promise<string>;
+    executeRecovery(guardian: Keypair, params: ExecuteRecoveryParams): Promise<string>;
+    attestSkill(attester: Keypair, params: AttestSkillParams): Promise<string>;
+    revokeAttestation(attester: Keypair, params: RevokeAttestationParams): Promise<string>;
+    createNameAuction(owner: Keypair, params: CreateNameAuctionParams): Promise<string>;
+    bidNameAuction(owner: Keypair, params: BidNameAuctionParams): Promise<string>;
+    finalizeNameAuction(owner: Keypair, params: FinalizeNameAuctionParams): Promise<string>;
+}
+export {};