import { createClient } from "@evolution-sdk/evolution";

const client = createClient({
  network: "mainnet",
  provider: {
    type: "blockfrost",
    baseUrl: "https://cardano-mainnet.blockfrost.io/api/v0",
    projectId: process.env.BLOCKFROST_PROJECT_ID!
  }
});

// Submit signed transaction
const signedTxCbor = "84a300..."; // Signed transaction CBOR
const txHash = await client.submitTx(signedTxCbor);

console.log("Transaction submitted:", txHash);

import { createClient } from "@evolution-sdk/evolution";

const client = createClient({
  network: "mainnet",
  provider: {
    type: "blockfrost",
    baseUrl: "https://cardano-mainnet.blockfrost.io/api/v0",
    projectId: process.env.BLOCKFROST_PROJECT_ID!
  }
});

const signedTxCbor = "84a300...";
const txHash = await client.submitTx(signedTxCbor);

// Wait for confirmation (checks every 5 seconds by default)
const confirmed = await client.awaitTx(txHash);

if (confirmed) {
  console.log("Transaction confirmed!");
} else {
  console.log("Transaction not found");
}

import { createClient } from "@evolution-sdk/evolution";

const client = createClient({
  network: "mainnet",
  provider: {
    type: "blockfrost",
    baseUrl: "https://cardano-mainnet.blockfrost.io/api/v0",
    projectId: process.env.BLOCKFROST_PROJECT_ID!
  }
});

const txHash = "abc123...";

// Check every 10 seconds
const confirmed = await client.awaitTx(txHash, 10000);

console.log("Confirmed:", confirmed);

import { createClient } from "@evolution-sdk/evolution";

const client = createClient({
  network: "mainnet",
  provider: {
    type: "blockfrost",
    baseUrl: "https://cardano-mainnet.blockfrost.io/api/v0",
    projectId: process.env.BLOCKFROST_PROJECT_ID!
  }
});

const unsignedTxCbor = "84a300..."; // Unsigned transaction

// Evaluate script execution
const redeemers = await client.evaluateTx(unsignedTxCbor);

redeemers.forEach((redeemer) => {
  console.log("Redeemer tag:", redeemer.redeemer_tag);
  console.log("Redeemer index:", redeemer.redeemer_index);
  console.log("Memory units:", redeemer.ex_units.mem);
  console.log("CPU steps:", redeemer.ex_units.steps);
});

import { createClient } from "@evolution-sdk/evolution";

const client = createClient({
  network: "mainnet",
  provider: {
    type: "blockfrost",
    baseUrl: "https://cardano-mainnet.blockfrost.io/api/v0",
    projectId: process.env.BLOCKFROST_PROJECT_ID!
  }
});

interface SubmissionResult {
  success: boolean;
  txHash?: string;
  confirmed?: boolean;
  error?: string;
}

export async function submitAndWait(
  signedTxCbor: string,
  checkInterval = 5000
): Promise<SubmissionResult> {
  try {
    const txHash = await client.submitTx(signedTxCbor);
    
    console.log("Transaction submitted:", txHash);
    
    const confirmed = await client.awaitTx(txHash, checkInterval);
    
    return {
      success: true,
      txHash,
      confirmed
    };
  } catch (error: any) {
    console.error("Submission failed:", error);
    
    return {
      success: false,
      error: error.message
    };
  }
}

import { createClient } from "@evolution-sdk/evolution";

const client = createClient({
  network: "mainnet",
  provider: {
    type: "blockfrost",
    baseUrl: "https://cardano-mainnet.blockfrost.io/api/v0",
    projectId: process.env.BLOCKFROST_PROJECT_ID!
  }
});

async function submitBatch(signedTxs: string[]) {
  const results = [];
  
  for (const txCbor of signedTxs) {
    try {
      const txHash = await client.submitTx(txCbor);
      console.log("Submitted:", txHash);
      
      const confirmed = await client.awaitTx(txHash);
      
      results.push({
        success: true,
        txHash,
        confirmed
      });
    } catch (error: any) {
      results.push({
        success: false,
        error: error.message
      });
    }
  }
  
  return results;
}

import { createClient } from "@evolution-sdk/evolution";

const client = createClient({
  network: "mainnet",
  provider: {
    type: "blockfrost",
    baseUrl: "https://cardano-mainnet.blockfrost.io/api/v0",
    projectId: process.env.BLOCKFROST_PROJECT_ID!
  }
});

async function safeSubmit(signedTxCbor: string) {
  try {
    const txHash = await client.submitTx(signedTxCbor);
    return { success: true as const, txHash };
  } catch (error: any) {
    // Common errors
    if (error.message.includes("OutsideValidityIntervalUTxO")) {
      return {
        success: false as const,
        error: "Transaction expired (outside validity interval)"
      };
    }
    
    if (error.message.includes("BadInputsUTxO")) {
      return {
        success: false as const,
        error: "UTxO already spent"
      };
    }
    
    if (error.message.includes("ValueNotConservedUTxO")) {
      return {
        success: false as const,
        error: "Input/output value mismatch"
      };
    }
    
    if (error.message.includes("FeeTooSmallUTxO")) {
      return {
        success: false as const,
        error: "Transaction fee too low"
      };
    }
    
    return {
      success: false as const,
      error: error.message
    };
  }
}

