@kadi.build/deploy-ability 0.0.1

package/dist/targets/akash/bid-types.js

@@ -0,0 +1,89 @@
+/**
+ * Bid Types and Pricing
+ *
+ * Type definitions for enhanced provider bids including comprehensive pricing
+ * calculations across multiple time periods (hour, day, week, month) and
+ * currencies (uAKT, AKT, USD).
+ *
+ * @module targets/akash/bid-types
+ */
+/**
+ * Average time between blocks on Akash Network (in seconds)
+ *
+ * This value is determined empirically by observing actual block times.
+ * Akash Console uses 6.098 seconds as the average.
+ *
+ * Used for calculating time-based pricing from per-block prices.
+ */
+const AVERAGE_BLOCK_TIME_SECONDS = 6.098;
+/**
+ * Average number of days in a month (365.25 / 12)
+ *
+ * Using the astronomical year (365.25 days) divided by 12 months
+ * provides accurate monthly cost estimates accounting for leap years.
+ */
+const AVERAGE_DAYS_IN_MONTH = 30.437;
+/**
+ * Conversion factor: 1 AKT = 1,000,000 uAKT
+ */
+const UAKT_PER_AKT = 1_000_000;
+/**
+ * Create BidPricing instance from blockchain price data
+ *
+ * Calculates all time-period prices from the raw per-block price.
+ *
+ * @param price - Price object from blockchain bid
+ * @param price.denom - Denomination (typically "uakt")
+ * @param price.amount - Amount per block as string
+ * @returns Complete pricing information across all time periods
+ *
+ * @example
+ * ```typescript
+ * const pricing = createBidPricing({
+ *   denom: 'uakt',
+ *   amount: '1234'
+ * });
+ * console.log(pricing.akt.perMonth); // Monthly cost in AKT
+ * ```
+ */
+export function createBidPricing(price) {
+    // Parse raw price per block
+    const pricePerBlock = parseFloat(price.amount);
+    // Calculate number of blocks for each time period
+    const blocksPerHour = (60 * 60) / AVERAGE_BLOCK_TIME_SECONDS;
+    const blocksPerDay = (24 * 60 * 60) / AVERAGE_BLOCK_TIME_SECONDS;
+    const blocksPerWeek = (7 * 24 * 60 * 60) / AVERAGE_BLOCK_TIME_SECONDS;
+    const blocksPerMonth = (AVERAGE_DAYS_IN_MONTH * 24 * 60 * 60) / AVERAGE_BLOCK_TIME_SECONDS;
+    // Calculate prices in uAKT for all time periods
+    const uaktPricing = {
+        perBlock: pricePerBlock,
+        perHour: pricePerBlock * blocksPerHour,
+        perDay: pricePerBlock * blocksPerDay,
+        perWeek: pricePerBlock * blocksPerWeek,
+        perMonth: pricePerBlock * blocksPerMonth,
+    };
+    // Calculate prices in AKT (divide uAKT by 1,000,000)
+    const aktPricing = {
+        perBlock: uaktPricing.perBlock / UAKT_PER_AKT,
+        perHour: uaktPricing.perHour / UAKT_PER_AKT,
+        perDay: uaktPricing.perDay / UAKT_PER_AKT,
+        perWeek: uaktPricing.perWeek / UAKT_PER_AKT,
+        perMonth: uaktPricing.perMonth / UAKT_PER_AKT,
+    };
+    // Return pricing object with USD conversion method
+    return {
+        raw: {
+            denom: price.denom,
+            amount: price.amount,
+        },
+        uakt: uaktPricing,
+        akt: aktPricing,
+        toUSD: (aktPriceUSD) => ({
+            perHour: aktPricing.perHour * aktPriceUSD,
+            perDay: aktPricing.perDay * aktPriceUSD,
+            perWeek: aktPricing.perWeek * aktPriceUSD,
+            perMonth: aktPricing.perMonth * aktPriceUSD,
+        }),
+    };
+}
+//# sourceMappingURL=bid-types.js.map

