@kadi.build/deploy-ability 0.0.1

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

@@ -0,0 +1,803 @@
+/**
+ * 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 30% safety margin (standard for Cosmos SDK transactions)
+        // This matches cosmos-kit's default gas adjustment
+        const gasLimit = Math.ceil(gasEstimation * 1.3);
+        // 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 '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 30% safety margin (standard for Cosmos SDK transactions)
+        // This matches cosmos-kit's default gas adjustment
+        const gasLimit = Math.ceil(gasEstimation * 1.3);
+        // 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