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

package/dist/types/contract/create.d.ts

@@ -1,70 +1,165 @@
-import { Address, TransactionSigner } from '@solana/kit';
-import { type NetworkSelector } from '../network';
-type CreateContractInstruction = any;
 /**
- * Simplified parameters for creating a rental contract
+ * # 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
+ */
+import { PaymentFrequencyString } from '../types/paymentFrequency';
+import { type FluentInstruction, type SmartFluentConfigSelector } from '../utils/instruction-converter';
+type UniversalAddress = string;
+type UniversalSigner = any;
+/**
+ * Parameters for creating a rental contract.
+ *
+ * This interface defines all the required and optional parameters needed to create
+ * a new rental contract on the SRSLY program. All addresses are strings to ensure
+ * compatibility with both @solana/kit and @solana/web3.js libraries.
+ *
+ * @interface CreateContractParams
  */
 export interface CreateContractParams {
     /**
-     * The owner wallet that will sign the transaction
+     * The fleet owner (can be a signer object or string address).
+     * This account will receive rental payments and has control over the contract.
      */
-    owner: TransactionSigner<string>;
+    owner: UniversalSigner | UniversalAddress;
     /**
-     * The fleet account address to be rented out
+     * String address of the fleet to be rented out.
+     * Must be a valid fleet registered in the Star Atlas SAGE ecosystem.
      */
-    fleet: Address<string>;
+    fleet: UniversalAddress;
     /**
-     * The owner's profile account address
+     * String address of the owner's profile in the Star Atlas game.
+     * Used for SAGE integration and fleet ownership validation.
      */
-    ownerProfile: Address<string>;
+    ownerProfile: UniversalAddress;
     /**
-     * The rental rate in ATLAS tokens
+     * Rental rate per payment period in ATLAS tokens.
+     * This rate is multiplied by the payment frequency to determine total cost.
+     * @example 1000 // 1000 ATLAS per payment period
      */
-    rate: number | bigint;
+    rate: number;
     /**
-     * The minimum rental duration in seconds
+     * Minimum rental duration in seconds.
+     * Borrowers must rent for at least this duration.
+     * Must be a multiple of the payment frequency interval.
+     * If not provided, defaults to 1 payment frequency period.
+     * @example hours(10) // 10 hours minimum rental for hourly frequency
      */
-    durationMin: number | bigint;
+    durationMin?: number;
     /**
-     * The maximum rental duration in seconds
+     * Maximum rental duration in seconds.
+     * Borrowers cannot rent for longer than this duration.
+     * Must be a multiple of the payment frequency interval.
+     * @example days(30) // 30 days maximum rental
      */
-    durationMax: number | bigint;
+    durationMax: number;
     /**
-     * The payment frequency (e.g., "daily", "weekly", "monthly")
+     * Payment frequency for automated payments.
+     * Determines how often rental payments are processed.
+     * @example 'daily' // Payments processed every 24 hours
      */
-    paymentsFreq: string;
+    paymentsFreq: PaymentFrequencyString;
     /**
-     * The owner key index
-     * Typically 0 unless the owner has multiple authorized keys
+     * Optional index of the owner's key in the SAGE system.
+     * Used for fleet validation and ownership verification.
+     * @default 0
      */
     ownerKeyIndex?: number;
-    /**
-     * The game ID account address
-     * Defaults to 'GAMEzqJehF8yAnKiTARUuhZMvLvkZVAsCVri5vSfemLr' if not provided
-     */
-    gameId?: Address<string>;
 }
 /**
- * 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
- */
-export declare function createContract(params: CreateContractParams): NetworkSelector<CreateContractInstruction>;
-/**
- * Export network selector for getCreateContractInstructionAsync
+ * @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
  */
-export declare function getCreateContractInstructionAsync(input: any, options?: any): NetworkSelector<any>;
+export declare function createContract(params: CreateContractParams): SmartFluentConfigSelector<FluentInstruction>;
 export {};
 //# sourceMappingURL=create.d.ts.map

