@wuwei-labs/srsly 2.0.0-beta.4 → 2.0.0-beta.41

package/dist/cjs/contract/create.js

@@ -1,58 +1,167 @@
 "use strict";
+/**
+ * # Contract Creation Module
+ *
+ * This module provides functionality for creating rental contracts on the SRSLY program.
+ * It offers a unified API that works with both @solana/kit and @solana/web3.js libraries,
+ * using strings for all addresses to eliminate library-specific type complexity.
+ *
+ * ## Features
+ *
+ * - **Universal Compatibility**: Works with both major Solana libraries
+ * - **Fluent API**: Chainable configuration and format conversion
+ * - **Validation**: Built-in parameter validation and duration alignment checking
+ * - **Network Agnostic**: Supports mainnet, devnet, and custom configurations
+ *
+ * @module Contract/Create
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createContract = createContract;
-exports.getCreateContractInstructionAsync = getCreateContractInstructionAsync;
-const network_1 = require("../network");
-const utils_1 = require("../utils");
+const config_1 = require("../utils/config");
+const constants_1 = require("../utils/constants");
+const paymentFrequency_1 = require("../utils/paymentFrequency");
+const paymentFrequency_2 = require("../types/paymentFrequency");
+const instruction_converter_1 = require("../utils/instruction-converter");
 /**
- * Internal function to create a contract instruction for a specific network
+ * Internal function to create a rental contract instruction with configuration options.
+ *
+ * This function handles the core logic of creating a contract instruction, including
+ * parameter validation, address resolution, and instruction generation. It's used
+ * internally by the public createContract function.
+ *
+ * @internal
+ * @param params - The contract creation parameters
+ * @param config - Optional configuration for network and program settings
+ * @returns Promise resolving to a fluent instruction object
+ * @throws Error when validation fails or required parameters are missing
  */
