@lobstercove/lichen-sdk 1.0.0

package/dist/sporepay.d.ts

@@ -0,0 +1,57 @@
+import { Connection } from './connection.js';
+import { Keypair } from './keypair.js';
+import { PublicKey } from './publickey.js';
+export interface SporePayStream {
+    streamId: bigint;
+    sender: string;
+    recipient: string;
+    totalAmount: bigint;
+    withdrawnAmount: bigint;
+    startSlot: bigint;
+    endSlot: bigint;
+    cancelled: boolean;
+    createdSlot: bigint;
+}
+export interface SporePayStreamInfo extends SporePayStream {
+    cliffSlot: bigint;
+}
+export interface SporePayStats {
+    streamCount: number;
+    totalStreamed: number;
+    totalWithdrawn: number;
+    cancelCount: number;
+    paused: boolean;
+}
+export interface CreateStreamParams {
+    recipient: PublicKey | string;
+    totalAmount: number | bigint;
+    startSlot: number | bigint;
+    endSlot: number | bigint;
+}
+export interface CreateStreamWithCliffParams extends CreateStreamParams {
+    cliffSlot: number | bigint;
+}
+export interface WithdrawFromStreamParams {
+    streamId: number | bigint;
+    amount: number | bigint;
+}
+export interface TransferStreamParams {
+    streamId: number | bigint;
+    newRecipient: PublicKey | string;
+}
+export declare class SporePayClient {
+    private readonly connection;
+    private resolvedProgram?;
+    constructor(connection: Connection, programId?: PublicKey);
+    private callReadonly;
+    getProgramId(): Promise<PublicKey>;
+    getStream(streamId: number | bigint): Promise<SporePayStream | null>;
+    getStreamInfo(streamId: number | bigint): Promise<SporePayStreamInfo | null>;
+    getWithdrawable(streamId: number | bigint): Promise<bigint>;
+    getStats(): Promise<SporePayStats>;
+    createStream(sender: Keypair, params: CreateStreamParams): Promise<string>;
+    createStreamWithCliff(sender: Keypair, params: CreateStreamWithCliffParams): Promise<string>;
+    withdrawFromStream(recipient: Keypair, params: WithdrawFromStreamParams): Promise<string>;
+    cancelStream(sender: Keypair, streamId: number | bigint): Promise<string>;
+    transferStream(recipient: Keypair, params: TransferStreamParams): Promise<string>;
+}

package/dist/sporepay.js

