@kadi.build/deploy-ability 0.0.3 → 0.0.5

package/dist/targets/akash/blockchain-client.js

@@ -1,803 +0,0 @@
-/**
- * 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 { Registry } from '@cosmjs/proto-signing';
-import { getAkashTypeRegistry, getTypeUrl } from '@akashnetwork/akashjs/build/stargate/index.js';
-import { getRpc } from '@akashnetwork/akashjs/build/rpc/index.js';
-import { QueryBidsRequest, QueryClientImpl as QueryMarketClient, MsgCreateLease, LeaseID, } from '@akashnetwork/akash-api/akash/market/v1beta4';
-import { MsgCreateDeployment, MsgCloseDeployment, } from '@akashnetwork/akash-api/akash/deployment/v1beta3';
-import { success, failure } from '../../types/index.js';
-import { DeploymentError } from '../../errors/index.js';
-import { getNetworkConfig, isProviderBlacklisted } from './environment.js';
-import { createBidPricing } from './bid-types.js';
-import { fetchAllProviders } from './provider-service.js';
-/**
- * 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 async function createSigningClient(wallet, network) {
-    try {
-        // Step 1: Create Cosmos SDK type registry with Akash-specific message types
-        // The Akash type registry includes all necessary Cosmos SDK types plus
-        // Akash deployment/market/provider message types. We don't need to merge
-        // with defaultRegistryTypes as the Akash registry is already complete.
-        const registry = new Registry(getAkashTypeRegistry());
-        // Step 2: Get RPC endpoint for the selected network
-        const networkConfig = getNetworkConfig(network);
-        const rpc = networkConfig.rpc;
-        // Step 3: Get accounts from wallet's offline signer
-        // The offline signer provides accounts without needing network access
-        const accounts = await wallet.offlineSigner.getAccounts();
-        if (accounts.length === 0) {
-            return {
-                success: false,
-                error: new DeploymentError('No accounts found in wallet', 'WALLET_ERROR', {}, false, 'Please check your wallet connection and ensure it has at least one account'),
-            };
-        }
-        // Step 4: Create SigningStargateClient connected to Akash RPC
-        // This client can sign and broadcast transactions using the wallet's signer
-        const client = await SigningStargateClient.connectWithSigner(rpc, wallet.offlineSigner, { registry });
-        // Step 5: Return client and account info for transaction operations
-        const account = accounts[0];
-        return {
-            success: true,
-            data: {
-                client,
-                account: {
-                    address: account.address,
-                    pubkey: account.pubkey,
-                    accountNumber: 0, // Will be fetched from chain when needed
-                    sequence: 0, // Will be fetched from chain when needed
-                },
-            },
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: new DeploymentError(`Failed to create signing client: ${error}`, 'RPC_ERROR', { error: String(error) }, false, 'Check network connection and RPC endpoint availability'),
-        };
-    }
-}
-/**
- * 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 async function createDeployment(clientContext, wallet, sdl, depositAkt = 5) {
-    try {
-        const { client, account } = clientContext;
-        const owner = wallet.address;
-        // Step 1: Get current block height for dseq
-        // The deployment sequence number (dseq) uniquely identifies this deployment.
-        // Using block height ensures uniqueness and monotonic increase.
-        const dseq = await client.getHeight();
-        // Step 2: Extract deployment groups and manifest version from SDL
-        // The SDL library from @akashnetwork/akashjs handles all validation
-        // and returns properly structured deployment groups ready for blockchain.
-        // We trust the SDK - no manual normalization needed!
-        const groups = sdl.groups();
-        const manifestVersion = await sdl.manifestVersion();
-        // Step 3: Calculate escrow deposit in uakt (micro-AKT)
-        // 1 AKT = 1,000,000 uakt
-        // The deposit is held in escrow and returned when deployment closes
-        const aktAmount = Number.isFinite(depositAkt) && depositAkt > 0 ? depositAkt : 5;
-        const depositUakt = Math.round(aktAmount * 1_000_000).toString();
-        // Step 4: Create deployment message with all parameters
-        const msg = MsgCreateDeployment.fromPartial({
-            id: { owner, dseq },
-            groups: groups, // Trust SDL - it returns correct structure
-            version: manifestVersion,
-            deposit: { amount: depositUakt, denom: 'uakt' },
-            depositor: owner,
-        });
-        // Step 5: Wrap message with type-safe URL
-        // getTypeUrl() ensures we use the correct protobuf type identifier
-        // for this message type, preventing runtime errors from typos
-        const anyMsg = {
-            typeUrl: getTypeUrl(MsgCreateDeployment),
-            value: msg,
-        };
-        // Step 6: Set transaction fee
-        // Gas estimation: 300,000 gas units
-        // Fee: 8,000 uakt (approximately 0.008 AKT)
-        const fee = {
-            amount: [{ denom: 'uakt', amount: '8000' }],
-            gas: '300000',
-        };
-        // Step 7: Sign and broadcast deployment transaction
-        const res = await client.signAndBroadcast(account.address, [anyMsg], fee, 'Create deployment via deploy-ability');
-        // Step 8: Check transaction result
-        // code === 0 means success, any other code is an error
-        if (res.code !== 0) {
-            return {
-                success: false,
-                error: new DeploymentError(`Deployment transaction failed: ${res.rawLog}`, 'TRANSACTION_FAILED', {
-                    code: res.code,
-                    rawLog: res.rawLog,
-                    transactionHash: res.transactionHash,
-                }, false, 'Check wallet balance (need funds for deposit + fees) and SDL validity'),
-            };
-        }
-        // Step 9: Return deployment result with dseq
-        return {
-            success: true,
-            data: {
-                dseq,
-                transactionHash: res.transactionHash,
-                height: res.height,
-            },
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: new DeploymentError(`Failed to create deployment: ${error}`, 'DEPLOYMENT_FAILED', { error: String(error) }, false, 'Check wallet connection, network status, and SDL validity'),
-        };
-    }
-}
-/**
- * Extract valid bids from marketplace response
- *
- * The marketplace returns bid responses in a wrapped format. We filter
- * for bids that exist and have valid provider addresses, then filter out
- * blacklisted providers.
- *
- * **Why this is needed:**
- * QueryBidsResponse.bids is an array of { bid?: Bid } where bid might be
- * undefined. We extract the actual Bid objects and validate them.
- *
- * @param response - Raw bids response from marketplace query
- * @returns Array of valid provider bids
- */
-function extractValidBids(response) {
-    if (!response.bids)
-        return [];
-    return response.bids
-        .filter((b) => b.bid !== undefined && b.bid !== null)
-        .map((b) => b.bid)
-        .filter((bid) => {
-        const provider = bid.bidId?.provider ?? '';
-        return provider !== '';
-    });
-}
-/**
- * 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 async function queryBids(wallet, network, dseq, options) {
-    try {
-        // Step 1: Get RPC endpoint for network
-        const networkConfig = getNetworkConfig(network);
-        const rpc = await getRpc(networkConfig.rpc);
-        // Step 2: Create marketplace query client
-        const queryClient = new QueryMarketClient(rpc);
-        // Step 3: Build bid query request
-        // Filter for open bids for this specific deployment
-        const request = QueryBidsRequest.fromPartial({
-            filters: {
-                owner: wallet.address,
-                dseq: dseq.toString(),
-                state: 'open',
-            },
-        });
-        // Step 4: Query marketplace for bids
-        const response = await queryClient.Bids(request);
-        // Step 5: Build effective blacklist (built-in + custom)
-        // Convert custom blacklist to Set for O(1) lookup
-        const customBlacklistSet = new Set((options?.customBlacklist || [])
-            .map((addr) => (typeof addr === 'string' ? addr.trim() : ''))
-            .filter((addr) => addr.length > 0));
-        // Step 6: Extract and filter valid bids
-        // Remove bids from blacklisted providers (unreliable/problematic)
-        const validBids = extractValidBids(response).filter((bid) => {
-            const provider = bid.bidId?.provider ?? '';
-            return (provider !== '' &&
-                !isProviderBlacklisted(provider) &&
-                !customBlacklistSet.has(provider));
-        });
-        // Step 7: If no bids found, return empty array
-        if (validBids.length === 0) {
-            return success([]);
-        }
-        // Step 8: Fetch ALL provider metadata from Console API
-        // This is much more efficient than fetching individual providers
-        // and matches how the web console works
-        const providerInfoResult = await fetchAllProviders(network);
-        // If provider info fetch failed, we can still continue with basic data
-        const providerInfoMap = providerInfoResult.success
-            ? providerInfoResult.data
-            : new Map();
-        // Step 9: Transform raw bids into EnhancedBids
-        const enhancedBids = [];
-        for (const bid of validBids) {
-            const provider = bid.bidId?.provider;
-            if (!provider)
-                continue;
-            // Get provider info (or create minimal fallback)
-            let providerInfo = providerInfoMap.get(provider);
-            if (!providerInfo) {
-                providerInfo = {
-                    owner: provider,
-                    hostUri: '', // Will be populated when creating lease
-                    isAudited: false,
-                };
-            }
-            // Filter out offline providers if requested
-            if (!options?.includeOffline &&
-                providerInfo.reliability &&
-                !providerInfo.reliability.isOnline) {
-                continue;
-            }
-            // Create pricing information
-            const pricing = createBidPricing({
-                denom: bid.price?.denom || 'uakt',
-                amount: bid.price?.amount || '0',
-            });
-            // Construct enhanced bid with unique ID
-            const bidId = `${provider}-${dseq}-${bid.bidId?.gseq}-${bid.bidId?.oseq}`;
-            const enhancedBid = {
-                id: bidId,
-                bid,
-                provider: providerInfo,
-                pricing,
-                createdAt: new Date(), // Bid creation time
-            };
-            enhancedBids.push(enhancedBid);
-        }
-        return success(enhancedBids);
-    }
-    catch (error) {
-        return failure(new DeploymentError(`Failed to query bids: ${error}`, 'QUERY_FAILED', { error: String(error), dseq }, true, 'Check network connection and try again'));
-    }
-}
-/**
- * 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 async function waitForBids(wallet, network, dseq, options) {
-    const pollInterval = 5000; // 5 seconds
-    const timeoutMs = options?.timeoutMs ?? 300000; // Default: 5 minutes
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeoutMs) {
-        // Query for bids with provided options
-        const bidResult = await queryBids(wallet, network, dseq, {
-            customBlacklist: options?.customBlacklist,
-            includeOffline: options?.includeOffline,
-        });
-        // Check for query errors
-        if (!bidResult.success) {
-            return bidResult;
-        }
-        // Check if we got at least one bid
-        if (bidResult.data.length > 0) {
-            return success(bidResult.data);
-        }
-        // Wait before next poll
-        await new Promise((resolve) => setTimeout(resolve, pollInterval));
-    }
-    // Timeout reached without receiving bids
-    return failure(new DeploymentError('Timeout waiting for provider bids', 'TIMEOUT', { dseq, timeoutMs }, true, 'No providers bid within timeout. Try: 1) Increase resources to attract more providers, 2) Increase deposit amount, 3) Check if your requirements are too specific'));
-}
-/**
- * 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 async function createLease(clientContext, bid) {
-    try {
-        const { client, account } = clientContext;
-        const { bidId } = bid;
-        // Step 1: Create lease message from accepted bid
-        // The bid ID contains all coordinates needed to create the lease
-        const msg = {
-            typeUrl: getTypeUrl(MsgCreateLease),
-            value: MsgCreateLease.fromPartial({ bidId }),
-        };
-        // Step 2: Estimate gas dynamically
-        // Simulate the transaction to get accurate gas estimation
-        const gasEstimation = await client.simulate(account.address, [msg], 'Create lease via deploy-ability');
-        // Add 60% safety margin for Akash Network transactions
-        // Matches Akash Console's GAS_SAFETY_MULTIPLIER (1.6x)
-        const gasLimit = Math.ceil(gasEstimation * 1.6);
-        // Set transaction fee with dynamic gas limit
-        // Fee: 5,000 uakt (approximately 0.005 AKT)
-        const fee = {
-            amount: [{ denom: 'uakt', amount: '5000' }],
-            gas: gasLimit.toString(),
-        };
-        // Step 3: Sign and broadcast lease transaction
-        const res = await client.signAndBroadcast(account.address, [msg], fee, 'Create lease via deploy-ability');
-        // Step 4: Check transaction result
-        if (res.code !== 0) {
-            return {
-                success: false,
-                error: new DeploymentError(`Lease transaction failed: ${res.rawLog}`, 'TRANSACTION_FAILED', {
-                    code: res.code,
-                    rawLog: res.rawLog,
-                    transactionHash: res.transactionHash,
-                }, false, 'Check wallet balance and bid validity. The bid may have expired or been withdrawn by the provider.'),
-            };
-        }
-        // Step 5: Return lease result with full coordinates
-        // The lease ID contains all information needed to interact with the provider
-        // BidID and LeaseID are structurally identical, so we extract the fields
-        // rather than using type casting (TypeScript sees them as different nominal types)
-        if (!bidId) {
-            return {
-                success: false,
-                error: new DeploymentError('Bid ID is missing from bid', 'INVALID_BID', { bid }, false, 'This should not happen - verify bid data structure'),
-            };
-        }
-        return {
-            success: true,
-            data: {
-                // Use LeaseID.fromPartial() to create proper protobuf type with $type field
-                leaseId: LeaseID.fromPartial({
-                    owner: bidId.owner,
-                    provider: bidId.provider,
-                    dseq: bidId.dseq,
-                    gseq: bidId.gseq,
-                    oseq: bidId.oseq,
-                }),
-                transactionHash: res.transactionHash,
-                height: res.height,
-            },
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: new DeploymentError(`Failed to create lease: ${error}`, 'LEASE_FAILED', { error: String(error) }, false, 'Check wallet connection and bid parameters'),
-        };
-    }
-}
-/**
- * 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 '@kadi.build/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 async function closeDeployment(clientContext, wallet, dseq) {
-    try {
-        const { client, account } = clientContext;
-        // Convert dseq to string for the message
-        const dseqString = typeof dseq === 'string' ? dseq : dseq.toString();
-        // Step 1: Create close deployment message
-        // This message tells the blockchain to terminate the deployment
-        // and return the escrow deposit to the owner
-        const msg = MsgCloseDeployment.fromPartial({
-            id: {
-                dseq: dseqString,
-                owner: wallet.address,
-            },
-        });
-        // Step 2: Wrap message with type-safe URL
-        const anyMsg = {
-            typeUrl: getTypeUrl(MsgCloseDeployment),
-            value: msg,
-        };
-        // Step 3: Estimate gas dynamically
-        // Simulate the transaction to get accurate gas estimation
-        // This prevents out-of-gas errors for deployments with many resources
-        const gasEstimation = await client.simulate(account.address, [anyMsg], 'Close deployment via deploy-ability');
-        // Add 60% safety margin for Akash Network transactions
-        // Matches Akash Console's GAS_SAFETY_MULTIPLIER (1.6x)
-        const gasLimit = Math.ceil(gasEstimation * 1.6);
-        // Set transaction fee with dynamic gas limit
-        // Fee: 5,000 uakt (approximately 0.005 AKT)
-        const fee = {
-            amount: [{ denom: 'uakt', amount: '5000' }],
-            gas: gasLimit.toString(),
-        };
-        // Step 4: Sign and broadcast close deployment transaction
-        const res = await client.signAndBroadcast(account.address, [anyMsg], fee, 'Close deployment via deploy-ability');
-        // Step 5: Check transaction result
-        // code === 0 means success, any other code is an error
-        if (res.code !== 0) {
-            return failure(new DeploymentError(`Close deployment transaction failed: ${res.rawLog}`, 'TRANSACTION_FAILED', {
-                code: res.code,
-                rawLog: res.rawLog,
-                transactionHash: res.transactionHash,
-                dseq: dseqString,
-            }, false, 'Common causes: Not deployment owner, deployment already closed, or insufficient funds for fees'));
-        }
-        // Step 6: Return closure confirmation
-        return success({
-            dseq: dseqString,
-            owner: wallet.address,
-            transactionHash: res.transactionHash,
-            height: res.height,
-            closedAt: new Date(),
-        });
-    }
-    catch (error) {
-        return failure(new DeploymentError(`Failed to close deployment: ${error}`, 'DEPLOYMENT_CLOSE_FAILED', { error: String(error), dseq: String(dseq) }, false, 'Check wallet connection, network status, and deployment ownership'));
-    }
-}
-//# sourceMappingURL=blockchain-client.js.map