import { createClient } from "@evolution-sdk/evolution";

const client = createClient({
  network: "mainnet",
  provider: {
    type: "blockfrost",
    baseUrl: "https://cardano-mainnet.blockfrost.io/api/v0",
    projectId: process.env.BLOCKFROST_PROJECT_ID!
  }
});

async function submitWithRetry(
  signedTxCbor: string,
  maxRetries = 3,
  delayMs = 1000
) {
  let lastError: any;
  
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const txHash = await client.submitTx(signedTxCbor);
      console.log(`Success on attempt ${attempt}:`, txHash);
      return { success: true as const, txHash };
    } catch (error: any) {
      lastError = error;
      console.log(`Attempt ${attempt} failed:`, error.message);
      
      // Don't retry on certain errors
      if (
        error.message.includes("BadInputsUTxO") ||
        error.message.includes("OutsideValidityIntervalUTxO")
      ) {
        break;
      }
      
      if (attempt < maxRetries) {
        await new Promise(resolve => setTimeout(resolve, delayMs));
      }
    }
  }
  
  return {
    success: false as const,
    error: lastError?.message || "Unknown error"
  };
}

import { createClient } from "@evolution-sdk/evolution";

const client = createClient({
  network: "mainnet",
  provider: {
    type: "blockfrost",
    baseUrl: "https://cardano-mainnet.blockfrost.io/api/v0",
    projectId: process.env.BLOCKFROST_PROJECT_ID!
  }
});

async function monitorTransaction(
  txHash: string,
  timeout = 300000, // 5 minutes
  checkInterval = 5000
): Promise<boolean> {
  const startTime = Date.now();
  
  while (Date.now() - startTime < timeout) {
    try {
      const confirmed = await client.awaitTx(txHash, checkInterval);
      
      if (confirmed) {
        console.log("Transaction confirmed:", txHash);
        return true;
      }
    } catch (error: any) {
      console.error("Monitoring error:", error);
    }
    
    await new Promise(resolve => setTimeout(resolve, checkInterval));
  }
  
  console.log("Transaction confirmation timeout:", txHash);
  return false;
}

import { createClient } from "@evolution-sdk/evolution";

const client = createClient({
  network: "mainnet",
  provider: {
    type: "blockfrost",
    baseUrl: "https://cardano-mainnet.blockfrost.io/api/v0",
    projectId: process.env.BLOCKFROST_PROJECT_ID!
  }
});

interface TransactionStatus {
  status: "submitted" | "confirmed" | "failed";
  txHash?: string;
  error?: string;
  attempts?: number;
  confirmedAt?: Date;
}

export async function submitTransaction(
  signedTxCbor: string
): Promise<TransactionStatus> {
  const maxRetries = 3;
  let attempts = 0;
  
  // Submission with retry
  while (attempts < maxRetries) {
    attempts++;
    
    try {
      const txHash = await client.submitTx(signedTxCbor);
      
      console.log(`Submitted (attempt ${attempts}):`, txHash);
      
      // Wait for confirmation
      const confirmed = await client.awaitTx(txHash, 5000);
      
      if (confirmed) {
        return {
          status: "confirmed",
          txHash,
          attempts,
          confirmedAt: new Date()
        };
      }
      
      return {
        status: "submitted",
        txHash,
        attempts
      };
      
    } catch (error: any) {
      console.error(`Attempt ${attempts} failed:`, error.message);
      
      // Terminal errors - don't retry
      if (
        error.message.includes("BadInputsUTxO") ||
        error.message.includes("OutsideValidityIntervalUTxO") ||
        error.message.includes("ValueNotConservedUTxO")
      ) {
        return {
          status: "failed",
          error: error.message,
          attempts
        };
      }
      
      // Wait before retry
      if (attempts < maxRetries) {
        await new Promise(resolve => setTimeout(resolve, 2000));
      }
    }
  }
  
  return {
    status: "failed",
    error: "Max retries exceeded",
    attempts
  };
}

import { createClient } from "@evolution-sdk/evolution";

const client = createClient({
  network: "mainnet",
  provider: {
    type: "blockfrost",
    baseUrl: "https://cardano-mainnet.blockfrost.io/api/v0",
    projectId: process.env.BLOCKFROST_PROJECT_ID!
  }
});

async function evaluateAndSubmit(signedTxCbor: string) {
  try {
    // Evaluate first
    const redeemers = await client.evaluateTx(signedTxCbor);
    
    console.log("Script evaluation:");
    redeemers.forEach((r, i) => {
      console.log(`  Redeemer ${i}:`, {
        tag: r.redeemer_tag,
        memory: r.ex_units.mem,
        steps: r.ex_units.steps
      });
    });
    
    // Submit if evaluation succeeds
    const txHash = await client.submitTx(signedTxCbor);
    const confirmed = await client.awaitTx(txHash);
    
    return {
      success: true,
      txHash,
      confirmed,
      redeemers
    };
    
  } catch (error: any) {
    return {
      success: false,
      error: error.message
    };
  }
}