@@ -0,0 +1,208 @@
+import { PublicKey } from './publickey.js';
+const PROGRAM_SYMBOL_CANDIDATES = ['SPOREPAY', 'sporepay'];
+const STREAM_SIZE = 105;
+const STREAM_INFO_SIZE = 113;
+const MAX_U64 = (1n << 64n) - 1n;
+function normalizeAddress(value) {
+    return value instanceof PublicKey ? value : new PublicKey(value);
+}
+function normalizeUnsignedU64(value, fieldName) {
+    const normalized = typeof value === 'bigint'
+        ? value
+        : Number.isSafeInteger(value) && value >= 0
+            ? BigInt(value)
+            : null;
+    if (normalized === null || normalized < 0n || normalized > MAX_U64) {
+        throw new Error(`${fieldName} must be a u64-safe integer value`);
+    }
+    return normalized;
+}
+function u64LE(value, fieldName) {
+    const out = new Uint8Array(8);
+    new DataView(out.buffer).setBigUint64(0, normalizeUnsignedU64(value, fieldName), true);
+    return out;
+}
+function buildLayoutArgs(layout, chunks) {
+    const header = Uint8Array.from([0xAB, ...layout]);
+    const total = chunks.reduce((sum, chunk) => sum + chunk.length, header.length);
+    const out = new Uint8Array(total);
+    out.set(header, 0);
+    let offset = header.length;
+    for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return out;
+}
+function encodeCreateStreamArgs(sender, params) {
+    return buildLayoutArgs([0x20, 0x20, 0x08, 0x08, 0x08], [
+        sender.toBytes(),
+        normalizeAddress(params.recipient).toBytes(),
+        u64LE(params.totalAmount, 'totalAmount'),
+        u64LE(params.startSlot, 'startSlot'),
+        u64LE(params.endSlot, 'endSlot'),
+    ]);
+}
+function encodeCreateStreamWithCliffArgs(sender, params) {
+    return buildLayoutArgs([0x20, 0x20, 0x08, 0x08, 0x08, 0x08], [
+        sender.toBytes(),
+        normalizeAddress(params.recipient).toBytes(),
+        u64LE(params.totalAmount, 'totalAmount'),
+        u64LE(params.startSlot, 'startSlot'),
+        u64LE(params.endSlot, 'endSlot'),
+        u64LE(params.cliffSlot, 'cliffSlot'),
+    ]);
+}
+function encodeWithdrawArgs(caller, params) {
+    return buildLayoutArgs([0x20, 0x08, 0x08], [
+        caller.toBytes(),
+        u64LE(params.streamId, 'streamId'),
+        u64LE(params.amount, 'amount'),
+    ]);
+}
+function encodeCancelArgs(caller, streamId) {
+    return buildLayoutArgs([0x20, 0x08], [
+        caller.toBytes(),
+        u64LE(streamId, 'streamId'),
+    ]);
+}
+function encodeTransferArgs(caller, params) {
+    return buildLayoutArgs([0x20, 0x20, 0x08], [
+        caller.toBytes(),
+        normalizeAddress(params.newRecipient).toBytes(),
+        u64LE(params.streamId, 'streamId'),
+    ]);
+}
+function encodeStreamLookupArgs(streamId) {
+    return buildLayoutArgs([0x08], [u64LE(streamId, 'streamId')]);
+}
+function decodeReturnData(returnData) {
+    return Uint8Array.from(Buffer.from(returnData, 'base64'));
+}
+function readU64(bytes, offset) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return view.getBigUint64(offset, true);
+}
+function ensureReturnCodeZero(result, functionName) {
+    const code = result.returnCode ?? 0;
+    if (code !== 0) {
+        throw new Error(result.error ?? `SporePay ${functionName} returned code ${code}`);
+    }
+    if (result.success === false && result.error) {
+        throw new Error(result.error);
+    }
+}
+function decodeStream(streamId, bytes) {
+    if (bytes.length < STREAM_SIZE) {
+        throw new Error('SporePay stream payload was shorter than expected');
+    }
+    return {
+        streamId,
+        sender: PublicKey.fromBytes(bytes.slice(0, 32)).toBase58(),
+        recipient: PublicKey.fromBytes(bytes.slice(32, 64)).toBase58(),
+        totalAmount: readU64(bytes, 64),
+        withdrawnAmount: readU64(bytes, 72),
+        startSlot: readU64(bytes, 80),
+        endSlot: readU64(bytes, 88),
+        cancelled: bytes[96] === 1,
+        createdSlot: readU64(bytes, 97),
+    };
+}
+function decodeStreamInfo(streamId, bytes) {
+    if (bytes.length < STREAM_INFO_SIZE) {
+        throw new Error('SporePay stream-info payload was shorter than expected');
+    }
+    return {
+        ...decodeStream(streamId, bytes),
+        cliffSlot: readU64(bytes, 105),
+    };
+}
+export class SporePayClient {
+    constructor(connection, programId) {
+        this.connection = connection;
+        this.resolvedProgram = programId;
+    }
+    async callReadonly(functionName, args) {
+        const programId = await this.getProgramId();
+        return this.connection.callReadonlyContract(programId, functionName, args);
+    }
+    async getProgramId() {
+        if (this.resolvedProgram) {
+            return this.resolvedProgram;
+        }
+        for (const symbol of PROGRAM_SYMBOL_CANDIDATES) {
+            try {
+                const entry = await this.connection.getSymbolRegistry(symbol);
+                if (entry?.program) {
+                    this.resolvedProgram = new PublicKey(entry.program);
+                    return this.resolvedProgram;
+                }
+            }
+            catch {
+                // Try the next known registry alias.
+            }
+        }
+        throw new Error('Unable to resolve the SporePay program via getSymbolRegistry("SPOREPAY")');
+    }
+    async getStream(streamId) {
+        const normalizedStreamId = normalizeUnsignedU64(streamId, 'streamId');
+        const result = await this.callReadonly('get_stream', encodeStreamLookupArgs(normalizedStreamId));
+        if ((result.returnCode ?? 0) === 1 || !result.returnData) {
+            return null;
+        }
+        ensureReturnCodeZero(result, 'get_stream');
+        return decodeStream(normalizedStreamId, decodeReturnData(result.returnData));
+    }
+    async getStreamInfo(streamId) {
+        const normalizedStreamId = normalizeUnsignedU64(streamId, 'streamId');
+        const result = await this.callReadonly('get_stream_info', encodeStreamLookupArgs(normalizedStreamId));
+        if ((result.returnCode ?? 0) === 1 || !result.returnData) {
+            return null;
+        }
+        ensureReturnCodeZero(result, 'get_stream_info');
+        return decodeStreamInfo(normalizedStreamId, decodeReturnData(result.returnData));
+    }
+    async getWithdrawable(streamId) {
+        const result = await this.callReadonly('get_withdrawable', encodeStreamLookupArgs(streamId));
+        ensureReturnCodeZero(result, 'get_withdrawable');
+        if (!result.returnData) {
+            throw new Error('SporePay get_withdrawable did not return a balance');
+        }
+        return readU64(decodeReturnData(result.returnData), 0);
+    }
+    async getStats() {
+        const stats = await this.connection.getSporePayStats();
+        return {
+            streamCount: stats.stream_count ?? 0,
+            totalStreamed: stats.total_streamed ?? 0,
+            totalWithdrawn: stats.total_withdrawn ?? 0,
+            cancelCount: stats.cancel_count ?? 0,
+            paused: Boolean(stats.paused),
+        };
+    }
+    async createStream(sender, params) {
+        const programId = await this.getProgramId();
+        const args = encodeCreateStreamArgs(sender.pubkey(), params);
+        return this.connection.callContract(sender, programId, 'create_stream', args);
+    }
+    async createStreamWithCliff(sender, params) {
+        const programId = await this.getProgramId();
+        const args = encodeCreateStreamWithCliffArgs(sender.pubkey(), params);
+        return this.connection.callContract(sender, programId, 'create_stream_with_cliff', args);
+    }
+    async withdrawFromStream(recipient, params) {
+        const programId = await this.getProgramId();
+        const args = encodeWithdrawArgs(recipient.pubkey(), params);
+        return this.connection.callContract(recipient, programId, 'withdraw_from_stream', args);
+    }
+    async cancelStream(sender, streamId) {
+        const programId = await this.getProgramId();
+        const args = encodeCancelArgs(sender.pubkey(), streamId);
+        return this.connection.callContract(sender, programId, 'cancel_stream', args);
+    }
+    async transferStream(recipient, params) {
+        const programId = await this.getProgramId();
+        const args = encodeTransferArgs(recipient.pubkey(), params);
+        return this.connection.callContract(recipient, programId, 'transfer_stream', args);
+    }
+}

