import { Core, 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!
  }
});

// Query any address
const utxos = await client.getUtxos(
  Core.Address.fromBech32("addr1qxy8sclc58rsck0pzsc0v4skmqjwuqsqpwfcvrdldl5sjvvhyltp7fk0fmtmrlnykgmhnzcns2msa2cmpvllzgqd2azqhpv8e4")
);
console.log("Found UTxOs:", utxos.length);

// Get protocol parameters
const params = await client.getProtocolParameters();
console.log("Min fee A:", params.minFeeA);

import { Core, 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!
  }
});

// Protocol parameters
const params = await client.getProtocolParameters();

// UTxO queries - use Core.Address.fromBech32 for addresses
const address = Core.Address.fromBech32("addr1qxy8sclc58rsck0pzsc0v4skmqjwuqsqpwfcvrdldl5sjvvhyltp7fk0fmtmrlnykgmhnzcns2msa2cmpvllzgqd2azqhpv8e4");
const utxos = await client.getUtxos(address);
const utxosWithAda = await client.getUtxosWithUnit(address, "lovelace");
const utxosByRefs = await client.getUtxosByOutRef([
  { txHash: "abc123def456...", outputIndex: 0 }
]);

// Delegation
const delegation = await client.getDelegation("stake1...");

// Datum resolution
const datum = await client.getDatum("datum-hash-here");

// Transaction operations
const signedTxCbor = "84a300...";
const txHash = await client.submitTx(signedTxCbor);
const confirmed = await client.awaitTx(txHash);

const unsignedTxCbor = "84a300...";
const evaluated = await client.evaluateTx(unsignedTxCbor);

import { Core, 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!
  }
});

// Portfolio tracker
async function getPortfolioBalance(addressesBech32: string[]) {
  const results = await Promise.all(
    addressesBech32.map(async (addressBech32) => {
      const utxos = await client.getUtxos(
        Core.Address.fromBech32(addressBech32)
      );
      const lovelace = utxos.reduce(
        (sum, utxo) => sum + utxo.assets.lovelace,
        0n
      );
      return { address: addressBech32, lovelace };
    })
  );
  
  return results;
}

// Usage with actual addresses
const portfolio = await getPortfolioBalance([
  "addr1qxy8sclc58rsck0pzsc0v4skmqjwuqsqpwfcvrdldl5sjvvhyltp7fk0fmtmrlnykgmhnzcns2msa2cmpvllzgqd2azqhpv8e4"
]);

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!
  }
});

// API endpoint
export async function submitTransaction(signedTxCbor: string) {
  try {
    const txHash = await client.submitTx(signedTxCbor);
    
    // Wait for confirmation
    const confirmed = await client.awaitTx(txHash, 5000);
    
    return {
      success: true,
      txHash,
      confirmed
    };
  } catch (error: any) {
    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 monitorProtocolParameters() {
  const params = await client.getProtocolParameters();
  
  return {
    minFeeA: params.minFeeA,
    minFeeB: params.minFeeB,
    maxTxSize: params.maxTxSize,
    maxValSize: params.maxValSize,
    keyDeposit: params.keyDeposit,
    poolDeposit: params.poolDeposit,
    priceMem: params.priceMem,
    priceStep: params.priceStep
  };
}

// Check parameters periodically
setInterval(async () => {
  const params = await monitorProtocolParameters();
  console.log("Current parameters:", params);
}, 3600000); // Every hour

import { Core, 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!
  }
});

// Cannot build transactions - no wallet address
// @ts-expect-error - Property 'newTx' does not exist on provider-only client
client.newTx();

// Cannot sign - no private key
// @ts-expect-error - Property 'signTx' does not exist on provider-only client
client.signTx();

// Cannot get own address - no wallet
// @ts-expect-error - Property 'address' does not exist on provider-only client
client.address();

// CAN query any address
const address = Core.Address.fromBech32("addr1qxy8sclc58rsck0pzsc0v4skmqjwuqsqpwfcvrdldl5sjvvhyltp7fk0fmtmrlnykgmhnzcns2msa2cmpvllzgqd2azqhpv8e4");
const utxos = await client.getUtxos(address);

// CAN submit pre-signed transactions
const signedCbor = "84a400..."; // Example signed transaction CBOR
const txHash = await client.submitTx(signedCbor);

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

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

// Later, attach wallet for specific user
const readOnlyClient = providerClient.attachWallet({
  type: "read-only",
  address: "addr1qxy8g0m3dnvxpk6dlh40u9vgc8m6hyqyjf6qn6j6t47wnhvcpqp0aw50nln8nyzfh6fjp6sxgajx5q0c6p73xqf2qhvq5pzqsh"
});

// Now can build transactions for this address
const builder = readOnlyClient.newTx();
builder.payToAddress({
  address: Core.Address.fromBech32("addr1qxh7f8gxv43dxz7k2vf6x5cxj5f5mk5mmqfk5u7qp7t2nvw9pqp0aw50nln8nyzfh6fjp6sxgajx5q0c6p73xqf2qhvqwlx8f7"),
  assets: Core.Assets.fromLovelace(5000000n)
});

const result = await builder.build();

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

const env = (process.env.NODE_ENV || "development") as "development" | "production";

const config = {
  development: {
    network: "preprod" as const,
    provider: {
      type: "blockfrost" as const,
      baseUrl: "https://cardano-preprod.blockfrost.io/api/v0",
      projectId: process.env.BLOCKFROST_PREPROD_PROJECT_ID!
    }
  },
  production: {
    network: "mainnet" as const,
    provider: {
      type: "kupmios" as const,
      ogmiosUrl: process.env.OGMIOS_URL!,
      kupoUrl: process.env.KUPO_URL!
    }
  }
};

const client = createClient(config[env]);