package/dist/types/contract/create.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../src/contract/create.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAErB,OAAO,EAAiD,KAAK,eAAe,EAAgB,MAAM,YAAY,CAAC;AAG/G,KAAK,yBAAyB,GAAG,GAAG,CAAC;AAOrC;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;OAEG;IACH,KAAK,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAEjC;;OAEG;IACH,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IAEvB;;OAEG;IACH,YAAY,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IAE9B;;OAEG;IACH,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAEtB;;OAEG;IACH,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;IAE7B;;OAEG;IACH,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;IAE7B;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;CAC1B;AA4CD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,oBAAoB,GAC3B,eAAe,CAAC,yBAAyB,CAAC,CAE5C;AAED;;GAEG;AACH,wBAAgB,iCAAiC,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,eAAe,CAAC,GAAG,CAAC,CAKjG"}
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../src/contract/create.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH,OAAO,EAAE,sBAAsB,EAA2B,MAAM,2BAA2B,CAAC;AAC5F,OAAO,EAA4D,KAAK,iBAAiB,EAAE,KAAK,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAGlK,KAAK,gBAAgB,GAAG,MAAM,CAAC;AAC/B,KAAK,eAAe,GAAG,GAAG,CAAC;AAE3B;;;;;;;;GAQG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,KAAK,EAAE,eAAe,GAAG,gBAAgB,CAAC;IAE1C;;;OAGG;IACH,KAAK,EAAE,gBAAgB,CAAC;IAExB;;;OAGG;IACH,YAAY,EAAE,gBAAgB,CAAC;IAE/B;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;;OAKG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;;OAIG;IACH,YAAY,EAAE,sBAAsB,CAAC;IAErC;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AA6ED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,oBAAoB,GAAG,yBAAyB,CAAC,iBAAiB,CAAC,CAGzG"}

package/dist/types/contract/index.d.ts

@@ -1,3 +1,48 @@
+/**
+ * # 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
+ */
 export * from "./close";
 export * from "./create";
 //# sourceMappingURL=index.d.ts.map

package/dist/types/contract/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/contract/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/contract/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA"}

package/dist/types/index.d.ts

@@ -1,6 +1,120 @@
-export * from "./network";
+/**
+ * # 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
+ */
 export * from "./contract";
 export * from "./rental";
 export * from "./utils";
-export type { ContractState, RentalState, Fleet, CreateContractInstruction, AcceptRentalInstruction, CancelRentalInstruction, CloseRentalInstruction, CloseContractInstruction, ResetRentalInstruction, PaymentFrequency, ClockData, ThreadResponse } from "./codama/devnet";
+export type { KitInstruction, FluentInstruction } from "./utils/instruction-converter";
+export type { ContractState, RentalState, CreateContractInstruction, AcceptRentalInstruction, CancelRentalInstruction, CloseRentalInstruction, CloseContractInstruction, ResetRentalInstruction, ClockData, ThreadResponse } from "./codama";
+/**
+ * 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
+ * );
+ * ```
+ */
+export { fetchContractState, fetchRentalState, fetchMultipleContractStates, fetchMultipleRentalStates } from "./utils/fetch-accounts";
+/**
+ * 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.
+ */
+export { PaymentFrequency } from "./codama/types/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');
+ * }
+ * ```
+ */
+export { PaymentFrequencyString, VALID_PAYMENT_FREQUENCIES, PAYMENT_FREQUENCY_MAP, PAYMENT_FREQUENCY_CONSTANTS, getPaymentFrequencyFromString, isValidPaymentFrequency } from "./types/paymentFrequency";
+/**
+ * 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');
+ * ```
+ */
+export { paymentFrequencyToSeconds, paymentFrequencyStringToSeconds, validateDurationAlignment } from "./utils/paymentFrequency";
+/**
+ * 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
+ * ```
+ */
+export { minutes, hours, days, weeks, months, duration } from "./utils/duration";
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,cAAc,WAAW,CAAC;AAG1B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AAIxB,YAAY,EAEV,aAAa,EACb,WAAW,EACX,KAAK,EAGL,yBAAyB,EACzB,uBAAuB,EACvB,uBAAuB,EACvB,sBAAsB,EACtB,wBAAwB,EACxB,sBAAsB,EAGtB,gBAAgB,EAChB,SAAS,EACT,cAAc,EACf,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAGH,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AAGxB,YAAY,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAIvF,YAAY,EAEV,aAAa,EACb,WAAW,EAGX,yBAAyB,EACzB,uBAAuB,EACvB,uBAAuB,EACvB,sBAAsB,EACtB,wBAAwB,EACxB,sBAAsB,EAGtB,SAAS,EACT,cAAc,EACf,MAAM,UAAU,CAAC;AAElB;;;;;;;;;;;;;GAaG;AACH,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,2BAA2B,EAC3B,yBAAyB,EAC1B,MAAM,wBAAwB,CAAC;AAEhC;;;;;GAKG;AACH,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAEnE;;;;;;;;;;;;GAYG;AACH,OAAO,EACL,sBAAsB,EACtB,yBAAyB,EACzB,qBAAqB,EACrB,2BAA2B,EAC3B,6BAA6B,EAC7B,uBAAuB,EACxB,MAAM,0BAA0B,CAAC;AAElC;;;;;;;;;;;GAWG;AACH,OAAO,EACL,yBAAyB,EACzB,+BAA+B,EAC/B,yBAAyB,EAC1B,MAAM,0BAA0B,CAAC;AAElC;;;;;;;;;;;;GAYG;AACH,OAAO,EACL,OAAO,EACP,KAAK,EACL,IAAI,EACJ,KAAK,EACL,MAAM,EACN,QAAQ,EACT,MAAM,kBAAkB,CAAC"}

