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 params = await client.getProtocolParameters();

// Fee calculation parameters
console.log("Min fee A:", params.minFeeA);
console.log("Min fee B:", params.minFeeB);

// Transaction limits
console.log("Max tx size:", params.maxTxSize);

// Deposits
console.log("Key deposit:", params.keyDeposit);
console.log("Pool deposit:", params.poolDeposit);

// Script execution costs
console.log("Price memory:", params.priceMem);
console.log("Price steps:", params.priceStep);

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

// Get all UTxOs at address
const utxos = await client.getUtxos(
  Core.Address.fromBech32("addr1qxy8sclc58rsck0pzsc0v4skmqjwuqsqpwfcvrdldl5sjvvhyltp7fk0fmtmrlnykgmhnzcns2msa2cmpvllzgqd2azqhpv8e4")
);

// Calculate total ADA
const totalLovelace = utxos.reduce(
  (sum, utxo) => sum + (utxo.assets.lovelace ?? 0n),
  0n
);
console.log("Total ADA:", Number(totalLovelace) / 1_000_000);

// List native assets
utxos.forEach((utxo) => {
  Object.entries(utxo.assets).forEach(([unit, amount]) => {
    if (unit !== "lovelace") {
      console.log(`Asset: ${unit}, Amount: ${amount}`);
    }
  });
});

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

// Find UTxOs with specific token at address
const policyId = "abc123def456abc123def456abc123def456abc123def456abc123de7890";
const assetName = "MyToken";
const unit = policyId + assetName;

const utxosWithToken = await client.getUtxosWithUnit(
  Core.Address.fromBech32("addr1qxy8sclc58rsck0pzsc0v4skmqjwuqsqpwfcvrdldl5sjvvhyltp7fk0fmtmrlnykgmhnzcns2msa2cmpvllzgqd2azqhpv8e4"),
  unit
);

console.log("UTxOs with token:", utxosWithToken.length);

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

// Query specific UTxOs
const utxos = await client.getUtxosByOutRef([
  { txHash: "abc123...", outputIndex: 0 },
  { txHash: "def456...", outputIndex: 1 }
]);

console.log("Found UTxOs:", utxos.length);

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 NFT (unique token with quantity 1)
const nftUnit = "policyId" + "tokenName";
const utxo = await client.getUtxoByUnit(nftUnit);

console.log("NFT found at:", Core.Address.toBech32(utxo.address));
console.log("Current owner UTxO:", Core.TransactionHash.toHex(utxo.transactionId));

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 delegation = await client.getDelegation("stake1uxy...");

console.log("Delegated to pool:", delegation.poolId);
console.log("Is delegated:", delegation.poolId !== undefined);
console.log("Rewards:", delegation.rewards);

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

// Get datum from hash
const datumHash = "abc123...";
const datumCbor = await client.getDatum(datumHash);

console.log("Datum CBOR:", datumCbor);

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

async function getPortfolioBalance(addressesBech32: string[]) {
  const balances = await Promise.all(
    addressesBech32.map(async (addressBech32) => {
      const address = Core.Address.fromBech32(addressBech32);
      const utxos = await client.getUtxos(address);
      const lovelace = utxos.reduce(
        (sum, utxo) => sum + utxo.assets.lovelace,
        0n
      );
      
      return {
        address: addressBech32,
        lovelace,
        ada: Number(lovelace) / 1_000_000
      };
    })
  );
  
  const totalLovelace = balances.reduce(
    (sum, b) => sum + b.lovelace,
    0n
  );
  
  return {
    addresses: balances,
    total: {
      lovelace: totalLovelace,
      ada: Number(totalLovelace) / 1_000_000
    }
  };
}

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

async function getTokenHolders(
  addresses: string[],
  tokenUnit: string
) {
  const holders = [];
  
  for (const addressBech32 of addresses) {
    const address = Core.Address.fromBech32(addressBech32);
    const utxos = await client.getUtxosWithUnit(address, tokenUnit);
    
    if (utxos.length > 0) {
      // Count UTxOs containing this token
      holders.push({
        address: addressBech32,
        amount: BigInt(utxos.length),
        utxoCount: utxos.length
      });
    }
  }
  
  return holders;
}

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 checkPoolDelegation(
  rewardAddresses: string[],
  targetPoolId: string
) {
  const results = await Promise.all(
    rewardAddresses.map(async (rewardAddress) => {
      const delegation = await client.getDelegation(rewardAddress);
      
      return {
        rewardAddress,
        delegatedToTarget: delegation.poolId === targetPoolId,
        currentPool: delegation.poolId,
        isDelegated: delegation.poolId !== undefined,
        rewards: delegation.rewards
      };
    })
  );
  
  return results;
}

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

async function getNFTOwnership(nftUnits: string[]) {
  const ownership = await Promise.all(
    nftUnits.map(async (unit) => {
      try {
        const utxo = await client.getUtxoByUnit(unit);
        return {
          unit,
          owner: Core.Address.toBech32(utxo.address),
          txHash: Core.TransactionHash.toHex(utxo.transactionId),
          outputIndex: utxo.index
        };
      } catch (error: any) {
        return {
          unit,
          owner: null,
          error: "Not found or burned"
        };
      }
    })
  );
  
  return ownership;
}

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

async function safeGetUtxos(addressBech32: string) {
  try {
    const address = Core.Address.fromBech32(addressBech32);
    const utxos = await client.getUtxos(address);
    return { success: true as const, utxos };
  } catch (error: any) {
    console.error("Failed to query UTxOs:", error);
    return { success: false as const, error: error.message };
  }
}

async function safeGetDelegation(rewardAddress: string) {
  try {
    const delegation = await client.getDelegation(rewardAddress);
    return { success: true as const, delegation };
  } catch (error: any) {
    // May fail if address not registered
    return { success: false as const, error: error.message };
  }
}

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

// Batch queries in parallel
async function batchQuery(addressesBech32: string[]) {
  // Good: parallel queries
  const results = await Promise.all(
    addressesBech32.map(addr => 
      client.getUtxos(Core.Address.fromBech32(addr))
    )
  );
  
  return results;
}

// Cache protocol parameters
type ProtocolParams = Awaited<ReturnType<typeof client.getProtocolParameters>>;
let cachedParams: ProtocolParams | null = null;
let cacheTime = 0;
const CACHE_DURATION = 300000; // 5 minutes

async function getCachedProtocolParameters() {
  const now = Date.now();
  
  if (!cachedParams || now - cacheTime > CACHE_DURATION) {
    cachedParams = await client.getProtocolParameters();
    cacheTime = now;
  }
  
  return cachedParams;
}