package/dist/sporevault.d.ts

@@ -0,0 +1,43 @@
+import { Connection } from './connection.js';
+import { Keypair } from './keypair.js';
+import { PublicKey } from './publickey.js';
+export interface SporeVaultVaultStats {
+    totalAssets: bigint;
+    totalShares: bigint;
+    sharePriceE9: bigint;
+    strategyCount: bigint;
+    totalEarned: bigint;
+    feesEarned: bigint;
+}
+export interface SporeVaultUserPosition {
+    shares: bigint;
+    estimatedValue: bigint;
+}
+export interface SporeVaultStrategyInfo {
+    strategyType: bigint;
+    allocationPercent: bigint;
+    deployedAmount: bigint;
+}
+export interface SporeVaultStats {
+    totalAssets: number;
+    totalShares: number;
+    strategyCount: number;
+    totalEarned: number;
+    feesEarned: number;
+    protocolFees: number;
+    paused: boolean;
+}
+export declare class SporeVaultClient {
+    private readonly connection;
+    private resolvedProgram?;
+    constructor(connection: Connection, programId?: PublicKey);
+    private callReadonly;
+    getProgramId(): Promise<PublicKey>;
+    getVaultStats(): Promise<SporeVaultVaultStats>;
+    getUserPosition(user: PublicKey | string): Promise<SporeVaultUserPosition>;
+    getStrategyInfo(index: number | bigint): Promise<SporeVaultStrategyInfo | null>;
+    getStats(): Promise<SporeVaultStats>;
+    deposit(depositor: Keypair, amount: number | bigint): Promise<string>;
+    withdraw(depositor: Keypair, sharesToBurn: number | bigint): Promise<string>;
+    harvest(caller: Keypair): Promise<string>;
+}

package/dist/sporevault.js

