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

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,10 +1,120 @@
+/**
+ * # 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 { 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";
-export { decaseconds, minutes, hours, days, weeks, months, duration } from "./utils/duration";
+/**
+ * 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,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AAIxB,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;AAGlB,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,2BAA2B,EAC3B,yBAAyB,EAC1B,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAGnE,OAAO,EACL,sBAAsB,EACtB,yBAAyB,EACzB,qBAAqB,EACrB,2BAA2B,EAC3B,6BAA6B,EAC7B,uBAAuB,EACxB,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,yBAAyB,EACzB,+BAA+B,EAC/B,yBAAyB,EAC1B,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,WAAW,EACX,OAAO,EACP,KAAK,EACL,IAAI,EACJ,KAAK,EACL,MAAM,EACN,QAAQ,EACT,MAAM,kBAAkB,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,91 +1,162 @@
 import { type ConfigSelector } from '../utils/config';
-import { type FluentInstruction, type FluentConfigSelector } from '../utils/instruction-converter';
+import { type FluentInstruction, type SmartFluentConfigSelector } from '../utils/instruction-converter';
 type UniversalAddress = string;
 type UniversalSigner = any;
 /**
- * Simplified parameters for accepting a rental - strings only!
+ * 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 (can be signer or string)
+     * 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: UniversalSigner | UniversalAddress;
+    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: 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
-     */
-    fleet: UniversalAddress;
-    /**
-     * The rental contract account address
+     * 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
      */
     contract: UniversalAddress;
     /**
-     * The rental rate (in ATLAS tokens)
-     */
-    rate: 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;
-    /**
-     * Optional referral token account address
-     * If provided, referrer will receive 5% of the platform fees
-     */
-    referralTokenAccount?: UniversalAddress;
 }
 /**
- * Creates an instruction to accept a rental with fluent configuration.
+ * 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
- * // Works with any library - just use strings for addresses!
+ * import { acceptRental, days } from '@srsly/sdk';
+ *
+ * // Basic rental acceptance
  * const instruction = await acceptRental({
- *   borrower: wallet,                     // Can be signer object or string
- *   borrowerProfile: "ProfileAddr...",    // String address
- *   borrowerFaction: 1,                   // 1 = mud, 2 = oni, 3 = ustur
- *   fleet: "FleetAddress123...",          // String address
- *   contract: "ContractAddr...",          // String address
- *   rate: 1000,                          // ATLAS tokens
- *   duration: 86400                      // 1 day in seconds (total: 1000 * 86400 * 100M stardust)
+ *   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
  * });
  *
- * // With referral (referrer gets 5% of platform fees)
- * const instruction = await acceptRental({
+ * // Configure for mainnet
+ * const mainnetInstruction = await acceptRental({
  *   borrower: wallet,
  *   borrowerProfile: "ProfileAddr...",
- *   borrowerFaction: 1,
- *   fleet: "FleetAddress123...",
+ *   borrowerFaction: 1,                   // Can use numbers: 1=mud, 2=oni, 3=ustur
  *   contract: "ContractAddr...",
- *   rate: 1000,
- *   duration: 86400,
- *   referralTokenAccount: "ReferralAddr..."
- * });
+ *   duration: days(7)
+ * }).set({ programs: 'mainnet' });
  *
- * // Use mainnet configuration
- * const instruction = await acceptRental(params).set({ programs: 'mainnet' });
- *
- * // Override specific constants
- * const instruction = await acceptRental(params).set({
+ * // 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...' // gameId configured via .set()
+ *   gameId: 'custom-game-id...'
  * });
  *
- * // Use the instruction with your preferred Solana library
- * // instruction is compatible with both @solana/kit and @solana/web3.js
+ * // 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 simplified parameters for accepting a rental
- * @returns A ConfigSelector that can be configured with .set() or awaited directly
+ * @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 acceptRental(params: AcceptRentalParams): FluentConfigSelector<FluentInstruction>;
 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,EAA4D,KAAK,cAAc,EAAsB,MAAM,iBAAiB,CAAC;AAGpI,OAAO,EAAuD,KAAK,iBAAiB,EAAE,KAAK,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAGxJ,KAAK,gBAAgB,GAAG,MAAM,CAAC;AAC/B,KAAK,eAAe,GAAG,GAAG,CAAC;AAG3B;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,QAAQ,EAAE,eAAe,GAAG,gBAAgB,CAAC;IAE7C;;OAEG;IACH,eAAe,EAAE,gBAAgB,CAAC;IAElC;;;OAGG;IACH,eAAe,EAAE,MAAM,GAAG,MAAM,CAAC;IAEjC;;OAEG;IACH,KAAK,EAAE,gBAAgB,CAAC;IAExB;;OAEG;IACH,QAAQ,EAAE,gBAAgB,CAAC;IAE3B;;OAEG;IACH,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAEtB;;OAEG;IACH,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAE1B;;;OAGG;IACH,oBAAoB,CAAC,EAAE,gBAAgB,CAAC;CACzC;AAoED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,kBAAkB,GACzB,oBAAoB,CAAC,iBAAiB,CAAC,CAGzC;AAED,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,cAAc,CAAC,GAAG,CAAC,CAK9F"}
+{"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"}

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

@@ -3,45 +3,109 @@ type UniversalAddress = string;
 type UniversalSigner = any;
 type CancelRentalInstruction = any;
 /**
- * Simplified parameters for canceling a rental - strings only!
+ * Parameters for canceling an active rental.
+ *
+ * This interface defines the required parameters for a borrower to cancel their
+ * active rental. Canceling a rental stops automated payments but typically
+ * incurs a penalty fee as defined in the contract terms.
+ *
+ * @interface CancelRentalParams
  */
 export interface CancelRentalParams {
     /**
-     * The borrower wallet that will sign the transaction (can be signer or string)
+     * The borrower who wants to cancel the rental (must be a signer object).
+     * Must be the original borrower who accepted the rental contract.
+     * This account will pay any cancellation penalties.
      */
-    borrower: UniversalSigner | UniversalAddress;
+    borrower: UniversalSigner;
     /**
-     * The rental contract account address
+     * String address of the rental contract associated with the active rental.
+     * The rental state for this contract will be canceled and automated payments stopped.
      */
     contract: UniversalAddress;
 }
 /**
  * Creates an instruction to cancel a rental with fluent configuration.
  *
+ * This function allows a borrower to cancel their active rental before the
+ * rental period expires. Canceling a rental stops automated payments but
+ * may incur penalty fees as defined in the contract terms. The fleet ownership
+ * is immediately returned to the original owner.
+ *
+ * ## Features
+ *
+ * - **Immediate Cancellation**: Stops the rental and automated payments immediately
+ * - **Fleet Transfer**: Returns fleet control to the original owner
+ * - **Thread Cleanup**: Cancels the automated payment thread
+ * - **Penalty Processing**: Handles any cancellation fees as defined in the contract
+ * - **Universal Library Support**: Works with both @solana/kit and @solana/web3.js
+ *
+ * ## Process
+ *
+ * 1. **Validate Authority**: Ensures only the borrower can cancel their rental
+ * 2. **Calculate Penalties**: Computes any cancellation fees owed
+ * 3. **Transfer Fleet**: Returns fleet ownership to the original owner
+ * 4. **Cancel Thread**: Stops automated payment processing
+ * 5. **Update State**: Marks rental as canceled in the rental state account
+ *
+ * ## Requirements
+ *
+ * - Rental must be active (not already canceled or completed)
+ * - Caller must be the original borrower
+ * - Borrower must have sufficient funds for any cancellation penalties
+ *
+ * ## Cancellation Effects
+ *
+ * - **Fleet Control**: Immediately returned to owner
+ * - **Automated Payments**: Stopped permanently
+ * - **Rental State**: Marked as canceled
+ * - **Thread Account**: Cleaned up and closed
+ * - **Penalties**: Charged according to contract terms
+ *
  * @example
  * ```typescript
- * // Works with any library - just use strings for addresses!
+ * import { cancelRental } from '@srsly/sdk';
+ *
+ * // Basic rental cancellation
  * const instruction = await cancelRental({
- *   borrower: wallet,            // Can be signer object or string
- *   contract: "ContractAddr..."  // String address
+ *   borrower: wallet,            // Borrower's wallet (must be original borrower)
+ *   contract: "ContractAddr..."  // Contract address for the active rental
  * });
  *
- * // Use mainnet configuration
- * const instruction = await cancelRental(params).set({ programs: 'mainnet' });
+ * // Configure for mainnet
+ * const mainnetInstruction = await cancelRental({
+ *   borrower: wallet,
+ *   contract: "ContractAddr..."
+ * }).set({ programs: 'mainnet' });
  *
- * // Override specific constants
- * const instruction = await cancelRental(params).set({
- *   programs: 'mainnet'
- * });
+ * // Convert to @solana/web3.js format
+ * const web3jsInstruction = await cancelRental({
+ *   borrower: wallet,
+ *   contract: "ContractAddr..."
+ * }).web3js();
  *
- * // Use the instruction with your preferred Solana library
- * // instruction is compatible with both @solana/kit and @solana/web3.js
+ * // Use with your preferred Solana library
+ * const transaction = new Transaction().add(web3jsInstruction);
+ * await sendAndConfirmTransaction(connection, transaction, [wallet]);
  * ```
  *
- * @param params The simplified parameters for canceling a rental
+ * @param params - The rental cancellation parameters including borrower and contract
  * @returns A ConfigSelector that can be configured with .set() or awaited directly
+ * @throws Error when rental is not active, caller is not the borrower, or instruction generation fails
  */
 export declare function cancelRental(params: CancelRentalParams): ConfigSelector<CancelRentalInstruction>;