package/dist/targets/akash/bid-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bid-types.js","sourceRoot":"","sources":["../../../src/targets/akash/bid-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH;;;;;;;GAOG;AACH,MAAM,0BAA0B,GAAG,KAAK,CAAC;AAEzC;;;;;GAKG;AACH,MAAM,qBAAqB,GAAG,MAAM,CAAC;AAErC;;GAEG;AACH,MAAM,YAAY,GAAG,SAAS,CAAC;AAyH/B;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAGhC;IACC,4BAA4B;IAC5B,MAAM,aAAa,GAAG,UAAU,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAE/C,kDAAkD;IAClD,MAAM,aAAa,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,0BAA0B,CAAC;IAC7D,MAAM,YAAY,GAAG,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,GAAG,0BAA0B,CAAC;IACjE,MAAM,aAAa,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,GAAG,0BAA0B,CAAC;IACtE,MAAM,cAAc,GAAG,CAAC,qBAAqB,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,GAAG,0BAA0B,CAAC;IAE3F,gDAAgD;IAChD,MAAM,WAAW,GAAG;QAClB,QAAQ,EAAE,aAAa;QACvB,OAAO,EAAE,aAAa,GAAG,aAAa;QACtC,MAAM,EAAE,aAAa,GAAG,YAAY;QACpC,OAAO,EAAE,aAAa,GAAG,aAAa;QACtC,QAAQ,EAAE,aAAa,GAAG,cAAc;KACzC,CAAC;IAEF,qDAAqD;IACrD,MAAM,UAAU,GAAG;QACjB,QAAQ,EAAE,WAAW,CAAC,QAAQ,GAAG,YAAY;QAC7C,OAAO,EAAE,WAAW,CAAC,OAAO,GAAG,YAAY;QAC3C,MAAM,EAAE,WAAW,CAAC,MAAM,GAAG,YAAY;QACzC,OAAO,EAAE,WAAW,CAAC,OAAO,GAAG,YAAY;QAC3C,QAAQ,EAAE,WAAW,CAAC,QAAQ,GAAG,YAAY;KAC9C,CAAC;IAEF,mDAAmD;IACnD,OAAO;QACL,GAAG,EAAE;YACH,KAAK,EAAE,KAAK,CAAC,KAAK;YAClB,MAAM,EAAE,KAAK,CAAC,MAAM;SACrB;QACD,IAAI,EAAE,WAAW;QACjB,GAAG,EAAE,UAAU;QACf,KAAK,EAAE,CAAC,WAAmB,EAAE,EAAE,CAAC,CAAC;YAC/B,OAAO,EAAE,UAAU,CAAC,OAAO,GAAG,WAAW;YACzC,MAAM,EAAE,UAAU,CAAC,MAAM,GAAG,WAAW;YACvC,OAAO,EAAE,UAAU,CAAC,OAAO,GAAG,WAAW;YACzC,QAAQ,EAAE,UAAU,CAAC,QAAQ,GAAG,WAAW;SAC5C,CAAC;KACH,CAAC;AACJ,CAAC"}

package/dist/targets/akash/blockchain-client.d.ts