@@ -0,0 +1,176 @@
+import { PublicKey } from './publickey.js';
+const PROGRAM_SYMBOL_CANDIDATES = ['SPOREVAULT', 'sporevault', 'SporeVault', 'VAULT', 'vault'];
+const MAX_U64 = (1n << 64n) - 1n;
+function normalizeAddress(value) {
+    return value instanceof PublicKey ? value : new PublicKey(value);
+}
+function normalizeUnsignedU64(value, fieldName) {
+    const normalized = typeof value === 'bigint'
+        ? value
+        : Number.isSafeInteger(value) && value >= 0
+            ? BigInt(value)
+            : null;
+    if (normalized === null || normalized < 0n || normalized > MAX_U64) {
+        throw new Error(`${fieldName} must be a u64-safe integer value`);
+    }
+    return normalized;
+}
+function u64LE(value, fieldName) {
+    const out = new Uint8Array(8);
+    new DataView(out.buffer).setBigUint64(0, normalizeUnsignedU64(value, fieldName), true);
+    return out;
+}
+function buildLayoutArgs(layout, chunks) {
+    const header = Uint8Array.from([0xAB, ...layout]);
+    const total = chunks.reduce((sum, chunk) => sum + chunk.length, header.length);
+    const out = new Uint8Array(total);
+    out.set(header, 0);
+    let offset = header.length;
+    for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return out;
+}
+function encodeUserAmountArgs(user, amount) {
+    return buildLayoutArgs([0x20, 0x08], [
+        user.toBytes(),
+        u64LE(amount, 'amount'),
+    ]);
+}
+function encodeUserLookupArgs(user) {
+    return buildLayoutArgs([0x20], [normalizeAddress(user).toBytes()]);
+}
+function encodeIndexArgs(index) {
+    return buildLayoutArgs([0x08], [u64LE(index, 'index')]);
+}
+function decodeReturnData(returnData) {
+    return Uint8Array.from(Buffer.from(returnData, 'base64'));
+}
+function readU64(bytes, offset) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return view.getBigUint64(offset, true);
+}
+function ensureReadonlySuccess(result, functionName, allowedReturnCodes = [0]) {
+    const code = result.returnCode ?? 0;
+    if (!allowedReturnCodes.includes(code)) {
+        throw new Error(result.error ?? `SporeVault ${functionName} returned code ${code}`);
+    }
+    if (result.success === false && result.error) {
+        throw new Error(result.error);
+    }
+}
+function decodeVaultStats(result) {
+    ensureReadonlySuccess(result, 'get_vault_stats');
+    if (!result.returnData) {
+        throw new Error('SporeVault get_vault_stats did not return vault data');
+    }
+    const bytes = decodeReturnData(result.returnData);
+    if (bytes.length < 48) {
+        throw new Error('SporeVault get_vault_stats payload was shorter than expected');
+    }
+    return {
+        totalAssets: readU64(bytes, 0),
+        totalShares: readU64(bytes, 8),
+        sharePriceE9: readU64(bytes, 16),
+        strategyCount: readU64(bytes, 24),
+        totalEarned: readU64(bytes, 32),
+        feesEarned: readU64(bytes, 40),
+    };
+}
+function decodeUserPosition(result) {
+    ensureReadonlySuccess(result, 'get_user_position');
+    if (!result.returnData) {
+        throw new Error('SporeVault get_user_position did not return user data');
+    }
+    const bytes = decodeReturnData(result.returnData);
+    if (bytes.length < 16) {
+        throw new Error('SporeVault get_user_position payload was shorter than expected');
+    }
+    return {
+        shares: readU64(bytes, 0),
+        estimatedValue: readU64(bytes, 8),
+    };
+}
+function decodeStrategyInfo(result) {
+    ensureReadonlySuccess(result, 'get_strategy_info');
+    if (!result.returnData) {
+        throw new Error('SporeVault get_strategy_info did not return strategy data');
+    }
+    const bytes = decodeReturnData(result.returnData);
+    if (bytes.length < 24) {
+        throw new Error('SporeVault get_strategy_info payload was shorter than expected');
+    }
+    return {
+        strategyType: readU64(bytes, 0),
+        allocationPercent: readU64(bytes, 8),
+        deployedAmount: readU64(bytes, 16),
+    };
+}
+export class SporeVaultClient {
+    constructor(connection, programId) {
+        this.connection = connection;
+        this.resolvedProgram = programId;
+    }
+    async callReadonly(functionName, args = new Uint8Array()) {
+        const programId = await this.getProgramId();
+        return this.connection.callReadonlyContract(programId, functionName, args);
+    }
+    async getProgramId() {
+        if (this.resolvedProgram) {
+            return this.resolvedProgram;
+        }
+        for (const symbol of PROGRAM_SYMBOL_CANDIDATES) {
+            try {
+                const entry = await this.connection.getSymbolRegistry(symbol);
+                if (entry?.program) {
+                    this.resolvedProgram = new PublicKey(entry.program);
+                    return this.resolvedProgram;
+                }
+            }
+            catch {
+                // Try the next known registry alias.
+            }
+        }
+        throw new Error('Unable to resolve the SporeVault program via getSymbolRegistry("SPOREVAULT")');
+    }
+    async getVaultStats() {
+        return decodeVaultStats(await this.callReadonly('get_vault_stats'));
+    }
+    async getUserPosition(user) {
+        return decodeUserPosition(await this.callReadonly('get_user_position', encodeUserLookupArgs(user)));
+    }
+    async getStrategyInfo(index) {
+        const result = await this.callReadonly('get_strategy_info', encodeIndexArgs(index));
+        if ((result.returnCode ?? 0) === 1 || !result.returnData) {
+            return null;
+        }
+        return decodeStrategyInfo(result);
+    }
+    async getStats() {
+        const stats = await this.connection.getSporeVaultStats();
+        return {
+            totalAssets: stats.total_assets ?? 0,
+            totalShares: stats.total_shares ?? 0,
+            strategyCount: stats.strategy_count ?? 0,
+            totalEarned: stats.total_earned ?? 0,
+            feesEarned: stats.fees_earned ?? 0,
+            protocolFees: stats.protocol_fees ?? 0,
+            paused: Boolean(stats.paused),
+        };
+    }
+    async deposit(depositor, amount) {
+        const programId = await this.getProgramId();
+        const args = encodeUserAmountArgs(depositor.pubkey(), amount);
+        return this.connection.callContract(depositor, programId, 'deposit', args, normalizeUnsignedU64(amount, 'amount'));
+    }
+    async withdraw(depositor, sharesToBurn) {
+        const programId = await this.getProgramId();
+        const args = encodeUserAmountArgs(depositor.pubkey(), sharesToBurn);
+        return this.connection.callContract(depositor, programId, 'withdraw', args);
+    }
+    async harvest(caller) {
+        const programId = await this.getProgramId();
+        return this.connection.callContract(caller, programId, 'harvest');
+    }
+}