package/dist/types/rental/accept.d.ts

@@ -1,46 +1,162 @@
-import { Address, TransactionSigner } from '@solana/kit';
-import { type NetworkSelector } from '../network';
-type AcceptRentalInstruction = any;
+import { type ConfigSelector } from '../utils/config';
+import { type FluentInstruction, type SmartFluentConfigSelector } from '../utils/instruction-converter';
+type UniversalAddress = string;
+type UniversalSigner = any;
 /**
- * Simplified parameters for accepting a rental
+ * Parameters for accepting a rental contract.
+ *
+ * This interface defines the required parameters for a borrower to accept an existing
+ * rental contract. The SDK automatically fetches contract details and calculates the
+ * required payment amount based on the contract's rate and payment frequency.
+ *
+ * @interface AcceptRentalParams
  */
 export interface AcceptRentalParams {
     /**
-     * The borrower wallet that will sign the transaction
+     * The borrower who will rent the fleet (must be a signer object).
+     * This account will control the fleet during the rental period and make payments.
      */
-    borrower: TransactionSigner<string>;
+    borrower: UniversalSigner;
     /**
-     * The borrower's profile account address
+     * String address of the borrower's profile in the Star Atlas game.
+     * Used for SAGE integration to transfer fleet control to the borrower.
      */
-    borrowerProfile: Address<string>;
+    borrowerProfile: UniversalAddress;
     /**
-     * The borrower's faction (1 = mud, 2 = oni, 3 = ustur)
-     * Or as string: 'mud', 'oni', 'ustur'
+     * Faction identifier for the borrower in Star Atlas.
+     * Can be provided as a number (1 = MUD, 2 = ONI, 3 = Ustur) or string ('mud', 'oni', 'ustur').
+     * Used for deriving faction-specific game accounts required by SAGE.
+     * @example 'mud' // or 1
      */
     borrowerFaction: number | string;
     /**
-     * The fleet account address that will be rented
+     * String address of the rental contract to accept.
+     * The SDK will automatically fetch the contract state to retrieve:
+     * - Fleet address and ownership details
+     * - Rental rate per payment period
+     * - Payment frequency (hourly, daily, weekly, monthly)
+     * - Duration constraints (minimum and maximum)
+     * - Owner information for payment routing
      */
-    fleet: Address<string>;
+    contract: UniversalAddress;
     /**
-     * The rental contract account address
-     */
-    contract: Address<string>;
-    /**
-     * The game ID account address
-     * Defaults to 'GAMEzqJehF8yAnKiTARUuhZMvLvkZVAsCVri5vSfemLr' if not provided
-     */
-    gameId?: Address<string>;
-    /**
-     * The rental amount (in ATLAS tokens)
-     */
-    amount: number | bigint;
-    /**
-     * The rental duration (in seconds)
+     * Rental duration in seconds.
+     * Must be within the contract's minimum and maximum duration limits.
+     * Must also be a multiple of the payment frequency interval.
+     * @example 604800 // 7 days in seconds
      */
     duration: number | bigint;
 }
