@lobstercove/lichen-sdk 1.0.0

package/dist/lichenid.js

@@ -0,0 +1,628 @@
+import { PublicKey } from './publickey.js';
+const PREMIUM_NAME_MIN_LENGTH = 3;
+const PREMIUM_NAME_MAX_LENGTH = 4;
+const DIRECT_NAME_MIN_LENGTH = 5;
+const MAX_NAME_LENGTH = 32;
+const MAX_SKILL_NAME_BYTES = 32;
+const MAX_ENDPOINT_BYTES = 255;
+const MAX_METADATA_BYTES = 1024;
+const RECOVERY_GUARDIAN_COUNT = 5;
+const MAX_U64 = (1n << 64n) - 1n;
+const SPORES_PER_LICN = 1000000000;
+const PROGRAM_SYMBOL_CANDIDATES = ['YID', 'yid', 'LICHENID'];
+const textEncoder = new TextEncoder();
+export const LICHEN_ID_DELEGATE_PERMISSIONS = {
+    PROFILE: 1,
+    AGENT_TYPE: 2,
+    SKILLS: 4,
+    NAMING: 8,
+};
+const AVAILABILITY_BY_NAME = {
+    offline: 0,
+    available: 1,
+    busy: 2,
+    online: 1,
+};
+function normalizeAddress(value) {
+    return value instanceof PublicKey ? value : new PublicKey(value);
+}
+function normalizeNameLabel(name) {
+    return name.trim().toLowerCase().replace(/\.lichen$/, '');
+}
+function hasValidNameCharacters(label) {
+    return !label.startsWith('-')
+        && !label.endsWith('-')
+        && !label.includes('--')
+        && /^[a-z0-9-]+$/.test(label);
+}
+function validateLookupName(name) {
+    const label = normalizeNameLabel(name);
+    if (!label) {
+        throw new Error('Name cannot be empty');
+    }
+    if (label.length > MAX_NAME_LENGTH) {
+        throw new Error('LichenID names must be at most 32 characters');
+    }
+    if (!hasValidNameCharacters(label)) {
+        throw new Error('LichenID names must use lowercase a-z, 0-9, and internal hyphens only');
+    }
+    return label;
+}
+function validateDirectRegistrationName(name) {
+    const label = validateLookupName(name);
+    if (label.length < DIRECT_NAME_MIN_LENGTH) {
+        throw new Error('Direct registerName supports 5-32 character labels; 3-4 character names are auction-only');
+    }
+    return label;
+}
+function validateAuctionName(name) {
+    const label = validateLookupName(name);
+    if (label.length < PREMIUM_NAME_MIN_LENGTH || label.length > PREMIUM_NAME_MAX_LENGTH) {
+        throw new Error('Name auction helpers support 3-4 character premium labels only');
+    }
+    return label;
+}
+function normalizeDurationYears(value) {
+    return Math.max(1, Math.min(10, Math.trunc(value ?? 1) || 1));
+}
+function validateSkillName(name) {
+    const skillName = name.trim();
+    if (!skillName) {
+        throw new Error('Skill name cannot be empty');
+    }
+    if (textEncoder.encode(skillName).length > MAX_SKILL_NAME_BYTES) {
+        throw new Error('Skill names must be at most 32 bytes');
+    }
+    return skillName;
+}
+function normalizeEndpointUrl(url) {
+    const value = url.trim();
+    if (!value) {
+        throw new Error('Endpoint URL cannot be empty');
+    }
+    if (textEncoder.encode(value).length > MAX_ENDPOINT_BYTES) {
+        throw new Error('Endpoint URL must be at most 255 bytes');
+    }
+    return value;
+}
+function normalizeMetadata(metadata) {
+    const serialized = typeof metadata === 'string' ? metadata.trim() : JSON.stringify(metadata);
+    if (!serialized) {
+        throw new Error('Metadata cannot be empty');
+    }
+    if (textEncoder.encode(serialized).length > MAX_METADATA_BYTES) {
+        throw new Error('Metadata must be at most 1024 bytes');
+    }
+    return serialized;
+}
+function normalizeAvailabilityStatus(status) {
+    if (typeof status === 'number') {
+        if (status === 0 || status === 1 || status === 2) {
+            return status;
+        }
+    }
+    else {
+        const normalized = AVAILABILITY_BY_NAME[status.toLowerCase()];
+        if (normalized !== undefined) {
+            return normalized;
+        }
+    }
+    throw new Error('Availability must be one of offline, available, busy, or the numeric values 0-2');
+}
+function normalizeDelegatePermissions(permissions) {
+    if (!Number.isInteger(permissions) || permissions <= 0 || permissions > 0x0F) {
+        throw new Error('Delegate permissions must be a non-zero bitmask using PROFILE, AGENT_TYPE, SKILLS, and NAMING');
+    }
+    return permissions;
+}
+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 validateAttestationLevel(level) {
+    const normalized = Math.trunc(level ?? 3);
+    if (normalized < 1 || normalized > 5) {
+        throw new Error('Attestation level must be between 1 and 5');
+    }
+    return normalized;
+}
+function normalizeRecoveryGuardians(owner, guardians) {
+    if (guardians.length !== RECOVERY_GUARDIAN_COUNT) {
+        throw new Error('Recovery helpers require exactly 5 guardian addresses');
+    }
+    const normalized = guardians.map(normalizeAddress);
+    const unique = new Set(normalized.map((guardian) => guardian.toBase58()));
+    if (unique.size !== RECOVERY_GUARDIAN_COUNT) {
+        throw new Error('Recovery guardians must be unique');
+    }
+    if (normalized.some((guardian) => guardian.equals(owner))) {
+        throw new Error('Recovery guardians cannot include the owner');
+    }
+    return normalized;
+}
+function padBytes(bytes, size) {
+    const out = new Uint8Array(size);
+    out.set(bytes.subarray(0, size));
+    return out;
+}
+function u8(value) {
+    return Uint8Array.from([value & 0xFF]);
+}
+function u32LE(value) {
+    const out = new Uint8Array(4);
+    new DataView(out.buffer).setUint32(0, value, true);
+    return out;
+}
+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 encodeRegisterIdentityArgs(owner, params) {
+    const nameBytes = textEncoder.encode(params.name);
+    return buildLayoutArgs([0x20, 0x01, 0x40, 0x04], [
+        owner.toBytes(),
+        u8(params.agentType),
+        padBytes(nameBytes, 64),
+        u32LE(nameBytes.length),
+    ]);
+}
+function encodeNameDurationArgs(owner, name, durationYears) {
+    const nameBytes = textEncoder.encode(name);
+    return buildLayoutArgs([0x20, 0x20, 0x04, 0x01], [
+        owner.toBytes(),
+        padBytes(nameBytes, 32),
+        u32LE(nameBytes.length),
+        u8(durationYears),
+    ]);
+}
+function encodeAddSkillArgs(owner, params) {
+    const skillName = validateSkillName(params.name);
+    const proficiency = Math.max(0, Math.min(100, Math.trunc(params.proficiency ?? 50) || 0));
+    const nameBytes = textEncoder.encode(skillName);
+    return buildLayoutArgs([0x20, 0x20, 0x04, 0x01], [
+        owner.toBytes(),
+        padBytes(nameBytes, 32),
+        u32LE(nameBytes.length),
+        u8(proficiency),
+    ]);
+}
+function encodeVouchArgs(owner, vouchee) {
+    return buildLayoutArgs([0x20, 0x20], [owner.toBytes(), vouchee.toBytes()]);
+}
+function encodeEndpointArgs(owner, url) {
+    const endpoint = normalizeEndpointUrl(url);
+    const urlBytes = textEncoder.encode(endpoint);
+    const stride = Math.max(32, urlBytes.length);
+    return buildLayoutArgs([0x20, stride, 0x04], [
+        owner.toBytes(),
+        padBytes(urlBytes, stride),
+        u32LE(urlBytes.length),
+    ]);
+}
+function encodeMetadataArgs(owner, metadata) {
+    const serialized = normalizeMetadata(metadata);
+    const metadataBytes = textEncoder.encode(serialized);
+    const stride = Math.max(32, metadataBytes.length);
+    return buildLayoutArgs([0x20, stride, 0x04], [
+        owner.toBytes(),
+        padBytes(metadataBytes, stride),
+        u32LE(metadataBytes.length),
+    ]);
+}
+function encodeRateArgs(owner, rateSpores) {
+    return buildLayoutArgs([0x20, 0x08], [
+        owner.toBytes(),
+        u64LE(rateSpores, 'rateSpores'),
+    ]);
+}
+function encodeAvailabilityArgs(owner, status) {
+    return buildLayoutArgs([0x20, 0x01], [
+        owner.toBytes(),
+        u8(normalizeAvailabilityStatus(status)),
+    ]);
+}
+function encodeSetDelegateArgs(owner, params) {
+    return buildLayoutArgs([0x20, 0x20, 0x01, 0x08], [
+        owner.toBytes(),
+        normalizeAddress(params.delegate).toBytes(),
+        u8(normalizeDelegatePermissions(params.permissions)),
+        u64LE(params.expiresAtMs, 'expiresAtMs'),
+    ]);
+}
+function encodeDelegateLookupArgs(owner, delegate) {
+    return buildLayoutArgs([0x20, 0x20], [owner.toBytes(), delegate.toBytes()]);
+}
+function encodeDelegatedEndpointArgs(delegate, params) {
+    const owner = normalizeAddress(params.owner);
+    const endpoint = normalizeEndpointUrl(params.url);
+    const urlBytes = textEncoder.encode(endpoint);
+    const stride = Math.max(32, urlBytes.length);
+    return buildLayoutArgs([0x20, 0x20, stride, 0x04], [
+        delegate.toBytes(),
+        owner.toBytes(),
+        padBytes(urlBytes, stride),
+        u32LE(urlBytes.length),
+    ]);
+}
+function encodeDelegatedMetadataArgs(delegate, params) {
+    const owner = normalizeAddress(params.owner);
+    const serialized = normalizeMetadata(params.metadata);
+    const metadataBytes = textEncoder.encode(serialized);
+    const stride = Math.max(32, metadataBytes.length);
+    return buildLayoutArgs([0x20, 0x20, stride, 0x04], [
+        delegate.toBytes(),
+        owner.toBytes(),
+        padBytes(metadataBytes, stride),
+        u32LE(metadataBytes.length),
+    ]);
+}
+function encodeDelegatedAvailabilityArgs(delegate, params) {
+    const owner = normalizeAddress(params.owner);
+    return buildLayoutArgs([0x20, 0x20, 0x01], [
+        delegate.toBytes(),
+        owner.toBytes(),
+        u8(normalizeAvailabilityStatus(params.status)),
+    ]);
+}
+function encodeDelegatedRateArgs(delegate, params) {
+    const owner = normalizeAddress(params.owner);
+    return buildLayoutArgs([0x20, 0x20, 0x08], [
+        delegate.toBytes(),
+        owner.toBytes(),
+        u64LE(params.rateSpores, 'rateSpores'),
+    ]);
+}
+function encodeUpdateAgentTypeAsArgs(delegate, params) {
+    const owner = normalizeAddress(params.owner);
+    return buildLayoutArgs([0x20, 0x20, 0x01], [
+        delegate.toBytes(),
+        owner.toBytes(),
+        u8(params.agentType),
+    ]);
+}
+function encodeRecoveryGuardiansArgs(owner, params) {
+    const guardians = normalizeRecoveryGuardians(owner, params.guardians);
+    return buildLayoutArgs([0x20, 0x20, 0x20, 0x20, 0x20, 0x20], [
+        owner.toBytes(),
+        guardians[0].toBytes(),
+        guardians[1].toBytes(),
+        guardians[2].toBytes(),
+        guardians[3].toBytes(),
+        guardians[4].toBytes(),
+    ]);
+}
+function encodeRecoveryActionArgs(caller, params) {
+    return buildLayoutArgs([0x20, 0x20, 0x20], [
+        caller.toBytes(),
+        normalizeAddress(params.target).toBytes(),
+        normalizeAddress(params.newOwner).toBytes(),
+    ]);
+}
+function encodeAttestSkillArgs(attester, params) {
+    const skillName = validateSkillName(params.name);
+    const nameBytes = textEncoder.encode(skillName);
+    return buildLayoutArgs([0x20, 0x20, 0x20, 0x04, 0x01], [
+        attester.toBytes(),
+        normalizeAddress(params.identity).toBytes(),
+        padBytes(nameBytes, 32),
+        u32LE(nameBytes.length),
+        u8(validateAttestationLevel(params.level)),
+    ]);
+}
+function encodeGetAttestationsArgs(identity, skillName) {
+    const normalized = validateSkillName(skillName);
+    const nameBytes = textEncoder.encode(normalized);
+    return buildLayoutArgs([0x20, 0x20, 0x04], [
+        identity.toBytes(),
+        padBytes(nameBytes, 32),
+        u32LE(nameBytes.length),
+    ]);
+}
+function encodeRevokeAttestationArgs(attester, params) {
+    const skillName = validateSkillName(params.name);
+    const nameBytes = textEncoder.encode(skillName);
+    return buildLayoutArgs([0x20, 0x20, 0x20, 0x04], [
+        attester.toBytes(),
+        normalizeAddress(params.identity).toBytes(),
+        padBytes(nameBytes, 32),
+        u32LE(nameBytes.length),
+    ]);
+}
+function encodeCreateNameAuctionArgs(owner, params) {
+    const label = validateAuctionName(params.name);
+    const nameBytes = textEncoder.encode(label);
+    return buildLayoutArgs([0x20, 0x20, 0x04, 0x08, 0x08], [
+        owner.toBytes(),
+        padBytes(nameBytes, 32),
+        u32LE(nameBytes.length),
+        u64LE(params.reserveBidSpores, 'reserveBidSpores'),
+        u64LE(params.endSlot, 'endSlot'),
+    ]);
+}
+function encodeBidNameAuctionArgs(owner, params) {
+    const label = validateAuctionName(params.name);
+    const nameBytes = textEncoder.encode(label);
+    return buildLayoutArgs([0x20, 0x20, 0x04, 0x08], [
+        owner.toBytes(),
+        padBytes(nameBytes, 32),
+        u32LE(nameBytes.length),
+        u64LE(params.bidAmountSpores, 'bidAmountSpores'),
+    ]);
+}
+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 readSafeU64(bytes, offset, fieldName) {
+    const value = readU64(bytes, offset);
+    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new Error(`${fieldName} exceeds JavaScript's safe integer range`);
+    }
+    return Number(value);
+}
+function ensureReturnCodeZero(result, functionName) {
+    const code = result.returnCode ?? 0;
+    if (code !== 0) {
+        throw new Error(result.error ?? `LichenID ${functionName} returned code ${code}`);
+    }
+    if (result.success === false && result.error) {
+        throw new Error(result.error);
+    }
+}
+function decodeDelegateRecord(owner, delegate, bytes) {
+    if (bytes.length < 17) {
+        throw new Error('Delegate record payload was shorter than expected');
+    }
+    const permissions = bytes[0];
+    const expiresAtMs = readSafeU64(bytes, 1, 'expiresAtMs');
+    const createdAtMs = readSafeU64(bytes, 9, 'createdAtMs');
+    return {
+        owner: owner.toBase58(),
+        delegate: delegate.toBase58(),
+        permissions,
+        expiresAtMs,
+        createdAtMs,
+        active: Date.now() < expiresAtMs,
+        canProfile: (permissions & LICHEN_ID_DELEGATE_PERMISSIONS.PROFILE) !== 0,
+        canAgentType: (permissions & LICHEN_ID_DELEGATE_PERMISSIONS.AGENT_TYPE) !== 0,
+        canSkills: (permissions & LICHEN_ID_DELEGATE_PERMISSIONS.SKILLS) !== 0,
+        canNaming: (permissions & LICHEN_ID_DELEGATE_PERMISSIONS.NAMING) !== 0,
+    };
+}
+function registrationCostPerYearLicn(name) {
+    const label = normalizeNameLabel(name);
+    if (label.length <= 3)
+        return 500;
+    if (label.length === 4)
+        return 100;
+    return 20;
+}
+export function estimateLichenIdNameRegistrationCost(name, durationYears = 1) {
+    const years = Math.max(1, Math.min(10, Math.trunc(durationYears) || 1));
+    return BigInt(registrationCostPerYearLicn(name)) * BigInt(years) * BigInt(SPORES_PER_LICN);
+}
+export class LichenIdClient {
+    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 LichenID program via getSymbolRegistry("YID")');
+    }
+    async getProfile(address) {
+        return this.connection.getLichenIdProfile(normalizeAddress(address));
+    }
+    async getReputation(address) {
+        return this.connection.getLichenIdReputation(normalizeAddress(address));
+    }
+    async getSkills(address) {
+        return this.connection.getLichenIdSkills(normalizeAddress(address));
+    }
+    async getVouches(address) {
+        return this.connection.getLichenIdVouches(normalizeAddress(address));
+    }
+    async resolveName(name) {
+        const label = validateLookupName(name);
+        return this.connection.resolveLichenName(`${label}.lichen`);
+    }
+    async getMetadata(address) {
+        const profile = await this.getProfile(address);
+        return profile?.agent?.metadata ?? null;
+    }
+    async getDelegate(owner, delegate) {
+        const ownerAddress = normalizeAddress(owner);
+        const delegateAddress = normalizeAddress(delegate);
+        const result = await this.callReadonly('get_delegate', encodeDelegateLookupArgs(ownerAddress, delegateAddress));
+        if ((result.returnCode ?? 0) === 1 || !result.returnData) {
+            return null;
+        }
+        ensureReturnCodeZero(result, 'get_delegate');
+        return decodeDelegateRecord(ownerAddress, delegateAddress, decodeReturnData(result.returnData));
+    }
+    async getAttestations(identity, skillName) {
+        const result = await this.callReadonly('get_attestations', encodeGetAttestationsArgs(normalizeAddress(identity), skillName));
+        ensureReturnCodeZero(result, 'get_attestations');
+        if (!result.returnData) {
+            throw new Error('LichenID get_attestations did not return attestation data');
+        }
+        return readSafeU64(decodeReturnData(result.returnData), 0, 'attestationCount');
+    }
+    async getNameAuction(name) {
+        return this.connection.getNameAuction(validateLookupName(name));
+    }
+    async getAgentDirectory(options = {}) {
+        return this.connection.getLichenIdAgentDirectory(options);
+    }
+    async getStats() {
+        return this.connection.getLichenIdStats();
+    }
+    async registerIdentity(owner, params) {
+        const name = params.name.trim();
+        if (!name) {
+            throw new Error('Identity name cannot be empty');
+        }
+        const args = encodeRegisterIdentityArgs(owner.pubkey(), {
+            agentType: params.agentType,
+            name,
+        });
+        const programId = await this.getProgramId();
+        return this.connection.callContract(owner, programId, 'register_identity', args);
+    }
+    async registerName(owner, params) {
+        const durationYears = normalizeDurationYears(params.durationYears);
+        const label = validateDirectRegistrationName(params.name);
+        const value = params.valueSpores ?? estimateLichenIdNameRegistrationCost(label, durationYears);
+        const args = encodeNameDurationArgs(owner.pubkey(), label, durationYears);
+        const programId = await this.getProgramId();
+        return this.connection.callContract(owner, programId, 'register_name', args, value);
+    }
+    async addSkill(owner, params) {
+        const programId = await this.getProgramId();
+        const args = encodeAddSkillArgs(owner.pubkey(), params);
+        return this.connection.callContract(owner, programId, 'add_skill', args);
+    }
+    async vouch(owner, vouchee) {
+        const programId = await this.getProgramId();
+        const args = encodeVouchArgs(owner.pubkey(), normalizeAddress(vouchee));
+        return this.connection.callContract(owner, programId, 'vouch', args);
+    }
+    async setEndpoint(owner, params) {
+        const programId = await this.getProgramId();
+        const args = encodeEndpointArgs(owner.pubkey(), params.url);
+        return this.connection.callContract(owner, programId, 'set_endpoint', args);
+    }
+    async setMetadata(owner, params) {
+        const programId = await this.getProgramId();
+        const args = encodeMetadataArgs(owner.pubkey(), params.metadata);
+        return this.connection.callContract(owner, programId, 'set_metadata', args);
+    }
+    async setRate(owner, params) {
+        const programId = await this.getProgramId();
+        const args = encodeRateArgs(owner.pubkey(), params.rateSpores);
+        return this.connection.callContract(owner, programId, 'set_rate', args);
+    }
+    async setAvailability(owner, params) {
+        const programId = await this.getProgramId();
+        const args = encodeAvailabilityArgs(owner.pubkey(), params.status);
+        return this.connection.callContract(owner, programId, 'set_availability', args);
+    }
+    async setDelegate(owner, params) {
+        const programId = await this.getProgramId();
+        const args = encodeSetDelegateArgs(owner.pubkey(), params);
+        return this.connection.callContract(owner, programId, 'set_delegate', args);
+    }
+    async revokeDelegate(owner, delegate) {
+        const programId = await this.getProgramId();
+        const args = encodeDelegateLookupArgs(owner.pubkey(), normalizeAddress(delegate));
+        return this.connection.callContract(owner, programId, 'revoke_delegate', args);
+    }
+    async setEndpointAs(delegate, params) {
+        const programId = await this.getProgramId();
+        const args = encodeDelegatedEndpointArgs(delegate.pubkey(), params);
+        return this.connection.callContract(delegate, programId, 'set_endpoint_as', args);
+    }
+    async setMetadataAs(delegate, params) {
+        const programId = await this.getProgramId();
+        const args = encodeDelegatedMetadataArgs(delegate.pubkey(), params);
+        return this.connection.callContract(delegate, programId, 'set_metadata_as', args);
+    }
+    async setAvailabilityAs(delegate, params) {
+        const programId = await this.getProgramId();
+        const args = encodeDelegatedAvailabilityArgs(delegate.pubkey(), params);
+        return this.connection.callContract(delegate, programId, 'set_availability_as', args);
+    }
+    async setRateAs(delegate, params) {
+        const programId = await this.getProgramId();
+        const args = encodeDelegatedRateArgs(delegate.pubkey(), params);
+        return this.connection.callContract(delegate, programId, 'set_rate_as', args);
+    }
+    async updateAgentTypeAs(delegate, params) {
+        const programId = await this.getProgramId();
+        const args = encodeUpdateAgentTypeAsArgs(delegate.pubkey(), params);
+        return this.connection.callContract(delegate, programId, 'update_agent_type_as', args);
+    }
+    async setRecoveryGuardians(owner, params) {
+        const programId = await this.getProgramId();
+        const args = encodeRecoveryGuardiansArgs(owner.pubkey(), params);
+        return this.connection.callContract(owner, programId, 'set_recovery_guardians', args);
+    }
+    async approveRecovery(guardian, params) {
+        const programId = await this.getProgramId();
+        const args = encodeRecoveryActionArgs(guardian.pubkey(), params);
+        return this.connection.callContract(guardian, programId, 'approve_recovery', args);
+    }
+    async executeRecovery(guardian, params) {
+        const programId = await this.getProgramId();
+        const args = encodeRecoveryActionArgs(guardian.pubkey(), params);
+        return this.connection.callContract(guardian, programId, 'execute_recovery', args);
+    }
+    async attestSkill(attester, params) {
+        const programId = await this.getProgramId();
+        const args = encodeAttestSkillArgs(attester.pubkey(), params);
+        return this.connection.callContract(attester, programId, 'attest_skill', args);
+    }
+    async revokeAttestation(attester, params) {
+        const programId = await this.getProgramId();
+        const args = encodeRevokeAttestationArgs(attester.pubkey(), params);
+        return this.connection.callContract(attester, programId, 'revoke_attestation', args);
+    }
+    async createNameAuction(owner, params) {
+        const programId = await this.getProgramId();
+        const args = encodeCreateNameAuctionArgs(owner.pubkey(), params);
+        return this.connection.callContract(owner, programId, 'create_name_auction', args);
+    }
+    async bidNameAuction(owner, params) {
+        const programId = await this.getProgramId();
+        const args = encodeBidNameAuctionArgs(owner.pubkey(), params);
+        return this.connection.callContract(owner, programId, 'bid_name_auction', args, params.bidAmountSpores);
+    }
+    async finalizeNameAuction(owner, params) {
+        const durationYears = normalizeDurationYears(params.durationYears);
+        const label = validateAuctionName(params.name);
+        const programId = await this.getProgramId();
+        const args = encodeNameDurationArgs(owner.pubkey(), label, durationYears);
+        return this.connection.callContract(owner, programId, 'finalize_name_auction', args);
+    }
+}

