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

package/dist/esm/rental/accept.js

@@ -1,60 +1,213 @@
-import { getCachedNetworkModule, createNetworkSelector } from '../network';
-import { deriveGameAccounts, DEFAULT_GAME_ID, } from '../utils';
+import { getModule, createConfigSelector, resolveProgramAddresses, getConfig } from '../utils/config';
+import { ATLAS_TO_STARDUST, toAddress } from '../utils/constants';
+import { deriveGameAccounts } from '../utils';
+import { createFluentInstruction, createSmartFluentConfigSelector } from '../utils/instruction-converter';
+import { fetchMaybeContractState } from '../codama/accounts';
+import { createSolanaRpc } from '@solana/kit';
+import { paymentFrequencyStringToSeconds } from '../utils/paymentFrequency';
+import { deriveRentalThread, deriveRentalState, deriveRentalAuthority } from '../utils/pda';
 /**
- * Asynchronously creates an instruction to accept a rental with minimal required parameters.
- * Derives borrowerProfileFaction, starbase, and starbasePlayer automatically.
+ * Internal function to accept a rental instruction with configuration options.
+ *
+ * This function handles the core logic of creating a rental acceptance instruction,
+ * including contract state fetching, payment calculation, account derivation, and
+ * instruction generation. It automatically validates contract constraints and
+ * calculates the required payment amount.
+ *
+ * @internal
+ * @param params - The rental acceptance parameters
+ * @param config - Optional configuration for network and program settings
+ * @returns Promise resolving to a fluent instruction object
+ * @throws Error when contract is not found, duration constraints are violated, or account derivation fails
+ */
+async function _acceptRental(params, config) {
+    const { borrower, borrowerProfile, borrowerFaction, contract, duration, } = params;
+    // Get the resolved addresses from config (including network-specific addresses)
+    // Use global config as fallback, same pattern as constants.ts
+    const globalConfig = getConfig();
+    const effectiveConfig = { ...globalConfig, ...config };
+    const resolvedAddresses = await resolveProgramAddresses(effectiveConfig);
+    // Fetch contract state to get payment frequency and validate parameters
+    let contractState;
+    try {
+        // Create RPC from resolved addresses
+        const rpc = createSolanaRpc(resolvedAddresses.rpcUrl);
+        contractState = await fetchMaybeContractState(rpc, toAddress(contract));
+        if (!contractState.exists) {
+            throw new Error(`Contract not found: ${contract}`);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to fetch contract state: ${error}`);
+    }
+    // Extract data from contract state
+    const rate = Number(contractState.data.rate);
+    const fleet = contractState.data.fleet;
+    // Validate duration constraints
+    const durationMin = Number(contractState.data.durationMin);
+    const durationMax = Number(contractState.data.durationMax);
+    const durationNumber = Number(duration);
+    if (durationNumber < durationMin || durationNumber > durationMax) {
+        throw new Error(`Duration ${durationNumber} seconds is outside contract constraints (${durationMin}-${durationMax} seconds)`);
+    }
+    // Calculate amount based on payment frequency and periods (matching program logic)
+    const paymentFrequencySeconds = paymentFrequencyStringToSeconds(contractState.data.paymentsFeq);
+    const paymentPeriods = Math.floor(durationNumber / paymentFrequencySeconds);
+    // Use the config's stardust_to_atlas conversion factor (defaulting to ATLAS_TO_STARDUST for now)
+    const stardustToAtlas = ATLAS_TO_STARDUST; // TODO: Get from config account
+    const amount = BigInt(rate) * BigInt(paymentPeriods) * BigInt(stardustToAtlas);
+    // Manually derive ALL game accounts - they all use different program addresses than main SAGE program
+    const { profileFaction, starbase, starbasePlayer } = await deriveGameAccounts(toAddress(borrowerProfile), borrowerFaction, resolvedAddresses.gameId, 0, // starbaseSeqId
+    config);
+    // Manually derive PDAs with correct program IDs
+    const rentalStatePda = await deriveRentalState(toAddress(contract), borrower.address, // Extract address from signer
+    resolvedAddresses.srslyProgramAddress);
+    const rentalAuthorityPda = await deriveRentalAuthority(resolvedAddresses.srslyProgramAddress);
+    // 🔧 FIX: Derive rental thread PDA using Antegen program ID
+    const rentalThreadPda = await deriveRentalThread(rentalAuthorityPda, rentalStatePda, resolvedAddresses.antegenProgramAddress);
+    // Create input with ALL manually derived game accounts - they use different program addresses
+    const input = {
+        borrower: borrower, // Pass signer directly to Codama
+        borrowerProfile: toAddress(borrowerProfile), // Ensure string
+        borrowerProfileFaction: toAddress(profileFaction), // Manually derived (Profile program)
+        fleet: toAddress(fleet), // Ensure string
+        contract: toAddress(contract), // Ensure string
+        gameId: resolvedAddresses.gameId, // Already Address from resolveProgramAddresses
+        starbase: toAddress(starbase), // Manually derived (SAGE program but different derivation)
+        starbasePlayer: toAddress(starbasePlayer), // Manually derived (SAGE program but different derivation)
+        mint: resolvedAddresses.atlasMint, // ATLAS mint from config
+        sageProgram: resolvedAddresses.sageProgramAddress, // SAGE program from config
+        antegenProgram: resolvedAddresses.antegenProgramAddress, // Antegen program from config
+        // Override PDAs with correctly derived addresses
+        rentalState: rentalStatePda,
+        rentalAuthority: rentalAuthorityPda,
+        rentalThread: rentalThreadPda, // Uses Antegen program ID!
+        amount, // BigInt value
+        duration, // BigInt value
+    };
+    // Get network-specific codama functions from centralized config
+    const instructionsModule = getModule('instructions');
+    const { getAcceptRentalInstructionAsync } = instructionsModule;
+    const rawInstruction = await getAcceptRentalInstructionAsync(input, { programAddress: resolvedAddresses.srslyProgramAddress });
+    return createFluentInstruction(rawInstruction);
+}
+/**
+ * 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
- * // Create the instruction with automatic account derivation
- * const ix = await acceptRental({
+ * 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: profileAddress,
- *   borrowerFaction: 1, // 1 = mud, 2 = oni, 3 = ustur
- *   fleet: fleetAddress,
- *   contract: contractAddress,
- *   amount: 1000,
- *   duration: 86400  // 1 day in seconds
- *   // gameId is optional and will default to the standard game ID
+ *   borrowerProfile: "ProfileAddr...",
+ *   borrowerFaction: 'mud',
+ *   contract: "ContractAddr...",
+ *   duration: days(7)
+ * }).set({
+ *   programs: 'mainnet',
+ *   gameId: 'custom-game-id...'
  * });
  *
- * // Add to transaction and sign
- * const tx = new Transaction().add(ix);
- * await sendAndConfirmTransaction(connection, tx, [wallet]);
+ * // 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 promise that resolves to the instruction to accept a rental
+ * @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
  */
-async function _acceptRental(params, network) {
-    const { borrower, borrowerProfile, borrowerFaction, fleet, contract, gameId = DEFAULT_GAME_ID, amount, duration, } = params;
-    // Derive the three accounts we need
-    const { profileFaction, starbase, starbasePlayer } = await deriveGameAccounts(borrowerProfile, borrowerFaction, gameId);
-    // Let codama derive the rest (rentalThread, rentalState, rentalAuthority, etc.)
-    const input = {
-        borrower,
-        borrowerProfile,
-        borrowerProfileFaction: profileFaction,
-        fleet,
-        contract,
-        gameId,
-        starbase,
-        starbasePlayer,
-        amount,
-        duration,
-    };
-    // Dynamically import network-specific codama functions
-    const codamaModule = await getCachedNetworkModule('instructions');
-    const { getAcceptRentalInstructionAsync, SRSLY_PROGRAM_ADDRESS } = codamaModule;
-    return getAcceptRentalInstructionAsync(input, { programAddress: SRSLY_PROGRAM_ADDRESS });
-}
 export function acceptRental(params) {
-    return createNetworkSelector((network) => _acceptRental(params, network));
+    const baseSelector = createConfigSelector((config) => _acceptRental(params, config));
+    return createSmartFluentConfigSelector(baseSelector);
 }
+/**
+ * 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 function getAcceptRentalInstructionAsync(input, options) {
-    return createNetworkSelector(async (network) => {
-        const codamaModule = await getCachedNetworkModule('instructions', network);
-        return codamaModule.getAcceptRentalInstructionAsync(input, options);
+    return createConfigSelector(async () => {
+        const instructionsModule = getModule('instructions');
+        return instructionsModule.getAcceptRentalInstructionAsync(input, options);
     });
 }
 //# sourceMappingURL=accept.js.map

package/dist/esm/rental/accept.js.map

@@ -1 +1 @@
-{"version":3,"file":"accept.js","sourceRoot":"","sources":["../../../src/rental/accept.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,sBAAsB,EAAE,qBAAqB,EAAsC,MAAM,YAAY,CAAC;AAM/G,OAAO,EACL,kBAAkB,EAClB,eAAe,GAChB,MAAM,UAAU,CAAC;AAiDlB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,KAAK,UAAU,aAAa,CAC1B,MAA0B,EAC1B,OAAiB;IAEjB,MAAM,EACJ,QAAQ,EACR,eAAe,EACf,eAAe,EACf,KAAK,EACL,QAAQ,EACR,MAAM,GAAG,eAAkC,EAC3C,MAAM,EACN,QAAQ,GACT,GAAG,MAAM,CAAC;IAEX,oCAAoC;IACpC,MAAM,EACJ,cAAc,EACd,QAAQ,EACR,cAAc,EACf,GAAG,MAAM,kBAAkB,CAC1B,eAAe,EACf,eAAe,EACf,MAAM,CACP,CAAC;IAEF,gFAAgF;IAChF,MAAM,KAAK,GAAoC;QAC7C,QAAQ;QACR,eAAe;QACf,sBAAsB,EAAE,cAAc;QACtC,KAAK;QACL,QAAQ;QACR,MAAM;QACN,QAAQ;QACR,cAAc;QACd,MAAM;QACN,QAAQ;KACT,CAAC;IAEF,uDAAuD;IACvD,MAAM,YAAY,GAAG,MAAM,sBAAsB,CAAC,cAAc,CAAC,CAAC;IAClE,MAAM,EAAE,+BAA+B,EAAE,qBAAqB,EAAE,GAAG,YAAY,CAAC;IAEhF,OAAO,+BAA+B,CACpC,KAAY,EACZ,EAAE,cAAc,EAAE,qBAAqB,EAAE,CAC1C,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,YAAY,CAC1B,MAA0B;IAE1B,OAAO,qBAAqB,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,aAAa,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAC5E,CAAC;AAED,MAAM,UAAU,+BAA+B,CAAC,KAAU,EAAE,OAAa;IACvE,OAAO,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;QAC7C,MAAM,YAAY,GAAG,MAAM,sBAAsB,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC;QAC3E,OAAO,YAAY,CAAC,+BAA+B,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACtE,CAAC,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"accept.js","sourceRoot":"","sources":["../../../src/rental/accept.ts"],"names":[],"mappings":"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"}

package/dist/esm/rental/cancel.js

@@ -1,44 +1,123 @@
-import { getCachedNetworkModule, createNetworkSelector } from '../network';
+import { getModule, createConfigSelector } from '../utils/config';
+import { toAddress } from '../utils/constants';
 /**
- * Asynchronously creates an instruction to cancel a rental with minimal required parameters.
- * Derives rentalState, rentalThread, borrowerTokenAccount, rentalTokenAccount and
- * rentalAuthority automatically if not provided.
+ * Internal function to cancel a rental instruction with configuration options.
  *
- * @example
- * ```typescript
- * // Create the instruction with minimal parameters - just borrower and contract
- * const ix = await cancelRental({
- *   borrower: wallet,
- *   contract: contractAddress
- * });
+ * This function handles the core logic of creating a rental cancellation instruction,
+ * including address resolution and instruction generation. The cancellation stops
+ * automated payments and may incur penalty fees.
  *
- * // Add to transaction and sign
- * const tx = new Transaction().add(ix);
- * await sendAndConfirmTransaction(connection, tx, [wallet]);
- * ```
- *
- * @param params The simplified parameters for canceling a rental
- * @returns A promise that resolves to the instruction to cancel a rental
+ * @internal
+ * @param params - The rental cancellation parameters
+ * @param config - Optional configuration for network and program settings
+ * @returns Promise resolving to a cancellation instruction
+ * @throws Error when instruction generation fails or required parameters are missing
  */
-async function _cancelRental(params, network) {
+async function _cancelRental(params, config) {
     const { borrower, contract, } = params;
+    // Get the resolved addresses from config (including network-specific addresses)
+    // Note: resolvedAddresses not currently needed for this instruction but kept for consistency
+    // const resolvedAddresses = resolveProgramAddresses(config || {});
     // Let codama derive all the optional accounts
     const input = {
-        borrower,
-        contract,
+        borrower, // Pass signer directly to Codama
+        contract: toAddress(contract), // Ensure string
     };
-    // Dynamically import network-specific codama functions
-    const codamaModule = await getCachedNetworkModule('instructions');
-    const { getCancelRentalInstructionAsync, SRSLY_PROGRAM_ADDRESS } = codamaModule;
+    // Get network-specific codama functions from centralized config
+    const instructionsModule = getModule('instructions');
+    const programsModule = getModule('programs');
+    const { getCancelRentalInstructionAsync } = instructionsModule;
+    const { SRSLY_PROGRAM_ADDRESS } = programsModule;
     return getCancelRentalInstructionAsync(input, { programAddress: SRSLY_PROGRAM_ADDRESS });
 }
+/**
+ * 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
+ * import { cancelRental } from '@srsly/sdk';
+ *
+ * // Basic rental cancellation
+ * const instruction = await cancelRental({
+ *   borrower: wallet,            // Borrower's wallet (must be original borrower)
+ *   contract: "ContractAddr..."  // Contract address for the active rental
+ * });
+ *
+ * // Configure for mainnet
+ * const mainnetInstruction = await cancelRental({
+ *   borrower: wallet,
+ *   contract: "ContractAddr..."
+ * }).set({ programs: 'mainnet' });
+ *
+ * // Convert to @solana/web3.js format
+ * const web3jsInstruction = await cancelRental({
+ *   borrower: wallet,
+ *   contract: "ContractAddr..."
+ * }).web3js();
+ *
+ * // Use with your preferred Solana library
+ * const transaction = new Transaction().add(web3jsInstruction);
+ * await sendAndConfirmTransaction(connection, transaction, [wallet]);
+ * ```
+ *
+ * @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 function cancelRental(params) {
-    return createNetworkSelector((network) => _cancelRental(params, network));
+    return createConfigSelector((config) => _cancelRental(params, config));
 }
+/**
+ * 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 function getCancelRentalInstructionAsync(input, options) {
-    return createNetworkSelector(async (network) => {
-        const codamaModule = await getCachedNetworkModule('instructions', network);
-        return codamaModule.getCancelRentalInstructionAsync(input, options);
+    return createConfigSelector(async () => {
+        const instructionsModule = getModule('instructions');
+        return instructionsModule.getCancelRentalInstructionAsync(input, options);
     });
 }
 //# sourceMappingURL=cancel.js.map

package/dist/esm/rental/cancel.js.map

@@ -1 +1 @@
-{"version":3,"file":"cancel.js","sourceRoot":"","sources":["../../../src/rental/cancel.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,sBAAsB,EAAE,qBAAqB,EAAsC,MAAM,YAAY,CAAC;AAoB/G;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,KAAK,UAAU,aAAa,CAC1B,MAA0B,EAC1B,OAAiB;IAEjB,MAAM,EACJ,QAAQ,EACR,QAAQ,GACT,GAAG,MAAM,CAAC;IAEX,8CAA8C;IAC9C,MAAM,KAAK,GAAG;QACZ,QAAQ;QACR,QAAQ;KACT,CAAC;IAEF,uDAAuD;IACvD,MAAM,YAAY,GAAG,MAAM,sBAAsB,CAAC,cAAc,CAAC,CAAC;IAClE,MAAM,EAAE,+BAA+B,EAAE,qBAAqB,EAAE,GAAG,YAAY,CAAC;IAEhF,OAAO,+BAA+B,CACpC,KAAK,EACL,EAAE,cAAc,EAAE,qBAAqB,EAAE,CAC1C,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,YAAY,CAC1B,MAA0B;IAE1B,OAAO,qBAAqB,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,aAAa,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAC5E,CAAC;AAED,MAAM,UAAU,+BAA+B,CAAC,KAAU,EAAE,OAAa;IACvE,OAAO,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;QAC7C,MAAM,YAAY,GAAG,MAAM,sBAAsB,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC;QAC3E,OAAO,YAAY,CAAC,+BAA+B,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACtE,CAAC,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"cancel.js","sourceRoot":"","sources":["../../../src/rental/cancel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,oBAAoB,EAAoE,MAAM,iBAAiB,CAAC;AACpI,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AA+B/C;;;;;;;;;;;;GAYG;AACH,KAAK,UAAU,aAAa,CAC1B,MAA0B,EAC1B,MAAsB;IAEtB,MAAM,EACJ,QAAQ,EACR,QAAQ,GACT,GAAG,MAAM,CAAC;IAEX,gFAAgF;IAChF,6FAA6F;IAC7F,mEAAmE;IAEnE,8CAA8C;IAC9C,MAAM,KAAK,GAAG;QACZ,QAAQ,EAAqB,iCAAiC;QAC9D,QAAQ,EAAE,SAAS,CAAC,QAAQ,CAAC,EAAE,gBAAgB;KAChD,CAAC;IAEF,gEAAgE;IAChE,MAAM,kBAAkB,GAAG,SAAS,CAAC,cAAc,CAAC,CAAC;IACrD,MAAM,cAAc,GAAG,SAAS,CAAC,UAAU,CAAC,CAAC;IAC7C,MAAM,EAAE,+BAA+B,EAAE,GAAG,kBAAkB,CAAC;IAC/D,MAAM,EAAE,qBAAqB,EAAE,GAAG,cAAc,CAAC;IAEjD,OAAO,+BAA+B,CACpC,KAAK,EACL,EAAE,cAAc,EAAE,qBAAqB,EAAE,CAC1C,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,MAAM,UAAU,YAAY,CAC1B,MAA0B;IAE1B,OAAO,oBAAoB,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AACzE,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,+BAA+B,CAAC,KAAU,EAAE,OAAa;IACvE,OAAO,oBAAoB,CAAC,KAAK,IAAI,EAAE;QACrC,MAAM,kBAAkB,GAAG,SAAS,CAAC,cAAc,CAAC,CAAC;QACrD,OAAO,kBAAkB,CAAC,+BAA+B,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC5E,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/esm/rental/close.js

@@ -1,46 +1,184 @@
-import { getCachedNetworkModule, createNetworkSelector } from '../network';
+import { getModule, createConfigSelector, resolveProgramAddresses } from '../utils/config';
+import { toAddress } from '../utils/constants';
+import { createFluentInstruction, createSmartFluentConfigSelector } from '../utils/instruction-converter';
+import { fetchMaybeRentalState, fetchMaybeContractState, fetchMaybeConfig } from '../codama/accounts';
+import { createSolanaRpc, getProgramDerivedAddress, getBytesEncoder } from '@solana/kit';
+import { deriveRentalThread, deriveRentalAuthority } from '../utils/pda';
 /**
- * Asynchronously creates an instruction to close a rental with minimal required parameters.
- * This is called by an owner to close a rental that was previously accepted by a borrower.
- * Derives rentalState, rentalThread, rentalTokenAccount and rentalAuthority automatically if not provided.
+ * Internal function to close a rental instruction with configuration options.
+ *
+ * This function handles the core logic of creating a rental closure instruction,
+ * including address resolution and instruction generation. The closure finalizes
+ * the rental period and transfers any remaining funds to the owner.
+ *
+ * @internal
+ * @param params - The rental closure parameters
+ * @param config - Optional configuration for network and program settings
+ * @returns Promise resolving to a closure instruction
+ * @throws Error when instruction generation fails or required parameters are missing
+ */
+async function _closeRental(params, config) {
+    const { payer, rentalStateAddress, } = params;
+    // Get the resolved addresses from config (including network-specific addresses)
+    const resolvedAddresses = await resolveProgramAddresses(config || {});
+    // Create RPC from resolved addresses
+    const rpc = createSolanaRpc(resolvedAddresses.rpcUrl);
+    // Fetch rental state to get contract and borrower
+    let rentalState;
+    try {
+        if (!rentalStateAddress) {
+            throw new Error(`rentalStateAddress is ${rentalStateAddress}, cannot proceed`);
+        }
+        rentalState = await fetchMaybeRentalState(rpc, toAddress(rentalStateAddress));
+        if (!rentalState.exists) {
+            throw new Error(`Rental state not found: ${rentalStateAddress}`);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to fetch rental state: ${error}`);
+    }
+    // Extract required addresses from rental state
+    const contractAddress = rentalState.data.contract;
+    const borrower = rentalState.data.borrower;
+    // Derive PDAs similar to accept.ts
+    const rentalAuthorityPda = await deriveRentalAuthority(resolvedAddresses.srslyProgramAddress.toString());
+    // 🔧 FIX: Derive rental thread PDA using Antegen program ID and the passed-in rental state address
+    const rentalThreadPda = await deriveRentalThread(rentalAuthorityPda, toAddress(rentalStateAddress), // Use the passed-in rental state address
+    resolvedAddresses.antegenProgramAddress);
+    // Fetch contract state to get owner
+    let contractState;
+    try {
+        contractState = await fetchMaybeContractState(rpc, toAddress(contractAddress));
+        if (!contractState.exists) {
+            throw new Error(`Contract not found: ${contractAddress}`);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to fetch contract state: ${error}`);
+    }
+    // Fetch config state to get the authority (we already have mint from resolved addresses)
+    const [configPda] = await getProgramDerivedAddress({
+        programAddress: resolvedAddresses.srslyProgramAddress,
+        seeds: [
+            getBytesEncoder().encode(new Uint8Array([99, 111, 110, 102, 105, 103])), // "config"
+        ],
+    });
+    let configState;
+    try {
+        configState = await fetchMaybeConfig(rpc, configPda);
+        if (!configState.exists) {
+            throw new Error(`Config not found: ${configPda}`);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to fetch config state: ${error}`);
+    }
+    // Only provide required fields - let Codama auto-generate the rest except rental_thread
+    const input = {
+        payer: payer, // Pass the signer directly to Codama
+        mint: resolvedAddresses.atlasMint, // Use resolved ATLAS mint from config
+        authority: toAddress(configState.data.authority), // Config authority for fee collection
+        borrower: toAddress(borrower),
+        owner: toAddress(contractState.data.owner),
+        contract: toAddress(contractAddress),
+        // Only override rental_thread since Codama can't auto-generate this one
+        rentalThread: rentalThreadPda, // Uses Antegen program ID!
+    };
+    // Get network-specific codama functions from centralized config
+    const instructionsModule = getModule('instructions');
+    const { getCloseRentalInstructionAsync } = instructionsModule;
+    const rawInstruction = await getCloseRentalInstructionAsync(input, { programAddress: resolvedAddresses.srslyProgramAddress });
+    return createFluentInstruction(rawInstruction);
+}
+/**
+ * Creates an instruction to close a completed rental with fluent configuration.
+ *
+ * This function finalizes a rental that has reached its expiration or been fully paid.
+ * It transfers any remaining funds to the owner, returns fleet control, and cleans up
+ * the rental state account. This instruction can be called by anyone once the rental
+ * period has ended.
+ *
+ * ## Features
+ *
+ * - **Rental Finalization**: Properly closes completed or expired rentals
+ * - **Fund Transfer**: Moves any remaining payments or deposits to the owner
+ * - **Fleet Return**: Ensures fleet ownership is returned to the original owner
+ * - **State Cleanup**: Closes rental state account and returns lamports
+ * - **Thread Cleanup**: Cleans up automated payment threads
+ * - **Universal Library Support**: Works with both @solana/kit and @solana/web3.js
+ *
+ * ## Process
+ *
+ * 1. **Validate Completion**: Ensures rental period has ended or been fully paid
+ * 2. **Transfer Funds**: Moves any remaining ATLAS tokens to owner's account
+ * 3. **Return Fleet**: Transfers fleet ownership back to original owner
+ * 4. **Clean State**: Closes rental state account and returns SOL to payer
+ * 5. **Cancel Thread**: Cleans up any remaining automated payment threads
+ *
+ * ## Requirements
+ *
+ * - Rental must be completed or expired
+ * - Owner token account must be valid ATLAS token account
+ * - Rental state account must exist and be properly initialized
+ *
+ * ## When to Use
+ *
+ * - **Natural Expiration**: When rental period has ended
+ * - **Full Payment**: When all required payments have been made
+ * - **Account Cleanup**: To close expired rental accounts and recover SOL
+ * - **Fleet Recovery**: When fleet needs to be returned to owner
  *
  * @example
  * ```typescript
- * // Create the instruction with minimal parameters
- * const ix = await closeRental({
- *   borrower: borrowerAddress,
- *   ownerTokenAccount: ownerTokenAccountAddress,
- *   contract: contractAddress
+ * import { closeRental } from '@srsly/sdk';
+ *
+ * // Close a completed rental
+ * const instruction = await closeRental({
+ *   payer: wallet,                         // Transaction payer
+ *   rentalStateAddress: "RentalState..."   // Rental state address
  * });
  *
- * // Add to transaction and sign
- * const tx = new Transaction().add(ix);
- * await sendAndConfirmTransaction(connection, tx, [owner]);
+ * // Configure for mainnet
+ * const mainnetInstruction = await closeRental({
+ *   payer: wallet,
+ *   rentalStateAddress: "RentalState..."
+ * }).set({ programs: 'mainnet' });
+ *
+ * // Convert to @solana/web3.js format
+ * const web3jsInstruction = await closeRental({
+ *   payer: wallet,
+ *   rentalStateAddress: "RentalState..."
+ * }).web3js();
+ *
+ * // Use with your preferred Solana library
+ * const transaction = new Transaction().add(web3jsInstruction);
+ * await sendAndConfirmTransaction(connection, transaction, [wallet]);
  * ```
  *
- * @param params The simplified parameters for closing a rental
- * @returns A promise that resolves to the instruction to close a rental
+ * @param params - The rental closure parameters including payer and rental state address
+ * @returns A FluentConfigSelector that can be configured with .set() or awaited directly
+ * @throws Error when rental is not ready for closure or instruction generation fails
  */
-async function _closeRental(params, network) {
-    const { borrower, ownerTokenAccount, contract, } = params;
-    // Let codama derive the optional accounts
-    const input = {
-        borrower,
-        ownerTokenAccount,
-        contract,
-    };
-    // Dynamically import network-specific codama functions
-    const codamaModule = await getCachedNetworkModule('instructions');
-    const { getCloseRentalInstructionAsync, SRSLY_PROGRAM_ADDRESS } = codamaModule;
-    return getCloseRentalInstructionAsync(input, { programAddress: SRSLY_PROGRAM_ADDRESS });
-}
 export function closeRental(params) {
-    return createNetworkSelector((network) => _closeRental(params, network));
+    const baseSelector = createConfigSelector((config) => _closeRental(params, config));
+    return createSmartFluentConfigSelector(baseSelector);
 }
+/**
+ * Low-level function to create a rental closure 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 function getCloseRentalInstructionAsync(input, options) {
-    return createNetworkSelector(async (network) => {
-        const codamaModule = await getCachedNetworkModule('instructions', network);
-        return codamaModule.getCloseRentalInstructionAsync(input, options);
+    return createConfigSelector(async () => {
+        const instructionsModule = getModule('instructions');
+        return instructionsModule.getCloseRentalInstructionAsync(input, options);
     });
 }
 //# sourceMappingURL=close.js.map