-export declare function acceptRental(params: AcceptRentalParams): NetworkSelector<AcceptRentalInstruction>;
-export declare function getAcceptRentalInstructionAsync(input: any, options?: any): NetworkSelector<any>;
+/**
+ * Creates an instruction to accept a rental contract with fluent configuration.
+ *
+ * This function allows a borrower to accept an existing rental contract, automatically
+ * calculating the required payment amount based on the contract's rate and payment frequency.
+ * The SDK fetches contract details, validates duration constraints, and derives all
+ * necessary accounts for the rental operation.
+ *
+ * ## Features
+ *
+ * - **Automatic Payment Calculation**: Fetches contract state and calculates exact payment amount
+ * - **Duration Validation**: Ensures rental duration meets contract constraints
+ * - **Account Derivation**: Automatically derives all required game accounts
+ * - **SAGE Integration**: Sets up fleet ownership transfer in the Star Atlas ecosystem
+ * - **Clockwork Integration**: Configures automated payment scheduling
+ * - **Universal Library Support**: Works with both @solana/kit and @solana/web3.js
+ *
+ * ## Process
+ *
+ * 1. **Fetch Contract**: Retrieves contract state from the blockchain
+ * 2. **Validate Duration**: Checks that rental duration meets contract constraints
+ * 3. **Calculate Payment**: Computes payment amount using contract rate and payment frequency
+ * 4. **Derive Accounts**: Generates required game accounts (starbase, faction, etc.)
+ * 5. **Create Instruction**: Builds the rental acceptance instruction
+ * 6. **Setup Threading**: Configures automated payment processing
+ *
+ * ## Payment Calculation
+ *
+ * The payment amount is calculated using the formula:
+ * ```text
+ * payment = rate × payment_periods × stardust_to_atlas_conversion
+ * ```
+ *
+ * Where:
+ * - `rate`: Contract's rental rate per payment period
+ * - `payment_periods`: Duration divided by payment frequency interval
+ * - `stardust_to_atlas_conversion`: Network-specific conversion factor
+ *
+ * ## Requirements
+ *
+ * - Contract must exist and be active
+ * - Duration must be within contract's min/max limits
+ * - Duration must be multiple of payment frequency
+ * - Borrower must have sufficient ATLAS tokens for payment
+ *
+ * @example
+ * ```typescript
+ * import { acceptRental, days } from '@srsly/sdk';
+ *
+ * // Basic rental acceptance
+ * const instruction = await acceptRental({
+ *   borrower: wallet,                     // Borrower's wallet
+ *   borrowerProfile: "ProfileAddr...",    // Borrower's Star Atlas profile
+ *   borrowerFaction: 'mud',               // Faction: 'mud', 'oni', or 'ustur'
+ *   contract: "ContractAddr...",          // Contract to accept
+ *   duration: days(7)                     // 7 days rental duration
+ * });
+ *
+ * // Configure for mainnet
+ * const mainnetInstruction = await acceptRental({
+ *   borrower: wallet,
+ *   borrowerProfile: "ProfileAddr...",
+ *   borrowerFaction: 1,                   // Can use numbers: 1=mud, 2=oni, 3=ustur
+ *   contract: "ContractAddr...",
+ *   duration: days(7)
+ * }).set({ programs: 'mainnet' });
+ *
+ * // Override specific game configuration
+ * const customInstruction = await acceptRental({
+ *   borrower: wallet,
+ *   borrowerProfile: "ProfileAddr...",
+ *   borrowerFaction: 'mud',
+ *   contract: "ContractAddr...",
+ *   duration: days(7)
+ * }).set({
+ *   programs: 'mainnet',
+ *   gameId: 'custom-game-id...'
+ * });
+ *
+ * // Convert to @solana/web3.js format
+ * const web3jsInstruction = await acceptRental({
+ *   borrower: wallet,
+ *   borrowerProfile: "ProfileAddr...",
+ *   borrowerFaction: 'mud',
+ *   contract: "ContractAddr...",
+ *   duration: days(7)
+ * }).web3js();
+ *
+ * // Use with your preferred Solana library
+ * const transaction = new Transaction().add(web3jsInstruction);
+ * await sendAndConfirmTransaction(connection, transaction, [wallet]);
+ * ```
+ *
+ * @param params - The rental acceptance parameters including borrower, contract, and duration
+ * @returns A FluentConfigSelector that can be configured with .set() or awaited directly
+ * @throws Error when contract is not found, duration constraints are violated, or payment calculation fails
+ */
+export declare function acceptRental(params: AcceptRentalParams): SmartFluentConfigSelector<FluentInstruction>;
+/**
+ * Low-level function to create a rental acceptance instruction with raw input parameters.
+ *
+ * This function provides direct access to the underlying codama-generated instruction
+ * builder. It's primarily used internally by the SDK but can be used for advanced
+ * use cases where full control over instruction parameters is needed.
+ *
+ * @internal
+ * @param input - Raw instruction input parameters as expected by codama
+ * @param options - Optional instruction options including program address
+ * @returns A ConfigSelector for the raw instruction
+ */
+export declare function getAcceptRentalInstructionAsync(input: any, options?: any): ConfigSelector<any>;
 export {};
 //# sourceMappingURL=accept.d.ts.map