+/**
+ * Low-level function to create a rental cancellation 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 getCancelRentalInstructionAsync(input: any, options?: any): ConfigSelector<any>;
 export {};
 //# sourceMappingURL=cancel.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"cancel.d.ts","sourceRoot":"","sources":["../../../src/rental/cancel.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4D,KAAK,cAAc,EAAsB,MAAM,iBAAiB,CAAC;AAIpI,KAAK,gBAAgB,GAAG,MAAM,CAAC;AAC/B,KAAK,eAAe,GAAG,GAAG,CAAC;AAC3B,KAAK,uBAAuB,GAAG,GAAG,CAAC;AAEnC;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,QAAQ,EAAE,eAAe,GAAG,gBAAgB,CAAC;IAE7C;;OAEG;IACH,QAAQ,EAAE,gBAAgB,CAAC;CAC5B;AAmCD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,kBAAkB,GACzB,cAAc,CAAC,uBAAuB,CAAC,CAEzC;AAED,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,cAAc,CAAC,GAAG,CAAC,CAK9F"}
+{"version":3,"file":"cancel.d.ts","sourceRoot":"","sources":["../../../src/rental/cancel.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4D,KAAK,cAAc,EAAsB,MAAM,iBAAiB,CAAC;AAIpI,KAAK,gBAAgB,GAAG,MAAM,CAAC;AAC/B,KAAK,eAAe,GAAG,GAAG,CAAC;AAC3B,KAAK,uBAAuB,GAAG,GAAG,CAAC;AAEnC;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,QAAQ,EAAE,eAAe,CAAC;IAE1B;;;OAGG;IACH,QAAQ,EAAE,gBAAgB,CAAC;CAC5B;AA8CD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,kBAAkB,GACzB,cAAc,CAAC,uBAAuB,CAAC,CAEzC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,cAAc,CAAC,GAAG,CAAC,CAK9F"}