@amadeus-protocol/sdk 1.0.6 → 1.0.7

package/dist/contracts/lockup/parsers.js

@@ -0,0 +1,60 @@
+import { fromAtomicAma } from '../../conversion';
+/**
+ * Parse raw lockup vault data string into intermediate format
+ * Format: {unlock_height}-{amount}-{symbol}
+ *
+ * @param dataStr - Raw vault data string from contract state
+ * @returns Parsed data or null if invalid
+ */
+export function parseRawLockupVaultData(dataStr) {
+    const match = dataStr.match(/^(\d+)-(\d+)-([A-Za-z]+)$/);
+    if (!match)
+        return null;
+    const unlockHeight = Number.parseInt(match[1], 10);
+    const amountFlat = Number.parseInt(match[2], 10);
+    const symbol = match[3];
+    if (Number.isNaN(unlockHeight) || unlockHeight < 0)
+        return null;
+    if (Number.isNaN(amountFlat) || amountFlat < 0)
+        return null;
+    if (symbol !== 'AMA')
+        return null;
+    return { unlockHeight, amountFlat, symbol };
+}
+/**
+ * Parse lockup vault data from contract state
+ * Format: {unlock_height}-{amount}-{symbol}
+ * These vaults are locked for 5 epochs (100,000 * 5 = 500,000 heights)
+ *
+ * @param vaultData - Raw vault data from contract state (string or Uint8Array)
+ * @param vaultIndex - The vault index
+ * @returns Parsed vault or null if invalid
+ */
+export function parseLockupVaultData(vaultData, vaultIndex) {
+    try {
+        const dataStr = typeof vaultData === 'string' ? vaultData : new TextDecoder().decode(vaultData);
+        const rawData = parseRawLockupVaultData(dataStr);
+        if (!rawData)
+            return null;
+        const { unlockHeight, amountFlat } = rawData;
+        const amount = fromAtomicAma(amountFlat);
+        // Regular lockup vaults created from early unlock are locked for 5 epochs
+        // 5 epochs = 100,000 * 5 = 500,000 heights
+        const lockHeight = Math.max(0, unlockHeight - 500_000);
+        // Approximate epochs: 1 epoch ~ 100,000 heights
+        const unlockEpoch = Math.floor(unlockHeight / 100_000);
+        const lockEpoch = Math.floor(lockHeight / 100_000);
+        return {
+            unlockEpoch,
+            lockEpoch,
+            amount,
+            vaultIndex,
+            vaultType: 'vesting',
+            unlockHeight
+        };
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=parsers.js.map

package/dist/contracts/lockup/parsers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsers.js","sourceRoot":"","sources":["../../../src/contracts/lockup/parsers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAIhD;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CAAC,OAAe;IACtD,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,2BAA2B,CAAC,CAAA;IACxD,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAA;IAEvB,MAAM,YAAY,GAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAE,EAAE,EAAE,CAAC,CAAA;IACnD,MAAM,UAAU,GAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAE,EAAE,EAAE,CAAC,CAAA;IACjD,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAE,CAAA;IAExB,IAAI,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,YAAY,GAAG,CAAC;QAAE,OAAO,IAAI,CAAA;IAC/D,IAAI,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,UAAU,GAAG,CAAC;QAAE,OAAO,IAAI,CAAA;IAC3D,IAAI,MAAM,KAAK,KAAK;QAAE,OAAO,IAAI,CAAA;IAEjC,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,EAAE,CAAA;AAC5C,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,oBAAoB,CACnC,SAA8B,EAC9B,UAAkB;IAElB,IAAI,CAAC;QACJ,MAAM,OAAO,GACZ,OAAO,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,CAAA;QAEhF,MAAM,OAAO,GAAG,uBAAuB,CAAC,OAAO,CAAC,CAAA;QAChD,IAAI,CAAC,OAAO;YAAE,OAAO,IAAI,CAAA;QAEzB,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,GAAG,OAAO,CAAA;QAE5C,MAAM,MAAM,GAAG,aAAa,CAAC,UAAU,CAAC,CAAA;QAExC,0EAA0E;QAC1E,2CAA2C;QAC3C,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,CAAA;QAEtD,gDAAgD;QAChD,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,GAAG,OAAO,CAAC,CAAA;QACtD,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,GAAG,OAAO,CAAC,CAAA;QAElD,OAAO;YACN,WAAW;YACX,SAAS;YACT,MAAM;YACN,UAAU;YACV,SAAS,EAAE,SAAS;YACpB,YAAY;SACZ,CAAA;IACF,CAAC;IAAC,MAAM,CAAC;QACR,OAAO,IAAI,CAAA;IACZ,CAAC;AACF,CAAC"}

package/dist/contracts/lockup/storage-keys.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Build vault key prefix for an account
+ * Format: bic:lockup:vault:{account_48bytes}:
+ */
+export declare function buildLockupVaultKeyPrefix(accountBinary: Uint8Array): Uint8Array;
+/**
+ * Extract vault index from key
+ * Key format: bic:lockup:vault:{account_48bytes}:{vault_index}
+ *
+ * Note: When using prefix queries, the key might be:
+ * - Full key: bic:lockup:vault:{account_48bytes}:{vault_index}
+ * - Suffix only: {vault_index} (just the part after the prefix)
+ */
+export declare function extractLockupVaultIndexFromKey(key: string | Uint8Array): number | null;
+//# sourceMappingURL=storage-keys.d.ts.map

package/dist/contracts/lockup/storage-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-keys.d.ts","sourceRoot":"","sources":["../../../src/contracts/lockup/storage-keys.ts"],"names":[],"mappings":"AAkCA;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,aAAa,EAAE,UAAU,GAAG,UAAU,CAE/E;AAED;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,GAAG,IAAI,CA2CtF"}

package/dist/contracts/lockup/storage-keys.js

@@ -0,0 +1,78 @@
+import { Lockup } from './helpers';
+/**
+ * Generic function to build a storage key for an account
+ */
+function buildStorageKey(keyName, accountBinary, appendColon = false) {
+    const storageKey = Lockup.getStorageKey(keyName);
+    if (!storageKey) {
+        throw new Error(`Storage key '${keyName}' not found in ABI`);
+    }
+    const prefix = Lockup.getKeyPrefix(keyName);
+    if (!prefix) {
+        throw new Error(`Could not extract prefix for storage key '${keyName}'`);
+    }
+    const prefixBytes = new TextEncoder().encode(prefix);
+    const resultLength = prefixBytes.length + accountBinary.length + (appendColon ? 1 : 0);
+    const result = new Uint8Array(resultLength);
+    result.set(prefixBytes, 0);
+    result.set(accountBinary, prefixBytes.length);
+    if (appendColon) {
+        result[result.length - 1] = 0x3a; // ':'
+    }
+    return result;
+}
+/**
+ * Build vault key prefix for an account
+ * Format: bic:lockup:vault:{account_48bytes}:
+ */
+export function buildLockupVaultKeyPrefix(accountBinary) {
+    return buildStorageKey('vault', accountBinary, true);
+}
+/**
+ * Extract vault index from key
+ * Key format: bic:lockup:vault:{account_48bytes}:{vault_index}
+ *
+ * Note: When using prefix queries, the key might be:
+ * - Full key: bic:lockup:vault:{account_48bytes}:{vault_index}
+ * - Suffix only: {vault_index} (just the part after the prefix)
+ */
+export function extractLockupVaultIndexFromKey(key) {
+    try {
+        const keyBytes = typeof key === 'string' ? new TextEncoder().encode(key) : key;
+        const keyStr = typeof key === 'string' ? key : new TextDecoder().decode(key);
+        // Check if key is vault data format FIRST
+        // If key looks like vault data (e.g., '229427-75000000000000-AMA'), don't try to extract index
+        const isVaultDataFormat = /^\d+-\d+-[A-Za-z]+$/.test(keyStr);
+        if (isVaultDataFormat) {
+            return null;
+        }
+        // If the key is very short (likely just the vault index suffix from prefix query)
+        if (keyBytes.length < 10) {
+            const directParse = Number.parseInt(keyStr, 10);
+            if (!Number.isNaN(directParse) && directParse >= 0) {
+                return directParse;
+            }
+        }
+        // Find the last colon (':') byte (0x3A)
+        let lastColonIndex = -1;
+        for (let i = keyBytes.length - 1; i >= 0; i--) {
+            if (keyBytes[i] === 0x3a) {
+                lastColonIndex = i;
+                break;
+            }
+        }
+        if (lastColonIndex === -1 || lastColonIndex === keyBytes.length - 1) {
+            const wholeKeyParse = Number.parseInt(keyStr, 10);
+            return Number.isNaN(wholeKeyParse) ? null : wholeKeyParse;
+        }
+        // Extract vault index from after the last colon
+        const indexBytes = keyBytes.slice(lastColonIndex + 1);
+        const indexStr = new TextDecoder().decode(indexBytes);
+        const vaultIndex = Number.parseInt(indexStr, 10);
+        return Number.isNaN(vaultIndex) ? null : vaultIndex;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=storage-keys.js.map

package/dist/contracts/lockup/storage-keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-keys.js","sourceRoot":"","sources":["../../../src/contracts/lockup/storage-keys.ts"],"names":[],"mappings":"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"}

package/dist/contracts/lockup/types.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Type Definitions for Lockup smart contract
+ *
+ * Replaces Zod schemas with plain TypeScript types.
+ */
+/** Parsed Lockup vault (vesting vault) */
+export interface LockupVault {
+    unlockEpoch: number;
+    lockEpoch: number;
+    amount: number;
+    vaultIndex: number;
+    vaultType: 'vesting';
+    unlockHeight?: number;
+}
+/** Intermediate parse result from raw vault data string */
+export interface RawLockupVaultData {
+    unlockHeight: number;
+    amountFlat: number;
+    symbol: string;
+}
+export interface LockupAbiFunction {
+    type: 'function';
+    name: string;
+    inputs: LockupAbiInput[];
+    outputs: LockupAbiOutput[];
+    stateMutability: 'nonpayable' | 'payable' | 'view' | 'pure';
+    description?: string;
+    requirements?: string[];
+    storage?: {
+        reads?: LockupAbiStorageRead[];
+        writes?: LockupAbiStorageWrite[];
+    };
+}
+export interface LockupAbiInput {
+    name: string;
+    type: string;
+    description?: string;
+    validation?: {
+        min?: string;
+        max?: string;
+        type?: string;
+    };
+    enum?: string[];
+}
+export interface LockupAbiOutput {
+    name: string;
+    type: string;
+    description?: string;
+}
+export interface LockupAbiError {
+    name: string;
+    code: string;
+    description: string;
+}
+export interface LockupAbiStorage {
+    keys: LockupAbiStorageKey[];
+}
+export interface LockupAbiStorageKey {
+    name: string;
+    pattern: string;
+    type: 'mapping' | 'value' | 'array';
+    description: string;
+    valueFormat?: string;
+    valueSchema?: Record<string, any>;
+    query?: {
+        method: string;
+        endpoint: string;
+        prefix?: string;
+        key?: string;
+        description: string;
+    };
+}
+export interface LockupAbiStorageRead {
+    key: string;
+    description?: string;
+    value?: string;
+}
+export interface LockupAbiStorageWrite {
+    key: string;
+    value?: string;
+    operation?: 'increment' | 'decrement' | 'create' | 'delete' | 'mint';
+    amount?: string;
+    duration?: string;
+    description?: string;
+    condition?: string;
+    writes?: LockupAbiStorageWrite[];
+}
+/** @deprecated Use `LockupVault` instead */
+export type LockupVaultSchema = LockupVault;
+//# sourceMappingURL=types.d.ts.map

package/dist/contracts/lockup/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/contracts/lockup/types.ts"],"names":[],"mappings":"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"}

package/dist/contracts/lockup/types.js

@@ -0,0 +1,7 @@
+/**
+ * Type Definitions for Lockup smart contract
+ *
+ * Replaces Zod schemas with plain TypeScript types.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/contracts/lockup/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/contracts/lockup/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/contracts/lockup-prime/abi.d.ts

@@ -0,0 +1,348 @@
+/**
+ * LockupPrime Smart Contract ABI
+ *
+ * Standard ABI format
+ * Based on: /root/node/ex/native/rdb/src/consensus/bic/lockup_prime.rs
+ */
+export declare const LOCKUP_PRIME_ABI: {
+    readonly contractName: "LockupPrime";
+    readonly contractVersion: "1.0.0";
+    readonly abi: readonly [{
+        readonly type: "function";
+        readonly name: "lock";
+        readonly inputs: readonly [{
+            readonly name: "amount";
+            readonly type: "string";
+            readonly description: "Amount in flat units (as string, must be > 1 flat unit)";
+            readonly validation: {
+                readonly min: "1";
+                readonly type: "i128";
+            };
+        }, {
+            readonly name: "tier";
+            readonly type: "string";
+            readonly description: "Lock tier";
+            readonly enum: readonly ["7d", "30d", "90d", "180d", "365d"];
+        }];
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly description: "Lock AMA tokens for a specified tier to earn PRIME points";
+        readonly requirements: readonly ["amount > 1 flat unit", "sufficient AMA balance", "amount and tier must be UTF-8 encoded strings"];
+        readonly storage: {
+            readonly writes: readonly [{
+                readonly key: "bic:lockup_prime:vault:{caller}:{vault_index}";
+                readonly value: "{tier}-{multiplier}-{unlock_epoch}-{amount}";
+                readonly description: "Creates a new vault entry";
+            }, {
+                readonly key: "bic:lockup_prime:unique_index";
+                readonly operation: "increment";
+                readonly description: "Increments global vault index counter";
+            }, {
+                readonly key: "bic:coin:balance:{caller}:AMA";
+                readonly operation: "decrement";
+                readonly amount: "amount";
+                readonly description: "Deducts AMA from caller's balance";
+            }];
+            readonly reads: readonly [{
+                readonly key: "bic:coin:balance:{caller}:AMA";
+                readonly description: "Checks caller's AMA balance";
+            }];
+        };
+    }, {
+        readonly type: "function";
+        readonly name: "unlock";
+        readonly inputs: readonly [{
+            readonly name: "vaultIndex";
+            readonly type: "string";
+            readonly description: "Vault index to unlock (as string, e.g., \"0\", \"1\", \"2\")";
+        }];
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly description: "Unlock a vault and receive PRIME points (or penalty if early)";
+        readonly requirements: readonly ["vault must exist", "vault must belong to caller"];
+        readonly storage: {
+            readonly reads: readonly [{
+                readonly key: "bic:lockup_prime:vault:{caller}:{vault_index}";
+                readonly value: "{tier}-{multiplier}-{unlock_epoch}-{amount}";
+                readonly description: "Reads vault data";
+            }];
+            readonly writes: readonly [{
+                readonly key: "bic:lockup_prime:vault:{caller}:{vault_index}";
+                readonly operation: "delete";
+                readonly description: "Deletes vault after unlock";
+            }, {
+                readonly condition: "if current_epoch < unlock_epoch (early unlock)";
+                readonly writes: readonly [{
+                    readonly key: "bic:coin:balance:{treasury}:AMA";
+                    readonly operation: "increment";
+                    readonly amount: "penalty (25% of amount)";
+                    readonly description: "Penalty sent to treasury";
+                }, {
+                    readonly key: "bic:lockup:vault:{caller}:{index}";
+                    readonly operation: "create";
+                    readonly amount: "disbursement (75% of amount)";
+                    readonly duration: "5 epochs";
+                    readonly description: "Remaining amount locked for 5 epochs";
+                }];
+            }, {
+                readonly condition: "if current_epoch >= unlock_epoch (normal unlock)";
+                readonly writes: readonly [{
+                    readonly key: "bic:coin:balance:{caller}:PRIME";
+                    readonly operation: "mint";
+                    readonly amount: "amount * multiplier";
+                    readonly description: "Mints PRIME points";
+                }, {
+                    readonly key: "bic:coin:balance:{caller}:AMA";
+                    readonly operation: "increment";
+                    readonly amount: "amount";
+                    readonly description: "Returns locked AMA";
+                }];
+            }];
+        };
+    }, {
+        readonly type: "function";
+        readonly name: "daily_checkin";
+        readonly inputs: readonly [{
+            readonly name: "vaultIndex";
+            readonly type: "string";
+            readonly description: "Vault index for checkin (as string, e.g., \"0\", \"1\", \"2\")";
+        }];
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly description: "Daily checkin to earn bonus PRIME points and maintain streak";
+        readonly requirements: readonly ["vault must exist", "must be within 2-epoch checkin window", "vault must belong to caller"];
+        readonly storage: {
+            readonly reads: readonly [{
+                readonly key: "bic:lockup_prime:vault:{caller}:{vault_index}";
+                readonly value: "{tier}-{multiplier}-{unlock_epoch}-{amount}";
+                readonly description: "Reads vault amount for bonus calculation";
+            }, {
+                readonly key: "bic:lockup_prime:next_checkin_epoch:{caller}";
+                readonly value: "epoch (as string)";
+                readonly description: "Next allowed checkin epoch";
+            }];
+            readonly writes: readonly [{
+                readonly condition: "if delta == 0 || delta == 1 (valid checkin)";
+                readonly writes: readonly [{
+                    readonly key: "bic:lockup_prime:next_checkin_epoch:{caller}";
+                    readonly value: "current_epoch + 2";
+                    readonly description: "Updates next checkin epoch";
+                }, {
+                    readonly key: "bic:coin:balance:{caller}:PRIME";
+                    readonly operation: "mint";
+                    readonly amount: "unlock_amount / 100";
+                    readonly description: "Daily bonus (1% of locked amount)";
+                }, {
+                    readonly key: "bic:lockup_prime:daily_streak:{caller}";
+                    readonly operation: "increment";
+                    readonly description: "Increments streak counter";
+                }, {
+                    readonly condition: "if streak >= 30";
+                    readonly writes: readonly [{
+                        readonly key: "bic:lockup_prime:daily_streak:{caller}";
+                        readonly value: "0";
+                        readonly description: "Resets streak after bonus";
+                    }, {
+                        readonly key: "bic:coin:balance:{caller}:PRIME";
+                        readonly operation: "mint";
+                        readonly amount: "daily_bonus * 30";
+                        readonly description: "Streak bonus (30x daily bonus)";
+                    }];
+                }];
+            }, {
+                readonly condition: "if delta > 2 (missed checkin)";
+                readonly writes: readonly [{
+                    readonly key: "bic:lockup_prime:next_checkin_epoch:{caller}";
+                    readonly value: "current_epoch + 2";
+                    readonly description: "Resets next checkin epoch";
+                }, {
+                    readonly key: "bic:lockup_prime:daily_streak:{caller}";
+                    readonly value: "0";
+                    readonly description: "Resets streak to 0";
+                }];
+            }];
+        };
+    }];
+    readonly errors: readonly [{
+        readonly name: "invalid_args";
+        readonly code: "INVALID_ARGS";
+        readonly description: "Invalid number of arguments";
+    }, {
+        readonly name: "invalid_amount";
+        readonly code: "INVALID_AMOUNT";
+        readonly description: "Amount must be > 1 flat unit and valid i128";
+    }, {
+        readonly name: "invalid_tier";
+        readonly code: "INVALID_TIER";
+        readonly description: "Tier must be one of: 7d, 30d, 90d, 180d, 365d";
+    }, {
+        readonly name: "insufficient_funds";
+        readonly code: "INSUFFICIENT_FUNDS";
+        readonly description: "Insufficient AMA balance";
+    }, {
+        readonly name: "invalid_vault";
+        readonly code: "INVALID_VAULT";
+        readonly description: "Vault does not exist or does not belong to caller";
+    }, {
+        readonly name: "invalid_multiplier";
+        readonly code: "INVALID_MULTIPLIER";
+        readonly description: "Invalid multiplier value in vault data";
+    }, {
+        readonly name: "invalid_unlock_epoch";
+        readonly code: "INVALID_UNLOCK_EPOCH";
+        readonly description: "Invalid unlock epoch value in vault data";
+    }, {
+        readonly name: "invalid_unlock_amount";
+        readonly code: "INVALID_UNLOCK_AMOUNT";
+        readonly description: "Invalid unlock amount value in vault data";
+    }, {
+        readonly name: "invalid_next_checkin_epoch";
+        readonly code: "INVALID_NEXT_CHECKIN_EPOCH";
+        readonly description: "Invalid next checkin epoch value";
+    }];
+    readonly storage: {
+        readonly keys: readonly [{
+            readonly name: "vault";
+            readonly pattern: "bic:lockup_prime:vault:{account}:{vault_index}";
+            readonly type: "mapping";
+            readonly description: "Vault data for each account and vault index";
+            readonly valueFormat: "{tier}-{multiplier}-{unlock_epoch}-{amount}";
+            readonly valueSchema: {
+                readonly tier: {
+                    readonly type: "string";
+                    readonly enum: readonly ["7d", "30d", "90d", "180d", "365d"];
+                };
+                readonly multiplier: {
+                    readonly type: "string";
+                    readonly description: "Multiplier as string (e.g., \"17\", \"27\")";
+                    readonly parseAs: "u64";
+                };
+                readonly unlock_epoch: {
+                    readonly type: "string";
+                    readonly description: "Unlock epoch as string";
+                    readonly parseAs: "u64";
+                };
+                readonly amount: {
+                    readonly type: "string";
+                    readonly description: "Locked amount in flat units as string";
+                    readonly parseAs: "u64";
+                };
+            };
+            readonly query: {
+                readonly method: "POST";
+                readonly endpoint: "/api/contract/get_prefix";
+                readonly prefix: "bic:lockup_prime:vault:{account_binary}:";
+                readonly description: "Get all vaults for an account. Returns array of [key, value] tuples.";
+            };
+        }, {
+            readonly name: "daily_streak";
+            readonly pattern: "bic:lockup_prime:daily_streak:{account}";
+            readonly type: "value";
+            readonly description: "Current daily checkin streak count";
+            readonly valueFormat: "string (number)";
+            readonly valueSchema: {
+                readonly type: "string";
+                readonly parseAs: "u64";
+                readonly description: "Streak count as string (e.g., \"5\", \"0\")";
+            };
+            readonly query: {
+                readonly method: "POST";
+                readonly endpoint: "/api/contract/get";
+                readonly key: "bic:lockup_prime:daily_streak:{account_binary}";
+                readonly description: "Get daily streak for an account";
+            };
+        }, {
+            readonly name: "next_checkin_epoch";
+            readonly pattern: "bic:lockup_prime:next_checkin_epoch:{account}";
+            readonly type: "value";
+            readonly description: "Next epoch when checkin is allowed";
+            readonly valueFormat: "string (number)";
+            readonly valueSchema: {
+                readonly type: "string";
+                readonly parseAs: "u64";
+                readonly description: "Epoch as string (e.g., \"145\", \"200\")";
+            };
+            readonly query: {
+                readonly method: "POST";
+                readonly endpoint: "/api/contract/get";
+                readonly key: "bic:lockup_prime:next_checkin_epoch:{account_binary}";
+                readonly description: "Get next checkin epoch for an account";
+            };
+        }, {
+            readonly name: "unique_index";
+            readonly pattern: "bic:lockup_prime:unique_index";
+            readonly type: "value";
+            readonly description: "Global vault index counter";
+            readonly valueFormat: "string (number)";
+            readonly valueSchema: {
+                readonly type: "string";
+                readonly parseAs: "u64";
+                readonly description: "Global counter as string";
+            };
+            readonly query: {
+                readonly method: "POST";
+                readonly endpoint: "/api/contract/get";
+                readonly key: "bic:lockup_prime:unique_index";
+                readonly description: "Get global vault index counter";
+            };
+        }];
+    };
+    readonly constants: {
+        readonly tiers: {
+            readonly '7d': {
+                readonly epochs: 10;
+                readonly multiplier: 13;
+                readonly label: "7 Days";
+            };
+            readonly '30d': {
+                readonly epochs: 45;
+                readonly multiplier: 17;
+                readonly label: "30 Days";
+            };
+            readonly '90d': {
+                readonly epochs: 135;
+                readonly multiplier: 27;
+                readonly label: "90 Days";
+            };
+            readonly '180d': {
+                readonly epochs: 270;
+                readonly multiplier: 35;
+                readonly label: "180 Days";
+            };
+            readonly '365d': {
+                readonly epochs: 547;
+                readonly multiplier: 54;
+                readonly label: "365 Days";
+            };
+        };
+        readonly values: {
+            readonly MIN_LOCK_AMOUNT: "1";
+            readonly DAILY_BONUS_PERCENTAGE: "100";
+            readonly STREAK_BONUS_THRESHOLD: "30";
+            readonly STREAK_BONUS_MULTIPLIER: "30";
+            readonly EARLY_UNLOCK_PENALTY: "0.25";
+            readonly EARLY_UNLOCK_LOCK_DURATION: "5";
+            readonly CHECKIN_WINDOW: "2";
+        };
+    };
+    readonly encoding: {
+        readonly args: {
+            readonly format: "UTF-8 encoded strings";
+            readonly description: "All function arguments must be UTF-8 encoded as Uint8Array using TextEncoder";
+            readonly example: {
+                readonly lock: readonly ["new TextEncoder().encode('1000000000000')", "new TextEncoder().encode('30d')"];
+            };
+        };
+        readonly storage: {
+            readonly keys: {
+                readonly format: "Binary (48 bytes for account)";
+                readonly description: "Storage keys use binary account addresses, not base58";
+            };
+            readonly values: {
+                readonly format: "UTF-8 strings";
+                readonly description: "All storage values are UTF-8 encoded strings";
+            };
+        };
+    };
+};
+//# sourceMappingURL=abi.d.ts.map

package/dist/contracts/lockup-prime/abi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abi.d.ts","sourceRoot":"","sources":["../../../src/contracts/lockup-prime/abi.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8ZnB,CAAA"}