-async function _createContract(params, network) {
-    const { owner, fleet, ownerProfile, rate, durationMin, durationMax, paymentsFreq, ownerKeyIndex = 0, gameId = utils_1.DEFAULT_GAME_ID, } = params;
-    // Dynamically import network-specific codama functions
-    const codamaModule = await (0, network_1.getCachedNetworkModule)('instructions', network);
-    const { getCreateContractInstructionAsync, SRSLY_PROGRAM_ADDRESS } = codamaModule;
-    // Let codama derive the rest (contract, rentalAuthority, ownerTokenAccount, etc.)
+async function _createContract(params, config) {
+    const { owner, fleet, ownerProfile, rate, durationMin: customDurationMin, durationMax, paymentsFreq, ownerKeyIndex = 0, } = params;
+    // Validate payment frequency
+    if (!(0, paymentFrequency_2.isValidPaymentFrequency)(paymentsFreq)) {
+        throw new Error(`Invalid payment frequency: "${paymentsFreq}". Valid values are: ${JSON.stringify(Object.keys({ daily: true, weekly: true, monthly: true, hourly: true }))}`);
+    }
+    // Get the payment frequency interval
+    const paymentFrequencySeconds = (0, paymentFrequency_1.paymentFrequencyStringToSeconds)(paymentsFreq);
+    // Use custom durationMin if provided, otherwise default to 1 payment frequency period
+    const durationMin = customDurationMin ?? paymentFrequencySeconds;
+    // Validate duration alignment for both min and max
+    (0, paymentFrequency_1.validateDurationAlignment)(Number(durationMin), paymentsFreq);
+    (0, paymentFrequency_1.validateDurationAlignment)(Number(durationMax), paymentsFreq);
+    // Validate that max is greater than or equal to min
+    if (durationMax < durationMin) {
+        throw new Error(`Maximum duration (${durationMax}s) must be greater than or equal to minimum duration (${durationMin}s)`);
+    }
+    // Convert the payment frequency to the format expected by the Rust program (with @ prefix)
+    const paymentsFreqWithPrefix = `@${paymentsFreq}`;
+    // Get the resolved addresses from config (including network-specific addresses)
+    const resolvedAddresses = await (0, config_1.resolveProgramAddresses)(config || {});
     const input = {
-        owner,
-        fleet,
-        ownerProfile,
-        gameId,
-        rate,
+        owner, // Pass as-is (string or signer)
+        fleet: (0, constants_1.toAddress)(fleet), // Convert fleet to Address
+        ownerProfile: (0, constants_1.toAddress)(ownerProfile), // Convert ownerProfile to Address
+        gameId: resolvedAddresses.gameId, // Already Address from resolveProgramAddresses
+        sageProgram: resolvedAddresses.sageProgramAddress, // Already Address from resolveProgramAddresses
+        mint: resolvedAddresses.atlasMint, // Already Address from resolveProgramAddresses
         durationMin,
         durationMax,
-        paymentsFeq: paymentsFreq,
+        rate,
+        paymentsFeq: paymentsFreqWithPrefix, // Fixed: use paymentsFeq as expected by codama
         ownerKeyIndex,
     };
-    return getCreateContractInstructionAsync(input, { programAddress: SRSLY_PROGRAM_ADDRESS });
+    // Get network-specific codama functions from centralized config
+    const instructionsModule = (0, config_1.getModule)('instructions');
+    const programsModule = (0, config_1.getModule)('programs');
+    const { getCreateContractInstructionAsync } = instructionsModule;
+    const { SRSLY_PROGRAM_ADDRESS } = programsModule;
+    const rawInstruction = await getCreateContractInstructionAsync(input, { programAddress: SRSLY_PROGRAM_ADDRESS });
+    return (0, instruction_converter_1.createFluentInstruction)(rawInstruction);
 }
 /**
- * Creates an instruction to create a rental contract with fluent network selection.
+ * Creates an instruction to create a rental contract with fluent configuration.
+ *
+ * This is the main function for creating rental contracts on the SRSLY program.
+ * It provides a unified API that works with both @solana/kit and @solana/web3.js
+ * libraries, using strings for all addresses to eliminate compatibility issues.
+ *
+ * ## Features
+ *
+ * - **Universal Library Support**: Works with both @solana/kit and @solana/web3.js
+ * - **Fluent Configuration**: Chain configuration options with `.set()`
+ * - **Format Conversion**: Convert between library formats with `.web3js()`
+ * - **Validation**: Built-in parameter validation and duration alignment
+ * - **Network Support**: Configurable for different Solana networks
+ *
+ * ## Validation
+ *
+ * The function automatically validates:
+ * - Payment frequency is supported
+ * - Duration alignment with payment frequency
+ * - Required parameters are provided
+ *
+ * ## Process
+ *
+ * 1. **Validate Parameters**: Checks payment frequency and duration alignment
+ * 2. **Resolve Addresses**: Gets network-specific program and mint addresses
+ * 3. **Generate Instruction**: Creates the contract creation instruction
+ * 4. **Return Fluent Object**: Allows for configuration and format conversion
  *
  * @example
  * ```typescript
- * // Use global network setting
- * const ix = await createContract(params).execute();
+ * import { createContract, days, hours } from '@srsly/sdk';
+ *
+ * // Basic usage - returns @solana/kit format by default
+ * const instruction = await createContract({
+ *   owner: wallet,                    // Can be signer object or string
+ *   fleet: "FleetAddress123...",      // String address
+ *   ownerProfile: "ProfileAddr...",   // String address
+ *   rate: 1000,                      // 1000 ATLAS per payment period
+ *   durationMax: days(7),            // 7 days maximum rental
+ *   paymentsFreq: 'daily'            // Daily payments
+ * });
  *
- * // Use specific network for this instruction
- * const ix = await createContract(params).mainnet();
- * const ix = await createContract(params).devnet();
- * const ix = await createContract(params).network('mainnet');
+ * // With custom minimum duration
+ * const customMinInstruction = await createContract({
+ *   owner: wallet,
+ *   fleet: "FleetAddress123...",
+ *   ownerProfile: "ProfileAddr...",
+ *   rate: 100,                       // 100 ATLAS per hour
+ *   durationMin: hours(10),          // 10 hours minimum rental
+ *   durationMax: hours(24),          // 24 hours maximum rental
+ *   paymentsFreq: 'hourly'           // Hourly payments
+ * });
+ *
+ * // Convert to @solana/web3.js format
+ * const web3jsInstruction = await createContract({
+ *   owner: wallet,
+ *   fleet: "FleetAddress123...",
+ *   ownerProfile: "ProfileAddr...",
+ *   rate: 1000,
+ *   durationMax: days(7),
+ *   paymentsFreq: 'daily'
+ * }).web3js();
+ *
+ * // Configure network and convert format
+ * const mainnetInstruction = await createContract({
+ *   owner: wallet,
+ *   fleet: "FleetAddress123...",
+ *   ownerProfile: "ProfileAddr...",
+ *   rate: 1000,
+ *   durationMax: days(7),
+ *   paymentsFreq: 'daily'
+ * }).set({ programs: 'mainnet' }).web3js();
+ *
+ * // Use with your preferred Solana library
+ * const transaction = new Transaction().add(web3jsInstruction);
+ * await sendAndConfirmTransaction(connection, transaction, [wallet]);
  * ```
  *
- * @param params The simplified parameters for creating a rental contract
- * @returns A network selector for creating the instruction
+ * @param params - The contract creation parameters including owner, fleet, rate, and duration
+ * @returns A FluentConfigSelector that can be configured with .set() or awaited directly
+ * @throws Error when payment frequency is invalid or duration alignment fails
  */
 function createContract(params) {
-    return (0, network_1.createNetworkSelector)((network) => _createContract(params, network));
-}
-/**
- * Export network selector for getCreateContractInstructionAsync
- */
-function getCreateContractInstructionAsync(input, options) {
-    return (0, network_1.createNetworkSelector)(async (network) => {
-        const codamaModule = await (0, network_1.getCachedNetworkModule)('instructions', network);
-        return codamaModule.getCreateContractInstructionAsync(input, options);
-    });
+    const baseSelector = (0, config_1.createConfigSelector)((config) => _createContract(params, config));
+    return (0, instruction_converter_1.createSmartFluentConfigSelector)(baseSelector);
 }
 //# sourceMappingURL=create.js.map

package/dist/cjs/contract/create.js.map

@@ -1 +1 @@
-{"version":3,"file":"create.js","sourceRoot":"","sources":["../../../src/contract/create.ts"],"names":[],"mappings":";;AA8HA,wCAIC;AAKD,8EAKC;AAvID,wCAA+G;AAK/G,oCAGkB;AAsDlB;;GAEG;AACH,KAAK,UAAU,eAAe,CAC5B,MAA4B,EAC5B,OAAiB;IAEjB,MAAM,EACJ,KAAK,EACL,KAAK,EACL,YAAY,EACZ,IAAI,EACJ,WAAW,EACX,WAAW,EACX,YAAY,EACZ,aAAa,GAAG,CAAC,EACjB,MAAM,GAAG,uBAAkC,GAC5C,GAAG,MAAM,CAAC;IAEX,uDAAuD;IACvD,MAAM,YAAY,GAAG,MAAM,IAAA,gCAAsB,EAAC,cAAc,EAAE,OAAO,CAAC,CAAC;IAC3E,MAAM,EAAE,iCAAiC,EAAE,qBAAqB,EAAE,GAAG,YAAY,CAAC;IAElF,kFAAkF;IAClF,MAAM,KAAK,GAAG;QACZ,KAAK;QACL,KAAK;QACL,YAAY;QACZ,MAAM;QACN,IAAI;QACJ,WAAW;QACX,WAAW;QACX,WAAW,EAAE,YAAY;QACzB,aAAa;KACd,CAAC;IAEF,OAAO,iCAAiC,CACtC,KAAK,EACL,EAAE,cAAc,EAAE,qBAAqB,EAAE,CAC1C,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,cAAc,CAC5B,MAA4B;IAE5B,OAAO,IAAA,+BAAqB,EAAC,CAAC,OAAO,EAAE,EAAE,CAAC,eAAe,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAC9E,CAAC;AAED;;GAEG;AACH,SAAgB,iCAAiC,CAAC,KAAU,EAAE,OAAa;IACzE,OAAO,IAAA,+BAAqB,EAAC,KAAK,EAAE,OAAO,EAAE,EAAE;QAC7C,MAAM,YAAY,GAAG,MAAM,IAAA,gCAAsB,EAAC,cAAc,EAAE,OAAO,CAAC,CAAC;QAC3E,OAAO,YAAY,CAAC,iCAAiC,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACxE,CAAC,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"create.js","sourceRoot":"","sources":["../../../src/contract/create.ts"],"names":[],"mappings":"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"}

package/dist/cjs/contract/index.js

@@ -1,4 +1,49 @@
 "use strict";
+/**
+ * # Contract Management Module
+ *
+ * This module provides comprehensive functionality for managing rental contracts
+ * on the SRSLY program. It includes functions for creating and closing contracts,
+ * with full support for both @solana/kit and @solana/web3.js libraries.
+ *
+ * ## Available Functions
+ *
+ * - **createContract**: Create a new rental contract for a fleet
+ * - **closeContract**: Permanently close an existing rental contract
+ *
+ * ## Features
+ *
+ * - **Universal Library Support**: Works with both major Solana libraries
+ * - **String-Based Addresses**: Eliminates library-specific type conflicts
+ * - **Fluent API**: Chainable configuration and format conversion
+ * - **Network Agnostic**: Supports different Solana networks
+ * - **Validation**: Built-in parameter validation and error checking
+ *
+ * @example
+ * ```typescript
+ * import { createContract, closeContract, days } from '@srsly/sdk';
+ *
+ * // Create a rental contract
+ * const createInstruction = await createContract({
+ *   owner: wallet,
+ *   fleet: "FleetAddress123...",
+ *   ownerProfile: "ProfileAddr...",
+ *   rate: 1000,
+ *   durationMax: days(30),
+ *   paymentsFreq: 'daily'
+ * });
+ *
+ * // Close the contract later
+ * const closeInstruction = await closeContract({
+ *   owner: wallet,
+ *   fleet: "FleetAddress123...",
+ *   contract: "ContractAddr...",
+ *   faction: 'mud'
+ * });
+ * ```
+ *
+ * @module Contract
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/dist/cjs/contract/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/contract/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAuB;AACvB,2CAAwB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/contract/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;;;;;;;;;;;;;;;;AAEH,0CAAuB;AACvB,2CAAwB"}

package/dist/cjs/index.js

@@ -1,4 +1,55 @@
 "use strict";
+/**
+ * # SRSLY SDK - Solana Rental System Library
+ *
+ * A comprehensive TypeScript SDK for interacting with the SRSLY Solana program,
+ * which facilitates fleet rentals in the Star Atlas ecosystem. This SDK provides
+ * a fluent, developer-friendly interface that works with both @solana/kit and
+ * @solana/web3.js libraries.
+ *
+ * ## Features
+ *
+ * - **Universal Compatibility**: Works with both @solana/kit and @solana/web3.js
+ * - **Fluent API**: Chainable methods for intuitive development experience
+ * - **String-Based Addresses**: Uses strings for all addresses to eliminate library conflicts
+ * - **Network Agnostic**: Supports mainnet, devnet, and custom RPC endpoints
+ * - **Type Safety**: Full TypeScript support with comprehensive type definitions
+ * - **Auto-Generated Types**: Types generated from Solana program IDL for accuracy
+ *
+ * ## Quick Start
+ *
+ * ```typescript
+ * import { createContract, acceptRental, days } from '@srsly/sdk';
+ *
+ * // Create a rental contract
+ * const instruction = await createContract({
+ *   owner: wallet,
+ *   fleet: "FleetAddress123...",
+ *   ownerProfile: "ProfileAddr...",
+ *   rate: 1000,
+ *   durationMax: days(7),
+ *   paymentsFreq: 'daily'
+ * });
+ *
+ * // Accept a rental
+ * const rentalInstruction = await acceptRental({
+ *   borrower: borrowerWallet,
+ *   contract: contractAddress,
+ *   amount: 7000,
+ *   duration: days(7)
+ * });
+ * ```
+ *
+ * ## Architecture
+ *
+ * The SDK is organized into several main modules:
+ * - **Contract**: Functions for creating and managing rental contracts
+ * - **Rental**: Functions for rental operations (accept, cancel, close)
+ * - **Utils**: Helper functions for duration, payment frequency, and account management
+ * - **Types**: TypeScript type definitions and interfaces
+ *
+ * @packageDocumentation
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -14,10 +65,91 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-// Export network configuration
-__exportStar(require("./network"), exports);
+exports.duration = exports.months = exports.weeks = exports.days = exports.hours = exports.minutes = exports.validateDurationAlignment = exports.paymentFrequencyStringToSeconds = exports.paymentFrequencyToSeconds = exports.isValidPaymentFrequency = exports.getPaymentFrequencyFromString = exports.PAYMENT_FREQUENCY_CONSTANTS = exports.PAYMENT_FREQUENCY_MAP = exports.VALID_PAYMENT_FREQUENCIES = exports.PaymentFrequency = exports.fetchMultipleRentalStates = exports.fetchMultipleContractStates = exports.fetchRentalState = exports.fetchContractState = void 0;
 // Export main SDK functions
 __exportStar(require("./contract"), exports);
 __exportStar(require("./rental"), exports);
 __exportStar(require("./utils"), exports);
+/**
+ * Account fetch functions that work with any RPC endpoint.
+ *
+ * These functions accept RPC URL strings and return account data,
+ * making it easy to fetch program state from any network.
+ *
+ * @example
+ * ```typescript
+ * const contract = await fetchContractState(
+ *   "https://api.mainnet-beta.solana.com",
+ *   contractAddress
+ * );
+ * ```
+ */
+var fetch_accounts_1 = require("./utils/fetch-accounts");
+Object.defineProperty(exports, "fetchContractState", { enumerable: true, get: function () { return fetch_accounts_1.fetchContractState; } });
+Object.defineProperty(exports, "fetchRentalState", { enumerable: true, get: function () { return fetch_accounts_1.fetchRentalState; } });
+Object.defineProperty(exports, "fetchMultipleContractStates", { enumerable: true, get: function () { return fetch_accounts_1.fetchMultipleContractStates; } });
+Object.defineProperty(exports, "fetchMultipleRentalStates", { enumerable: true, get: function () { return fetch_accounts_1.fetchMultipleRentalStates; } });
+/**
+ * Payment frequency enum generated from the Rust program.
+ *
+ * This enum mirrors the Rust PaymentFrequency type and provides
+ * type-safe payment frequency values for contract creation.
+ */
+var paymentFrequency_1 = require("./codama/types/paymentFrequency");
+Object.defineProperty(exports, "PaymentFrequency", { enumerable: true, get: function () { return paymentFrequency_1.PaymentFrequency; } });
+/**
+ * Payment frequency types and validation utilities.
+ *
+ * These exports provide string-based payment frequency handling,
+ * validation functions, and mapping between different representations.
+ *
+ * @example
+ * ```typescript
+ * if (isValidPaymentFrequency('daily')) {
+ *   const frequency = getPaymentFrequencyFromString('daily');
+ * }
+ * ```
+ */
+var paymentFrequency_2 = require("./types/paymentFrequency");
+Object.defineProperty(exports, "VALID_PAYMENT_FREQUENCIES", { enumerable: true, get: function () { return paymentFrequency_2.VALID_PAYMENT_FREQUENCIES; } });
+Object.defineProperty(exports, "PAYMENT_FREQUENCY_MAP", { enumerable: true, get: function () { return paymentFrequency_2.PAYMENT_FREQUENCY_MAP; } });
+Object.defineProperty(exports, "PAYMENT_FREQUENCY_CONSTANTS", { enumerable: true, get: function () { return paymentFrequency_2.PAYMENT_FREQUENCY_CONSTANTS; } });
+Object.defineProperty(exports, "getPaymentFrequencyFromString", { enumerable: true, get: function () { return paymentFrequency_2.getPaymentFrequencyFromString; } });
+Object.defineProperty(exports, "isValidPaymentFrequency", { enumerable: true, get: function () { return paymentFrequency_2.isValidPaymentFrequency; } });
+/**
+ * Payment frequency utilities that mirror the Rust program implementation.
+ *
+ * These functions provide conversion between payment frequencies and time durations,
+ * ensuring consistency with the on-chain program logic.
+ *
+ * @example
+ * ```typescript
+ * const seconds = paymentFrequencyStringToSeconds('weekly');
+ * validateDurationAlignment(duration, 'daily');
+ * ```
+ */
+var paymentFrequency_3 = require("./utils/paymentFrequency");
+Object.defineProperty(exports, "paymentFrequencyToSeconds", { enumerable: true, get: function () { return paymentFrequency_3.paymentFrequencyToSeconds; } });
+Object.defineProperty(exports, "paymentFrequencyStringToSeconds", { enumerable: true, get: function () { return paymentFrequency_3.paymentFrequencyStringToSeconds; } });
+Object.defineProperty(exports, "validateDurationAlignment", { enumerable: true, get: function () { return paymentFrequency_3.validateDurationAlignment; } });
+/**
+ * Duration helper functions for convenient time unit conversion.
+ *
+ * These functions make it easy to specify durations in human-readable terms
+ * and convert them to the seconds required by the program.
+ *
+ * @example
+ * ```typescript
+ * const rentalDuration = days(7);           // 7 days in seconds
+ * const paymentPeriod = hours(6);           // 6 hours in seconds
+ * const longRental = duration(2, 'weeks');  // 2 weeks in seconds
+ * ```
+ */
+var duration_1 = require("./utils/duration");
+Object.defineProperty(exports, "minutes", { enumerable: true, get: function () { return duration_1.minutes; } });
+Object.defineProperty(exports, "hours", { enumerable: true, get: function () { return duration_1.hours; } });
+Object.defineProperty(exports, "days", { enumerable: true, get: function () { return duration_1.days; } });
+Object.defineProperty(exports, "weeks", { enumerable: true, get: function () { return duration_1.weeks; } });
+Object.defineProperty(exports, "months", { enumerable: true, get: function () { return duration_1.months; } });
+Object.defineProperty(exports, "duration", { enumerable: true, get: function () { return duration_1.duration; } });
 //# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+BAA+B;AAC/B,4CAA0B;AAE1B,4BAA4B;AAC5B,6CAA2B;AAC3B,2CAAyB;AACzB,0CAAwB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;;;;;;;;;;;;;;;;;AAEH,4BAA4B;AAC5B,6CAA2B;AAC3B,2CAAyB;AACzB,0CAAwB;AAyBxB;;;;;;;;;;;;;GAaG;AACH,yDAKgC;AAJ9B,oHAAA,kBAAkB,OAAA;AAClB,kHAAA,gBAAgB,OAAA;AAChB,6HAAA,2BAA2B,OAAA;AAC3B,2HAAA,yBAAyB,OAAA;AAG3B;;;;;GAKG;AACH,oEAAmE;AAA1D,oHAAA,gBAAgB,OAAA;AAEzB;;;;;;;;;;;;GAYG;AACH,6DAOkC;AALhC,6HAAA,yBAAyB,OAAA;AACzB,yHAAA,qBAAqB,OAAA;AACrB,+HAAA,2BAA2B,OAAA;AAC3B,iIAAA,6BAA6B,OAAA;AAC7B,2HAAA,uBAAuB,OAAA;AAGzB;;;;;;;;;;;GAWG;AACH,6DAIkC;AAHhC,6HAAA,yBAAyB,OAAA;AACzB,mIAAA,+BAA+B,OAAA;AAC/B,6HAAA,yBAAyB,OAAA;AAG3B;;;;;;;;;;;;GAYG;AACH,6CAO0B;AANxB,mGAAA,OAAO,OAAA;AACP,iGAAA,KAAK,OAAA;AACL,gGAAA,IAAI,OAAA;AACJ,iGAAA,KAAK,OAAA;AACL,kGAAA,MAAM,OAAA;AACN,oGAAA,QAAQ,OAAA"}

package/dist/cjs/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@wuwei-labs/srsly",
+  "version": "2.0.0-beta.41",
+  "description": "",
+  "source": "./src/index.ts",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/cjs",
+    "dist/esm",
+    "dist/types",
+    "target/idl/srsly.json",
+    "target/types/srsly.ts"
+  ],
+  "keywords": [
+    "SRSLY",
+    "Star",
+    "Atlas",
+    "sdk"
+  ],
+  "scripts": {
+    "build": "anchor run build && pnpm run package:cjs && pnpm run package:esm && pnpm run generate",
+    "build:clean": "pnpm run clean && pnpm run build",
+    "package:cjs": "tsc -p tsconfig.cjs.json && tsconfig-to-dual-package tsconfig.cjs.json",
+    "package:esm": "tsc -p tsconfig.esm.json && tsconfig-to-dual-package tsconfig.esm.json",
+    "clean": "rm -rf dist && cargo clean && pnpm install",
+    "generate": "node generate.mjs",
+    "docs": "typedoc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@10.6.5",
+  "dependencies": {
+    "@solana/kit": "^2.1.1"
+  },
+  "devDependencies": {
+    "@codama/nodes-from-anchor": "^1.1.13",
+    "@codama/renderers": "^1.0.21",
+    "@types/node": "^24.0.3",
+    "codama": "^1.2.13",
+    "tsconfig-to-dual-package": "^1.2.0",
+    "typedoc": "^0.28.3",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4",
+    "webpack": "^5.99.9"
+  },
+  "type": "commonjs"
+}