package/dist/types/rental/accept.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"accept.d.ts","sourceRoot":"","sources":["../../../src/rental/accept.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAErB,OAAO,EAAiD,KAAK,eAAe,EAAgB,MAAM,YAAY,CAAC;AAI/G,KAAK,uBAAuB,GAAG,GAAG,CAAC;AAOnC;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,QAAQ,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAEpC;;OAEG;IACH,eAAe,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IAEjC;;;OAGG;IACH,eAAe,EAAE,MAAM,GAAG,MAAM,CAAC;IAEjC;;OAEG;IACH,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IAEvB;;OAEG;IACH,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IAE1B;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IAEzB;;OAEG;IACH,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IAExB;;OAEG;IACH,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;CAC3B;AA8ED,wBAAgB,YAAY,CAC1B,MAAM,EAAE,kBAAkB,GACzB,eAAe,CAAC,uBAAuB,CAAC,CAE1C;AAED,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,eAAe,CAAC,GAAG,CAAC,CAK/F"}
+{"version":3,"file":"accept.d.ts","sourceRoot":"","sources":["../../../src/rental/accept.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuE,KAAK,cAAc,EAAsB,MAAM,iBAAiB,CAAC;AAG/I,OAAO,EAA4D,KAAK,iBAAiB,EAAE,KAAK,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAOlK,KAAK,gBAAgB,GAAG,MAAM,CAAC;AAC/B,KAAK,eAAe,GAAG,GAAG,CAAC;AAG3B;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,QAAQ,EAAE,eAAe,CAAC;IAE1B;;;OAGG;IACH,eAAe,EAAE,gBAAgB,CAAC;IAElC;;;;;OAKG;IACH,eAAe,EAAE,MAAM,GAAG,MAAM,CAAC;IAEjC;;;;;;;;OAQG;IACH,QAAQ,EAAE,gBAAgB,CAAC;IAE3B;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;CAC3B;AAuID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgGG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,kBAAkB,GACzB,yBAAyB,CAAC,iBAAiB,CAAC,CAG9C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,cAAc,CAAC,GAAG,CAAC,CAK9F"}