@@ -0,0 +1,577 @@
+/**
+ * Akash Network Blockchain Client Module
+ *
+ * Handles all blockchain operations for Akash Network deployments including:
+ * - Signing client creation and management
+ * - Deployment creation on blockchain
+ * - Provider bid collection and filtering
+ * - Lease creation with selected providers
+ *
+ * Design Philosophy:
+ * This is a LIBRARY, not a CLI. Operations return Result types with detailed
+ * data. The caller (deployer.ts) handles progress tracking and user feedback.
+ *
+ * We use the Akash SDK types and helpers directly rather than reinventing them.
+ * The SDK is well-designed and thoroughly tested - we enhance the DX with Result
+ * types and comprehensive comments.
+ *
+ * @module targets/akash/blockchain-client
+ */
+import { SigningStargateClient } from '@cosmjs/stargate';
+import { Bid, LeaseID } from '@akashnetwork/akash-api/akash/market/v1beta4';
+import type { Result } from '../../types/index.js';
+import type { WalletContext } from './types.js';
+import { DeploymentError } from '../../errors/index.js';
+import { type AkashNetwork } from './environment.js';
+import type { EnhancedBid } from './bid-types.js';
+/**
+ * Re-export SDK types for convenience
+ *
+ * We use the native Akash SDK types directly rather than creating
+ * custom interfaces. This ensures type compatibility with SDK functions
+ * and reduces maintenance burden when SDK updates.
+ *
+ * @example Using SDK types
+ * ```typescript
+ * import { ProviderBid, LeaseId } from './blockchain-client.js';
+ *
+ * function processBid(bid: ProviderBid) {
+ *   console.log('Provider:', bid.bidId?.provider);
+ * }
+ * ```
+ */
+export type ProviderBid = Bid;
+export type LeaseId = LeaseID;
+/**
+ * Signing client with account information
+ *
+ * Contains the SigningStargateClient needed for broadcasting transactions
+ * plus account information for transaction signing.
+ */
+export interface SigningClientContext {
+    /** Signing client for blockchain transactions */
+    client: SigningStargateClient;
+    /** Account information */
+    account: {
+        /** Account address (bech32 format) */
+        address: string;
+        /** Account public key (null if never used) */
+        pubkey: Uint8Array | null;
+        /** Unique account number */
+        accountNumber: number;
+        /** Transaction sequence (nonce) */
+        sequence: number;
+    };
+}
+/**
+ * Deployment creation result
+ *
+ * Contains the deployment sequence number (dseq) which uniquely identifies
+ * your deployment on the Akash Network, plus transaction metadata.
+ */
+export interface DeploymentResult {
+    /** Deployment sequence number - unique identifier for this deployment */
+    dseq: number;
+    /** Transaction hash on the blockchain */
+    transactionHash: string;
+    /** Block height where transaction was included */
+    height: number;
+}
+/**
+ * Lease creation result
+ *
+ * Contains the lease identifier and transaction metadata after successfully
+ * accepting a provider's bid.
+ */
+export interface LeaseResult {
+    /** Lease identifier with all coordinates */
+    leaseId: LeaseId;
+    /** Transaction hash on the blockchain */
+    transactionHash: string;
+    /** Block height where transaction was included */
+    height: number;
+}
+/**
+ * Deployment closure result
+ *
+ * Contains confirmation details after successfully closing a deployment.
+ * When a deployment is closed, all associated leases are terminated and
+ * the escrow deposit is returned to the deployment owner.
+ */
+export interface DeploymentCloseResult {
+    /** Deployment sequence number that was closed */
+    dseq: string;
+    /** Owner address of the deployment */
+    owner: string;
+    /** Transaction hash on the blockchain */
+    transactionHash: string;
+    /** Block height where transaction was included */
+    height: number;
+    /** Timestamp when closure was completed */
+    closedAt: Date;
+}
+/**
+ * SDL (Stack Definition Language) interface
+ *
+ * Represents a parsed Akash deployment manifest. The SDL defines
+ * your application's compute resources, networking, and placement
+ * requirements.
+ *
+ * This interface describes the minimal SDL operations needed by
+ * the blockchain client. The actual SDL parsing and validation
+ * is handled by @akashnetwork/akashjs.
+ *
+ * **The SDK handles all validation:**
+ * - Resource requirement validation
+ * - Service configuration validation
+ * - Network configuration validation
+ * - Pricing validation
+ *
+ * You get back properly-structured deployment groups ready for blockchain.
+ *
+ * @see https://akash.network/docs/guides/sdl
+ *
+ * @example Using SDL
+ * ```typescript
+ * import { SDL } from '@akashnetwork/akashjs/build/sdl';
+ *
+ * const sdl = SDL.fromString(yamlContent, 'beta3');
+ * const groups = sdl.groups();  // Already validated and structured!
+ * ```
+ */
+export interface SDL {
+    /**
+     * Get deployment groups from SDL
+     *
+     * Groups organize services with similar resource requirements.
+     * Each group becomes a separate order on the marketplace.
+     *
+     * The SDK returns these already validated and in the correct
+     * protobuf structure for MsgCreateDeployment.
+     *
+     * @returns Array of deployment group specifications
+     */
+    groups(): unknown[];
+    /**
+     * Calculate manifest version hash
+     *
+     * The manifest version is a SHA-256 hash of your deployment configuration.
+     * Providers use this to verify they're running the correct manifest.
+     *
+     * This hash changes whenever you update your deployment configuration,
+     * ensuring providers always run the latest version.
+     *
+     * @returns Uint8Array containing SHA256 hash of manifest
+     */
+    manifestVersion(): Promise<Uint8Array>;
+}
+/**
+ * Create a signing client for Akash blockchain operations
+ *
+ * Creates a SigningStargateClient configured with Akash-specific message
+ * types. This client is used for all blockchain transactions including
+ * deployment creation, lease creation, and certificate broadcasting.
+ *
+ * **Why you need this:**
+ * The Akash blockchain uses custom message types (MsgCreateDeployment,
+ * MsgCreateLease, etc.) that aren't in the standard Cosmos SDK. We need
+ * to register these types so the client can encode/decode them correctly.
+ *
+ * **What you get:**
+ * - A signing client connected to Akash RPC
+ * - Account information for transaction signing
+ * - Ability to broadcast any Akash transaction
+ *
+ * @param wallet - Wallet context with offline signer
+ * @param network - Akash network to connect to
+ * @returns Result with signing client and account info
+ *
+ * @example Basic usage
+ * ```typescript
+ * const clientResult = await createSigningClient(wallet, 'mainnet');
+ * if (!clientResult.success) {
+ *   console.error('Failed to create client:', clientResult.error.message);
+ *   return;
+ * }
+ *
+ * const { client, account } = clientResult.data;
+ * console.log('Connected with address:', account.address);
+ * ```
+ *
+ * @example Error handling
+ * ```typescript
+ * const result = await createSigningClient(wallet, 'testnet');
+ * if (!result.success) {
+ *   if (result.error.code === 'WALLET_ERROR') {
+ *     console.error('Wallet issue - check connection');
+ *   } else if (result.error.code === 'RPC_ERROR') {
+ *     console.error('Network issue - try different RPC endpoint');
+ *   }
+ *   return;
+ * }
+ * ```
+ */
+export declare function createSigningClient(wallet: WalletContext, network: AkashNetwork): Promise<Result<SigningClientContext, DeploymentError>>;
+/**
+ * Create a new Akash deployment on the blockchain
+ *
+ * Broadcasts a MsgCreateDeployment transaction that registers your application
+ * with the Akash marketplace. Providers will see this deployment and submit bids.
+ *
+ * **The deployment process:**
+ * 1. Your deployment gets a unique identifier (dseq = deployment sequence)
+ * 2. Deployment is posted to the blockchain with resource requirements
+ * 3. An escrow deposit is held (default 5 AKT, returned when you close)
+ * 4. Providers see your deployment and submit competitive bids
+ * 5. You choose a bid and create a lease
+ *
+ * **Escrow Deposit:**
+ * The deposit ensures you can pay for resources. It's returned when you
+ * close the deployment. Default is 5 AKT but you can customize it.
+ *
+ * **About dseq:**
+ * The deployment sequence number (dseq) is taken from the current block
+ * height, ensuring it's unique and monotonically increasing.
+ *
+ * @param clientContext - Signing client and account info
+ * @param wallet - Wallet context with address
+ * @param sdl - SDL object with deployment configuration
+ * @param depositAkt - Optional deposit amount in AKT (default: 5)
+ * @returns Result with deployment sequence number and transaction info
+ *
+ * @example Basic deployment
+ * ```typescript
+ * import { SDL } from '@akashnetwork/akashjs/build/sdl';
+ *
+ * // Parse SDL from YAML
+ * const sdl = SDL.fromString(yamlContent, 'beta3');
+ *
+ * // Create signing client
+ * const clientResult = await createSigningClient(wallet, 'mainnet');
+ * if (!clientResult.success) return clientResult;
+ *
+ * // Deploy with default 5 AKT deposit
+ * const deployResult = await createDeployment(
+ *   clientResult.data,
+ *   wallet,
+ *   sdl
+ * );
+ *
+ * if (deployResult.success) {
+ *   console.log('Deployment created!');
+ *   console.log('DSEQ:', deployResult.data.dseq);
+ *   console.log('TX:', deployResult.data.transactionHash);
+ * }
+ * ```
+ *
+ * @example Custom deposit
+ * ```typescript
+ * // Deploy with 10 AKT deposit for larger deployments
+ * const result = await createDeployment(
+ *   clientContext,
+ *   wallet,
+ *   sdl,
+ *   10  // 10 AKT deposit
+ * );
+ * ```
+ */
+export declare function createDeployment(clientContext: SigningClientContext, wallet: WalletContext, sdl: SDL, depositAkt?: number): Promise<Result<DeploymentResult, DeploymentError>>;
+/**
+ * Query provider bids for a deployment with enhanced information
+ *
+ * Queries the Akash marketplace for provider bids and enriches each bid with:
+ * - Complete provider information (name, location, audit status)
+ * - Reliability metrics (uptime percentages)
+ * - Pre-calculated pricing for all time periods (hour, day, week, month)
+ *
+ * Returns ALL valid bids so the caller can implement custom selection logic.
+ *
+ * **The Akash Bidding Process:**
+ * After you create a deployment, here's what happens:
+ * 1. Providers monitor the blockchain for new deployments
+ * 2. They check if they can fulfill your resource requirements
+ * 3. They submit competitive bids with their pricing
+ * 4. You query to see available bids (this function)
+ * 5. You choose the best bid based on your criteria
+ * 6. You create a lease with the selected provider
+ *
+ * **Bid Filtering:**
+ * We automatically exclude:
+ * - Blacklisted providers (known to be unreliable)
+ * - Custom blacklist from your deployment configuration
+ * - Bids without valid provider addresses
+ *
+ * **Note:** This returns immediately with current state. Use `waitForBids()`
+ * if you want to poll until bids arrive.
+ *
+ * @param wallet - Wallet context with owner address
+ * @param network - Akash network to query
+ * @param dseq - Deployment sequence number
+ * @param options - Optional query options
+ * @param options.customBlacklist - Additional provider addresses to exclude
+ * @param options.includeOffline - Include offline providers (default: false)
+ * @returns Result with array of enhanced bids (empty array if none found)
+ *
+ * @example Query and display bids
+ * ```typescript
+ * const result = await queryBids(wallet, 'mainnet', dseq);
+ *
+ * if (result.success) {
+ *   console.log(`Received ${result.data.length} bids`);
+ *   for (const bid of result.data) {
+ *     const provider = bid.provider;
+ *     const uptime = provider.reliability?.uptime7d;
+ *     console.log(`
+ *       Provider: ${provider.name || provider.owner}
+ *       Price: ${bid.pricing.akt.perMonth.toFixed(2)} AKT/month
+ *       Uptime (7d): ${uptime ? (uptime * 100).toFixed(1) + '%' : 'Unknown'}
+ *       Location: ${provider.location?.country || 'Unknown'}
+ *     `);
+ *   }
+ * }
+ * ```
+ *
+ * @example With filtering options
+ * ```typescript
+ * const blacklist = ['akash1badprovider...', 'akash1another...'];
+ * const result = await queryBids(wallet, 'mainnet', dseq, {
+ *   customBlacklist: blacklist,
+ *   includeOffline: false
+ * });
+ * ```
+ */
+export declare function queryBids(wallet: WalletContext, network: AkashNetwork, dseq: number, options?: {
+    readonly customBlacklist?: string[];
+    readonly includeOffline?: boolean;
+}): Promise<Result<EnhancedBid[], DeploymentError>>;
+/**
+ * Wait for provider bids with polling
+ *
+ * Polls the marketplace for provider bids until at least one valid bid is received
+ * or timeout is reached. This is a convenience wrapper around `queryBids()` that
+ * handles the polling logic for you.
+ *
+ * Returns ALL enhanced bids received, allowing the caller to implement custom
+ * selection logic based on price, reliability, location, or other criteria.
+ *
+ * **Why this is useful:**
+ * After creating a deployment, providers need time to:
+ * 1. See your deployment on the blockchain
+ * 2. Check if they can fulfill requirements
+ * 3. Calculate pricing
+ * 4. Submit their bid
+ *
+ * This usually takes 30-60 seconds. This function handles the wait for you.
+ *
+ * **Polling Strategy:**
+ * - Poll interval: 5 seconds (reasonable for network latency)
+ * - Default timeout: 5 minutes (enough for providers to respond)
+ * - Returns immediately when at least one bid is found
+ * - Returns all errors from query operation
+ *
+ * @param wallet - Wallet context with owner address
+ * @param network - Akash network to query
+ * @param dseq - Deployment sequence number
+ * @param options - Optional query and polling options
+ * @param options.customBlacklist - Provider addresses to exclude
+ * @param options.includeOffline - Include offline providers (default: false)
+ * @param options.timeoutMs - Timeout in milliseconds (default: 300000 = 5 min)
+ * @returns Result with array of enhanced bids or timeout error
+ *
+ * @example Wait for bids and display
+ * ```typescript
+ * console.log('Waiting for provider bids...');
+ *
+ * const result = await waitForBids(wallet, 'mainnet', dseq);
+ *
+ * if (result.success) {
+ *   console.log(`Received ${result.data.length} bids!`);
+ *   for (const bid of result.data) {
+ *     console.log(`Provider: ${bid.provider.name || bid.provider.owner}`);
+ *     console.log(`Price: ${bid.pricing.akt.perMonth} AKT/month`);
+ *   }
+ * } else {
+ *   if (result.error.code === 'TIMEOUT') {
+ *     console.error('No bids received within timeout');
+ *     console.log('Try increasing deployment resources or deposit');
+ *   } else {
+ *     console.error('Query failed:', result.error.message);
+ *   }
+ * }
+ * ```
+ *
+ * @example Custom timeout and options
+ * ```typescript
+ * // Wait up to 10 minutes, excluding specific providers
+ * const result = await waitForBids(wallet, 'mainnet', dseq, {
+ *   customBlacklist: ['akash1bad...', 'akash1another...'],
+ *   includeOffline: false,
+ *   timeoutMs: 600000  // 10 minutes
+ * });
+ * ```
+ */
+export declare function waitForBids(wallet: WalletContext, network: AkashNetwork, dseq: number, options?: {
+    readonly customBlacklist?: string[];
+    readonly includeOffline?: boolean;
+    readonly timeoutMs?: number;
+}): Promise<Result<EnhancedBid[], DeploymentError>>;
+/**
+ * Create a lease by accepting a provider bid
+ *
+ * Broadcasts a MsgCreateLease transaction to accept a provider's bid and
+ * establish a lease. This commits the deployment to the selected provider
+ * and allows them to start running your containers.
+ *
+ * **What happens when you create a lease:**
+ * 1. You accept a specific provider's bid
+ * 2. A lease is created on the blockchain
+ * 3. The provider is notified of the accepted bid
+ * 4. The provider prepares to receive your manifest
+ * 5. You send the manifest (deployment details) to the provider
+ * 6. The provider starts your containers
+ *
+ * **Important:** After creating the lease, you MUST send the manifest
+ * to the provider within a reasonable time, or they may close the lease.
+ *
+ * @param clientContext - Signing client and account info
+ * @param bid - Provider bid to accept
+ * @returns Result with lease identifier and transaction info
+ *
+ * @example Accept bid and create lease
+ * ```typescript
+ * // Wait for bids
+ * const bidResult = await waitForBids(wallet, 'mainnet', dseq);
+ * if (!bidResult.success) return bidResult;
+ *
+ * // Accept the bid by creating a lease
+ * const leaseResult = await createLease(clientContext, bidResult.data);
+ *
+ * if (leaseResult.success) {
+ *   const lease = leaseResult.data.leaseId;
+ *   console.log('Lease created!');
+ *   console.log('DSEQ:', lease.dseq);
+ *   console.log('Provider:', lease.provider);
+ *   console.log('TX:', leaseResult.data.transactionHash);
+ *
+ *   // Next step: send manifest to provider
+ *   await sendManifest(lease, manifest, certificate);
+ * }
+ * ```
+ *
+ * @example Error handling
+ * ```typescript
+ * const result = await createLease(clientContext, bid);
+ * if (!result.success) {
+ *   if (result.error.code === 'TRANSACTION_FAILED') {
+ *     console.error('Transaction failed:', result.error.context.rawLog);
+ *     console.log('Common causes: insufficient funds, bid expired');
+ *   }
+ * }
+ * ```
+ */
+export declare function createLease(clientContext: SigningClientContext, bid: ProviderBid): Promise<Result<LeaseResult, DeploymentError>>;
+/**
+ * Close an active Akash deployment
+ *
+ * Broadcasts a MsgCloseDeployment transaction that terminates all leases
+ * associated with the deployment and returns the escrow deposit to the owner.
+ *
+ * **What happens when you close a deployment:**
+ * 1. All active leases for this deployment are terminated
+ * 2. Providers stop running your containers
+ * 3. The escrow deposit (typically 5 AKT) is returned to your wallet
+ * 4. The deployment is marked as closed on the blockchain
+ *
+ * **When to close a deployment:**
+ * - When you're done with the deployment and want to stop paying
+ * - When migrating to a different provider or configuration
+ * - When cleaning up test/development deployments
+ * - Before wallet maintenance (to recover locked funds)
+ *
+ * **Important Notes:**
+ * - You can only close deployments you own
+ * - Closed deployments cannot be reopened (create a new deployment instead)
+ * - Always close deployments when done to avoid ongoing charges
+ * - The escrow deposit is returned immediately upon closure
+ *
+ * @param clientContext - Signing client and account info
+ * @param wallet - Wallet context (must be deployment owner)
+ * @param dseq - Deployment sequence number to close
+ * @returns Result with closure confirmation or error
+ *
+ * @example Close a deployment
+ * ```typescript
+ * import { closeDeployment, createSigningClient } from 'deploy-ability/akash';
+ *
+ * // Create signing client
+ * const clientResult = await createSigningClient(wallet, 'mainnet');
+ * if (!clientResult.success) {
+ *   console.error('Failed to create client:', clientResult.error.message);
+ *   return;
+ * }
+ *
+ * // Close the deployment
+ * const result = await closeDeployment(
+ *   clientResult.data,
+ *   wallet,
+ *   1234567  // DSEQ from deployment
+ * );
+ *
+ * if (result.success) {
+ *   console.log('Deployment closed successfully!');
+ *   console.log('DSEQ:', result.data.dseq);
+ *   console.log('TX:', result.data.transactionHash);
+ *   console.log('Deposit returned to:', result.data.owner);
+ * } else {
+ *   console.error('Failed to close:', result.error.message);
+ * }
+ * ```
+ *
+ * @example Close with error handling
+ * ```typescript
+ * const result = await closeDeployment(clientContext, wallet, dseq);
+ *
+ * if (!result.success) {
+ *   if (result.error.code === 'TRANSACTION_FAILED') {
+ *     console.error('Transaction failed:', result.error.context.rawLog);
+ *     // Common causes:
+ *     // - Not the deployment owner
+ *     // - Deployment already closed
+ *     // - Insufficient funds for transaction fee
+ *   } else if (result.error.code === 'WALLET_ERROR') {
+ *     console.error('Wallet issue - check connection');
+ *   }
+ * }
+ * ```
+ *
+ * @example Complete deployment lifecycle
+ * ```typescript
+ * // Deploy
+ * const deployment = await deployToAkash({
+ *   wallet,
+ *   certificate,
+ *   projectRoot: './',
+ *   profile: 'dev',
+ *   bidSelector: selectCheapestBid
+ * });
+ *
+ * if (deployment.success) {
+ *   console.log('Deployed with DSEQ:', deployment.data.dseq);
+ *
+ *   // ... use the deployment ...
+ *
+ *   // Close when done
+ *   const close = await closeDeployment(
+ *     clientContext,
+ *     wallet,
+ *     deployment.data.dseq
+ *   );
+ *
+ *   if (close.success) {
+ *     console.log('Cleaned up successfully');
+ *   }
+ * }
+ * ```
+ */
+export declare function closeDeployment(clientContext: SigningClientContext, wallet: WalletContext, dseq: number | string): Promise<Result<DeploymentCloseResult, DeploymentError>>;
+//# sourceMappingURL=blockchain-client.d.ts.map

package/dist/targets/akash/blockchain-client.d.ts.map

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