package/dist/thalllend.d.ts

@@ -0,0 +1,51 @@
+import { Connection } from './connection.js';
+import { Keypair } from './keypair.js';
+import { PublicKey } from './publickey.js';
+export interface ThallLendAccountInfo {
+    deposit: bigint;
+    borrow: bigint;
+    healthFactorBps: bigint;
+}
+export interface ThallLendProtocolStats {
+    totalDeposits: bigint;
+    totalBorrows: bigint;
+    utilizationPct: bigint;
+    reserves: bigint;
+}
+export interface ThallLendInterestRate {
+    ratePerSlot: bigint;
+    utilizationPct: bigint;
+    totalAvailable: bigint;
+}
+export interface ThallLendStats {
+    totalDeposits: number;
+    totalBorrows: number;
+    reserves: number;
+    depositCount: number;
+    borrowCount: number;
+    liquidationCount: number;
+    paused: boolean;
+}
+export interface LiquidateParams {
+    borrower: PublicKey | string;
+    repayAmount: number | bigint;
+}
+export declare class ThallLendClient {
+    private readonly connection;
+    private resolvedProgram?;
+    constructor(connection: Connection, programId?: PublicKey);
+    private callReadonly;
+    getProgramId(): Promise<PublicKey>;
+    getAccountInfo(user: PublicKey | string): Promise<ThallLendAccountInfo>;
+    getProtocolStats(): Promise<ThallLendProtocolStats>;
+    getInterestRate(): Promise<ThallLendInterestRate>;
+    getDepositCount(): Promise<bigint>;
+    getBorrowCount(): Promise<bigint>;
+    getLiquidationCount(): Promise<bigint>;
+    getStats(): Promise<ThallLendStats>;
+    deposit(depositor: Keypair, amount: number | bigint): Promise<string>;
+    withdraw(depositor: Keypair, amount: number | bigint): Promise<string>;
+    borrow(borrower: Keypair, amount: number | bigint): Promise<string>;
+    repay(borrower: Keypair, amount: number | bigint): Promise<string>;
+    liquidate(liquidator: Keypair, params: LiquidateParams): Promise<string>;
+}