package/dist/lichenswap.d.ts

@@ -0,0 +1,79 @@
+import { Connection } from './connection.js';
+import { Keypair } from './keypair.js';
+import { PublicKey } from './publickey.js';
+export interface LichenSwapPoolInfo {
+    reserveA: bigint;
+    reserveB: bigint;
+    totalLiquidity: bigint;
+}
+export interface LichenSwapVolumeTotals {
+    volumeA: bigint;
+    volumeB: bigint;
+}
+export interface LichenSwapProtocolFees {
+    feesA: bigint;
+    feesB: bigint;
+}
+export interface LichenSwapTwapCumulatives {
+    cumulativePriceA: bigint;
+    cumulativePriceB: bigint;
+    lastUpdatedAt: bigint;
+}
+export interface LichenSwapSwapStats {
+    swapCount: bigint;
+    volumeA: bigint;
+    volumeB: bigint;
+    poolCount: bigint;
+    totalLiquidity: bigint;
+}
+export interface LichenSwapStats {
+    swapCount: number;
+    volumeA: number;
+    volumeB: number;
+    paused: boolean;
+}
+export interface CreatePoolParams {
+    tokenA: PublicKey | string;
+    tokenB: PublicKey | string;
+}
+export interface AddLiquidityParams {
+    amountA: number | bigint;
+    amountB: number | bigint;
+    minLiquidity?: number | bigint;
+    valueSpores?: number | bigint;
+}
+export interface SwapParams {
+    amountIn: number | bigint;
+    minAmountOut?: number | bigint;
+    valueSpores?: number | bigint;
+}
+export interface SwapWithDeadlineParams extends SwapParams {
+    deadline: number | bigint;
+}
+export declare class LichenSwapClient {
+    private readonly connection;
+    private resolvedProgram?;
+    constructor(connection: Connection, programId?: PublicKey);
+    private callReadonly;
+    getProgramId(): Promise<PublicKey>;
+    getPoolInfo(): Promise<LichenSwapPoolInfo>;
+    getQuote(amountIn: number | bigint, aToB?: boolean): Promise<bigint>;
+    getLiquidityBalance(provider: PublicKey | string): Promise<bigint>;
+    getTotalLiquidity(): Promise<bigint>;
+    getFlashLoanFee(amount: number | bigint): Promise<bigint>;
+    getTwapCumulatives(): Promise<LichenSwapTwapCumulatives>;
+    getTwapSnapshotCount(): Promise<bigint>;
+    getProtocolFees(): Promise<LichenSwapProtocolFees>;
+    getPoolCount(): Promise<bigint>;
+    getSwapCount(): Promise<bigint>;
+    getTotalVolume(): Promise<LichenSwapVolumeTotals>;
+    getSwapStats(): Promise<LichenSwapSwapStats>;
+    getStats(): Promise<LichenSwapStats>;
+    createPool(owner: Keypair, params: CreatePoolParams): Promise<string>;
+    addLiquidity(provider: Keypair, params: AddLiquidityParams): Promise<string>;
+    swap(provider: Keypair, params: SwapParams, aToB?: boolean): Promise<string>;
+    swapAToB(provider: Keypair, params: SwapParams): Promise<string>;
+    swapBToA(provider: Keypair, params: SwapParams): Promise<string>;
+    swapAToBWithDeadline(provider: Keypair, params: SwapWithDeadlineParams): Promise<string>;
+    swapBToAWithDeadline(provider: Keypair, params: SwapWithDeadlineParams): Promise<string>;
+}