@fil-b/foc-storage-mcp 0.1.1 → 0.1.3

package/dist/mcp-server.js

@@ -15,50 +15,51 @@ import { Agent } from "@mastra/core/agent";
 // src/mastra/tools/dataset-tools.ts
 import { createTool } from "@mastra/core";
 
-// src/types/core.ts
-import {
-  TIME_CONSTANTS,
-  SIZE_CONSTANTS,
-  TOKENS
-} from "@filoz/synapse-sdk";
-
 // src/types/schemas.ts
 import { z as z2 } from "zod";
 
 // src/config/index.ts
+import { calibration, mainnet } from "@filoz/synapse-core/chains";
 import { config } from "dotenv";
 import { z } from "zod";
 config();
 var EnvSchema = z.object({
   PRIVATE_KEY: z.string().min(1, "PRIVATE_KEY is required"),
   FILECOIN_NETWORK: z.enum(["mainnet", "calibration"]).default("calibration"),
-  TOTAL_STORAGE_NEEDED_GiB: z.coerce.number().default(1024),
-  PERSISTENCE_PERIOD_DAYS: z.coerce.number().default(365),
-  RUNOUT_NOTIFICATION_THRESHOLD_DAYS: z.coerce.number().default(10)
+  TOTAL_STORAGE_NEEDED_GiB: z.coerce.number().default(150),
+  PERSISTENCE_PERIOD_DAYS: z.coerce.number().default(365).refine((value) => value >= 30, { message: "PERSISTENCE_PERIOD_DAYS must be greater than or equal to 30" }),
+  RUNOUT_NOTIFICATION_THRESHOLD_DAYS: z.coerce.number().default(45).refine((value) => value >= 30, { message: "RUNOUT_NOTIFICATION_THRESHOLD_DAYS must be greater than or equal to 30" })
 });
-var env = EnvSchema.parse(process.env);
+var env = {
+  ...EnvSchema.parse(process.env),
+  ...{
+    CDN_DATASET_FEE: 10n ** 18n
+  }
+};
 var NETWORK_CONFIGS = {
   mainnet: {
     chainId: 314,
     name: "Filecoin Mainnet",
-    rpcUrl: "https://api.node.glif.io/rpc/v1"
+    rpcUrl: mainnet.rpcUrls.default.http
   },
   calibration: {
     chainId: 314159,
     name: "Filecoin Calibration",
-    rpcUrl: "https://api.calibration.node.glif.io/rpc/v1"
+    rpcUrl: calibration.rpcUrls.default.http
   }
 };
+var CONTRACTS = env.FILECOIN_NETWORK === "calibration" ? calibration.contracts : mainnet.contracts;
 var MAX_UINT256 = 2n ** 256n - 1n;
 var DATA_SET_CREATION_FEE = BigInt(0.1 * 10 ** 18);
 var BYTES_PER_TIB = 1024n * 1024n * 1024n * 1024n;
 var BYTES_PER_GIB = 1024n * 1024n * 1024n;
+var CDN_EGRESS_RATE_PER_TIB = 7;
 var DEFAULT_EXPECTED_STORAGE_BYTES = 1024 * 1024 * 1024 * 1024;
 
 // src/types/schemas.ts
-import { SIZE_CONSTANTS as SIZE_CONSTANTS2 } from "@filoz/synapse-sdk";
+import { SIZE_CONSTANTS } from "@filoz/synapse-core/utils";
 var GetDatasetsSchema = z2.object({
-  includeAllDatasets: z2.boolean().optional().describe("Include all datasets. Default: false"),
+  includeAllDatasets: z2.boolean().optional().default(true).describe("Include all datasets. Default: true"),
   filterByCDN: z2.boolean().optional().describe("Filter to only CDN-enabled datasets. Default: false. If includeAllDatasets is true, this will be ignored")
 });
 var GetDatasetSchema = z2.object({
@@ -83,13 +84,16 @@ var UploadFileSchema = z2.object({
   autoPayment: z2.boolean().optional().default(true).describe("Automatically process payment if insufficient balance. Default: true")
 });
 var GetBalancesSchema = z2.object({
-  storageCapacityBytes: z2.number().optional().default(env.TOTAL_STORAGE_NEEDED_GiB * Number(SIZE_CONSTANTS2.GiB)).describe("Storage capacity in bytes. Default: 1 TB. This is used to calculate the storage needs and the deposit needed."),
+  storageCapacityBytes: z2.number().optional().default(env.TOTAL_STORAGE_NEEDED_GiB * Number(SIZE_CONSTANTS.GiB)).describe("Storage capacity in bytes. Default: 1 TB. This is used to calculate the storage needs and the deposit needed."),
   persistencePeriodDays: z2.number().optional().default(env.PERSISTENCE_PERIOD_DAYS).describe("Persistence period in days. Default: 365. This is used to calculate the storage needs and the deposit needed."),
   notificationThresholdDays: z2.number().optional().default(env.RUNOUT_NOTIFICATION_THRESHOLD_DAYS).describe("Notification threshold in days. Default: 10. This is used check if the user needs to top up their storage balance before the storage balance runs out.")
 });
 var ProcessPaymentSchema = z2.object({
   depositAmount: z2.number().optional().default(0).describe("Amount to deposit in USDFC. Default: 0. If not provided, the tool will check the balance and deposit the necessary amount.")
 });
+var ProcessWithdrawalSchema = z2.object({
+  withdrawalAmount: z2.number().optional().default(0).describe("Amount to withdraw in USDFC. Default: 0. If not provided, the tool will check the balance and withdraw the necessary amount.")
+});
 var GetProvidersSchema = z2.object({
   onlyApproved: z2.boolean().optional().default(true).describe("Filter to only approved providers. Default: true")
 });
@@ -121,7 +125,24 @@ var DataSetSchema = z2.object({
   totalDatasetSizeMessage: z2.string(),
   dataSetPieces: z2.array(DataSetPieceSchema)
 });
-var FormattedStorageBalanceResultSchema = z2.object({
+var StorageBalanceResultSchema = z2.object({
+  filBalance: z2.bigint(),
+  usdfcBalance: z2.bigint(),
+  availableStorageFundsUsdfc: z2.bigint(),
+  depositNeeded: z2.bigint(),
+  availableToFreeUp: z2.bigint(),
+  daysLeftAtMaxBurnRate: z2.number(),
+  daysLeftAtBurnRate: z2.number(),
+  isRateSufficient: z2.boolean(),
+  isLockupSufficient: z2.boolean(),
+  isSufficient: z2.boolean(),
+  currentStorageMonthlyRate: z2.bigint(),
+  maxStorageMonthlyRate: z2.bigint()
+});
+var StorageBalanceResultSerializedSchema = z2.object({
+  filBalance: z2.string(),
+  usdfcBalance: z2.string(),
+  availableStorageFundsUsdfc: z2.string(),
   depositNeeded: z2.string(),
   availableToFreeUp: z2.string(),
   daysLeftAtMaxBurnRate: z2.number(),
@@ -129,14 +150,27 @@ var FormattedStorageBalanceResultSchema = z2.object({
   isRateSufficient: z2.boolean(),
   isLockupSufficient: z2.boolean(),
   isSufficient: z2.boolean(),
-  availableFunds: z2.string(),
-  currentMonthlyRate: z2.string(),
-  maxMonthlyRate: z2.string()
+  currentStorageMonthlyRate: z2.string(),
+  maxStorageMonthlyRate: z2.string()
+});
+var FormattedStorageBalanceResultSchema = z2.object({
+  filBalance: z2.string(),
+  usdfcBalance: z2.string(),
+  availableStorageFundsUsdfc: z2.string(),
+  currentStorageMonthlyRate: z2.string(),
+  maxStorageMonthlyRate: z2.string(),
+  daysLeftAtMaxBurnRate: z2.string(),
+  daysLeftAtBurnRate: z2.string(),
+  depositNeeded: z2.string(),
+  availableToFreeUp: z2.string(),
+  isRateSufficient: z2.boolean(),
+  isLockupSufficient: z2.boolean(),
+  isSufficient: z2.boolean()
 });
 var GetProvidersOutputSchema = z2.object({
   success: z2.boolean(),
   // Success fields
-  providers: z2.array(z2.any()).optional(),
+  providers: z2.array(z2.custom()),
   count: z2.number().optional(),
   // Error fields  
   error: z2.string().optional(),
@@ -166,14 +200,24 @@ var ProcessPaymentOutputSchema = z2.object({
     deposit: z2.number()
   }).optional(),
   available: z2.number().optional(),
+  progressLog: z2.array(z2.string()).optional(),
+  // Error fields
+  error: z2.string().optional()
+});
+var ProcessWithdrawalOutputSchema = z2.object({
+  success: z2.boolean(),
+  message: z2.string(),
+  txHash: z2.string().nullable().optional(),
+  progressLog: z2.array(z2.string()).optional(),
   // Error fields
   error: z2.string().optional()
 });
 var GetBalancesOutputSchema = z2.object({
   success: z2.boolean(),
   // Success fields
-  checkStorageBalanceResultFormatted: z2.any().optional(),
-  checkStorageBalanceResult: z2.any().optional(),
+  checkStorageBalanceResultFormatted: FormattedStorageBalanceResultSchema.optional(),
+  checkStorageBalanceResult: StorageBalanceResultSerializedSchema.optional(),
+  progressLog: z2.array(z2.string()).optional(),
   // Error fields
   error: z2.string().optional(),
   message: z2.string().optional()
@@ -181,8 +225,9 @@ var GetBalancesOutputSchema = z2.object({
 var GetDatasetsOutputSchema = z2.object({
   success: z2.boolean(),
   // Success fields
-  datasets: z2.array(DataSetSchema).optional(),
+  datasets: z2.array(z2.custom()).optional(),
   count: z2.number().optional(),
+  progressLog: z2.array(z2.string()).optional(),
   // Error fields
   error: z2.string().optional(),
   // Common field
@@ -191,7 +236,7 @@ var GetDatasetsOutputSchema = z2.object({
 var GetDatasetOutputSchema = z2.object({
   success: z2.boolean(),
   // Success fields
-  dataset: DataSetSchema,
+  dataset: z2.custom().optional(),
   // Error fields
   error: z2.string().optional(),
   // Common field
@@ -200,18 +245,19 @@ var GetDatasetOutputSchema = z2.object({
 var CreateDatasetOutputSchema = z2.object({
   success: z2.boolean(),
   // Success fields
-  datasetId: z2.string().optional(),
-  txHash: z2.string().optional(),
+  datasetId: z2.string().nullable().optional(),
+  txHash: z2.string().nullable().optional(),
+  progressLog: z2.array(z2.string()).optional(),
   // Error fields
-  error: z2.string().optional(),
+  error: z2.string().nullable().optional(),
   // Common field
   message: z2.string()
 });
 
 // src/lib/calculations.ts
 import Decimal from "decimal.js";
-import { SIZE_CONSTANTS as SIZE_CONSTANTS3 } from "@filoz/synapse-sdk";
-import { getSizeFromPieceCID } from "@filoz/synapse-sdk/piece";
+import { getSize } from "@filoz/synapse-core/piece";
+import { SIZE_CONSTANTS as SIZE_CONSTANTS2 } from "@filoz/synapse-core/utils";
 Decimal.set({
   precision: 34,
   rounding: Decimal.ROUND_HALF_UP,
@@ -221,31 +267,6 @@ Decimal.set({
   minE: -9e15,
   modulo: Decimal.ROUND_DOWN
 });
-var toDecimal = (value) => value instanceof Decimal ? value : new Decimal(value.toString());
-var bytesToKiB = (bytes) => toDecimal(bytes).div(new Decimal(SIZE_CONSTANTS3.KiB.toString()));
-var bytesToMiB = (bytes) => toDecimal(bytes).div(new Decimal(SIZE_CONSTANTS3.MiB.toString()));
-var bytesToGiB = (bytes) => toDecimal(bytes).div(new Decimal(SIZE_CONSTANTS3.GiB.toString()));
-var getPieceInfoFromCidBytes = (input) => {
-  const sizeBytes = BigInt(getSizeFromPieceCID(input));
-  return {
-    sizeBytes,
-    sizeKiB: bytesToKiB(sizeBytes).toNumber(),
-    sizeMiB: bytesToMiB(sizeBytes).toNumber(),
-    sizeGiB: bytesToGiB(sizeBytes).toNumber()
-  };
-};
-var sizeInfoMessage = (sizeInfo) => {
-  if (sizeInfo.sizeInGB > 0.1) {
-    return `Dataset size: ${sizeInfo.sizeInGB.toFixed(4)} GB`;
-  }
-  if (sizeInfo.sizeInMiB > 0.1) {
-    return `Dataset size: ${sizeInfo.sizeInMiB.toFixed(4)} MB`;
-  }
-  if (sizeInfo.sizeInKiB > 0.1) {
-    return `Dataset size: ${sizeInfo.sizeInKiB.toFixed(4)} KB`;
-  }
-  return `Dataset size: ${sizeInfo.sizeInBytes} Bytes`;
-};
 
 // src/lib/synapse.ts
 import { Synapse } from "@filoz/synapse-sdk";
@@ -254,7 +275,7 @@ var getSynapseInstance = async () => {
   const synapse = await Synapse.create(
     {
       privateKey: env.PRIVATE_KEY,
-      rpcURL: NETWORK_CONFIGS[network].rpcUrl
+      rpcURL: NETWORK_CONFIGS[network].rpcUrl[0]
     }
   );
   return synapse;
@@ -284,6 +305,11 @@ function createErrorResponse(errorType, message, additionalData) {
     ...additionalData
   };
 }
+function toBaseUnits(amount, decimals = 18) {
+  const [whole, decimal = ""] = amount.split(".");
+  const paddedDecimal = decimal.padEnd(decimals, "0").slice(0, decimals);
+  return BigInt(whole + paddedDecimal);
+}
 function fromBaseUnits(amount, decimals = 18) {
   const str = amount.toString().padStart(decimals + 1, "0");
   const whole = str.slice(0, -decimals) || "0";
@@ -307,180 +333,223 @@ function serializeBigInt(obj) {
   }
   return obj;
 }
+function getExplorerUrl(txHash) {
+  const isMainnet = env.FILECOIN_NETWORK === "mainnet";
+  const baseUrl = isMainnet ? "https://filecoin.blockscout.com/tx" : "https://filecoin-testnet.blockscout.com/tx";
+  return `${baseUrl}/${txHash}`;
+}
 
-// src/services/wallet-service.ts
-import { ethers, Wallet, JsonRpcProvider } from "ethers";
-
-// src/services/payment-service.ts
-import { TIME_CONSTANTS as TIME_CONSTANTS2 } from "@filoz/synapse-sdk";
-async function processStoragePayment(synapse, depositAmount, persistenceDays) {
-  const warmStorageAddress = synapse.getWarmStorageAddress();
-  const epochs = TIME_CONSTANTS2.EPOCHS_PER_DAY * BigInt(persistenceDays);
-  if (depositAmount > 0n) {
-    const tx = await synapse.payments.depositWithPermitAndApproveOperator(
-      depositAmount,
-      warmStorageAddress,
-      MAX_UINT256,
-      MAX_UINT256,
-      epochs
-    );
-    const receipt = await tx.wait(1);
-    return { txHash: receipt?.hash || tx.hash, success: true };
-  } else {
-    const tx = await synapse.payments.approveService(
-      warmStorageAddress,
-      MAX_UINT256,
-      MAX_UINT256,
-      epochs
-    );
-    const receipt = await tx.wait(1);
-    return { txHash: receipt?.hash || tx.hash, success: true };
+// src/lib/errors.ts
+function getTopUpMessage(isTestnet) {
+  if (isTestnet) {
+    return `
+To resolve insufficient balance errors:
+" For tFIL: Visit https://faucet.calibration.fildev.network/
+" For tUSDFC: Visit https://forest-explorer.chainsafe.dev/faucet/calibnet_usdfc
+`;
+  }
+  return `
+To resolve insufficient balance errors:
+" Top up your FIL or USDFC balance
+" Ensure you have sufficient funds for the operation
+`;
+}
+function synapseErrorHandler(error) {
+  const errorParts = ["Payment processing failed"];
+  if (error?.cause) {
+    const cause = typeof error.cause === "string" ? error.cause : JSON.stringify(error.cause);
+    errorParts.push(`Cause: ${cause}`);
+  }
+  if (error?.shortMessage) {
+    errorParts.push(`Message: ${error.shortMessage}`);
   }
+  if (error?.details) {
+    errorParts.push(`Details: ${error.details}`);
+  }
+  const isTestnet = env.FILECOIN_NETWORK === "calibration";
+  errorParts.push(getTopUpMessage(isTestnet));
+  return errorParts.join("\n");
 }
 
 // src/services/dataset-service.ts
-import { PDPServer, WarmStorageService } from "@filoz/synapse-sdk";
-var getDatasets = async (withCDN = false, includeAll = false, onlyDatasetId = void 0) => {
-  try {
-    const synapse = await getSynapseInstance();
-    const warmStorageAddress = synapse.getWarmStorageAddress();
-    const warmStorageService = await WarmStorageService.create(synapse.getProvider(), warmStorageAddress);
-    const datasets = await synapse.storage.findDataSets();
-    if (datasets.length === 0) {
+import { metadataArrayToObject } from "@filoz/synapse-core/utils";
+
+// src/services/viem.ts
+import { createPublicClient, createWalletClient, http } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { calibration as calibration2, mainnet as mainnet2 } from "@filoz/synapse-core/chains";
+var account = privateKeyToAccount(env.PRIVATE_KEY);
+var chain = env.FILECOIN_NETWORK === "calibration" ? calibration2 : mainnet2;
+var client = createWalletClient({
+  account,
+  chain,
+  transport: http()
+});
+var publicClient = createPublicClient({
+  chain,
+  transport: http()
+});
+
+// src/services/dataset-service.ts
+import { createDataSet, getDataSet, getDataSets, getPieces } from "@filoz/synapse-core/warm-storage";
+import * as SP from "@filoz/synapse-core/sp";
+import { readContract } from "viem/actions";
+var getPiecesWithMetadata = async (dataSetId, pieces) => {
+  return await Promise.all(
+    pieces.map(async (piece) => {
+      const metadata = await readContract(client, {
+        address: CONTRACTS.storageView.address,
+        abi: CONTRACTS.storageView.abi,
+        functionName: "getAllPieceMetadata",
+        args: [dataSetId, BigInt(piece.id)]
+      });
       return {
-        success: true,
-        datasets: [],
-        count: 0,
-        message: "No datasets found. Upload files to create your first dataset."
+        ...piece,
+        metadata: metadataArrayToObject(metadata)
       };
-    }
-    const providers = await Promise.all(
-      datasets.map(
-        (dataset) => synapse.getProviderInfo(dataset.providerId).catch(() => null)
-      )
-    );
-    const userAddress = await synapse.getSigner().getAddress();
-    const filteredDatasets = datasets.filter((dataset) => {
-      if (onlyDatasetId !== void 0) {
-        return dataset.pdpVerifierDataSetId === onlyDatasetId;
-      }
-      if (includeAll) {
-        return true;
-      }
-      return dataset.withCDN === withCDN;
+    })
+  );
+};
+var getDatasetsService = async (withCDN = false, includeAll = false) => {
+  const dataSets = (await getDataSets(publicClient, {
+    address: account.address
+  })).filter((dataset) => includeAll || withCDN && dataset.cdn);
+  const datasetsWithPieces = await Promise.all(dataSets.map(async (dataset) => {
+    const pieces = await getPieces(publicClient, {
+      address: account.address,
+      dataSet: dataset
     });
-    if (filteredDatasets.length === 0) {
-      return {
-        success: true,
-        datasets: [],
-        count: 0,
-        message: `No datasets found with the given criteria`
-      };
-    }
-    const enrichedDatasets = await Promise.all(
-      filteredDatasets.map(async (dataset) => {
-        const provider = providers.find((p) => p?.id === dataset.providerId);
-        const serviceURL = provider.products.PDP?.data.serviceURL || "";
-        try {
-          const pdpServer = new PDPServer(null, serviceURL);
-          const data = await pdpServer.getDataSet(dataset.pdpVerifierDataSetId).then((data2) => {
-            data2.pieces.reverse();
-            return data2;
-          });
-          const pieces = data.pieces.reduce(
-            (acc, piece) => {
-              acc[piece.pieceCid.toV1().toString()] = getPieceInfoFromCidBytes(piece.pieceCid);
-              return acc;
-            },
-            {}
-          );
-          const piecesMetadata = (await Promise.all(data.pieces.map(async (piece) => {
-            return { pieceId: piece.pieceId, metadata: await warmStorageService.getPieceMetadata(dataset.pdpVerifierDataSetId, piece.pieceId) };
-          }))).reduce((acc, piece) => {
-            acc[piece.pieceId] = piece.metadata;
-            return acc;
-          }, {});
-          const getRetrievalUrl = (pieceCid) => {
-            if (dataset.withCDN) {
-              return `https://${userAddress}.calibration.filbeam.io/${pieceCid}`;
-            } else {
-              return `${serviceURL}/piece/${pieceCid}`;
-            }
-          };
-          const datasetSizeInfo = data.pieces.reduce((acc, piece) => {
-            acc.sizeInBytes += Number(pieces[piece.pieceCid.toV1().toString()].sizeBytes);
-            acc.sizeInKiB += Number(pieces[piece.pieceCid.toV1().toString()].sizeKiB);
-            acc.sizeInMiB += Number(pieces[piece.pieceCid.toV1().toString()].sizeMiB);
-            acc.sizeInGB += Number(pieces[piece.pieceCid.toV1().toString()].sizeGiB);
-            return acc;
-          }, { sizeInBytes: 0, sizeInKiB: 0, sizeInMiB: 0, sizeInGB: 0, message: "" });
-          const dataSetPieces = data.pieces.map((piece) => ({
-            pieceCid: piece.pieceCid.toV1().toString(),
-            retrievalUrl: getRetrievalUrl(piece.pieceCid.toV1().toString()),
-            sizes: pieces[piece.pieceCid.toV1().toString()],
-            metadata: piecesMetadata[piece.pieceId]
-          }));
-          return {
-            datasetId: dataset.pdpVerifierDataSetId,
-            withCDN: dataset.withCDN,
-            datasetMetadata: dataset.metadata,
-            totalDatasetSizeMessage: sizeInfoMessage(datasetSizeInfo),
-            dataSetPieces
-          };
-        } catch (error) {
-          return null;
-        }
-      })
-    );
+    return {
+      ...dataset,
+      pieces: await getPiecesWithMetadata(dataset.dataSetId, pieces.pieces)
+    };
+  }));
+  return datasetsWithPieces;
+};
+var getDataSetService = async (datasetId) => {
+  const dataset = await getDataSet(publicClient, {
+    dataSetId: BigInt(datasetId)
+  });
+  const pieces = await getPieces(publicClient, {
+    address: account.address,
+    dataSet: dataset
+  });
+  return {
+    ...dataset,
+    pieces: await getPiecesWithMetadata(dataset.dataSetId, pieces.pieces)
+  };
+};
+var createDataSetService = async (provider, cdn, metadata) => {
+  try {
+    const dataset = await createDataSet(client, {
+      cdn,
+      payee: provider.payee,
+      endpoint: provider.pdp.serviceURL,
+      metadata
+    });
+    const { dataSetId } = await SP.pollForDataSetCreationStatus({ statusUrl: dataset.statusUrl });
     return {
       success: true,
-      datasets: enrichedDatasets.filter((dataset) => dataset !== null).map(serializeBigInt),
-      count: enrichedDatasets.length,
-      message: `Found ${enrichedDatasets.length} dataset(s)`
+      dataSetId: dataSetId.toString(),
+      txHash: dataset.txHash,
+      message: "Dataset created successfully"
     };
   } catch (error) {
-    return createErrorResponse(
-      "dataset_fetch_failed",
-      `Failed to fetch datasets: ${error.message}`,
-      { success: false }
-    );
+    return {
+      success: false,
+      txHash: null,
+      dataSetId: null,
+      message: "Failed to create dataset: " + synapseErrorHandler(error)
+    };
   }
 };
 
+// src/services/payment-service.ts
+import * as Payments from "@filoz/synapse-core/pay";
+import { waitForTransactionReceipt } from "viem/actions";
+async function processPaymentService(depositAmount) {
+  try {
+    const hash = await Payments.depositAndApprove(client, {
+      amount: BigInt(depositAmount)
+    });
+    const receipt = await waitForTransactionReceipt(client, {
+      hash
+    });
+    return { txHash: hash, success: receipt.status === "success" };
+  } catch (error) {
+    return {
+      txHash: null,
+      success: false,
+      error: synapseErrorHandler(error)
+    };
+  }
+}
+async function processWithdrawalService(withdrawalAmount) {
+  try {
+    const hash = await Payments.withdraw(client, {
+      amount: BigInt(withdrawalAmount)
+    });
+    const receipt = await waitForTransactionReceipt(client, {
+      hash
+    });
+    return { txHash: hash, success: receipt.status === "success" };
+  } catch (error) {
+    return {
+      txHash: null,
+      success: false,
+      error: synapseErrorHandler(error)
+    };
+  }
+}
+
 // src/services/storage-service.ts
 import {
-  SIZE_CONSTANTS as SIZE_CONSTANTS4,
-  TIME_CONSTANTS as TIME_CONSTANTS3,
-  TOKENS as TOKENS2,
-  WarmStorageService as WarmStorageService2
-} from "@filoz/synapse-sdk";
+  SIZE_CONSTANTS as SIZE_CONSTANTS3,
+  TIME_CONSTANTS
+} from "@filoz/synapse-core/utils";
 import { formatUnits } from "viem";
-var checkStorageBalance = async (synapse, storageCapacityBytes = env.TOTAL_STORAGE_NEEDED_GiB * Number(SIZE_CONSTANTS4.GiB), persistencePeriodDays = env.PERSISTENCE_PERIOD_DAYS) => {
-  const warmStorageService = await WarmStorageService2.create(synapse.getProvider(), synapse.getWarmStorageAddress());
-  const [storageInfo, accountInfo, prices] = await Promise.all([
-    synapse.storage.getStorageInfo(),
-    synapse.payments.accountInfo(TOKENS2.USDFC),
-    warmStorageService.calculateStorageCost(storageCapacityBytes)
+import * as ERC20 from "@filoz/synapse-core/erc20";
+import * as Payments2 from "@filoz/synapse-core/pay";
+import { getBalance } from "viem/actions";
+import * as WarmStorage from "@filoz/synapse-core/warm-storage";
+var calculateStorageCost = (prices, sizeInBytes) => {
+  const { pricePerTiBPerMonthNoCDN, epochsPerMonth } = prices;
+  const sizeInBytesBigint = BigInt(sizeInBytes);
+  const perEpoch = pricePerTiBPerMonthNoCDN * sizeInBytesBigint / (SIZE_CONSTANTS3.TiB * epochsPerMonth);
+  const perDay = perEpoch * TIME_CONSTANTS.EPOCHS_PER_DAY;
+  const perMonth = perEpoch * epochsPerMonth;
+  return {
+    perEpoch,
+    perDay,
+    perMonth
+  };
+};
+var checkStorageBalance = async (storageCapacityBytes = env.TOTAL_STORAGE_NEEDED_GiB * Number(SIZE_CONSTANTS3.GiB), persistencePeriodDays = env.PERSISTENCE_PERIOD_DAYS) => {
+  const [filRaw, { value: usdfcRaw }, { availableFunds }, prices, operatorApprovals2] = await Promise.all([
+    getBalance(client, {
+      address: account.address
+    }),
+    ERC20.balance(client, {
+      address: account.address
+    }),
+    Payments2.accountInfo(client, {
+      address: account.address
+    }),
+    WarmStorage.servicePrice(client),
+    Payments2.operatorApprovals(client, {
+      address: account.address
+    })
   ]);
-  let filRaw;
-  try {
-    filRaw = await synapse.payments.walletBalance();
-  } catch (error) {
-    console.error(error);
-    throw new Error("Error fetching wallet balances. \n FIL balance not available. \n The main cause of this error is that your wallet doesn't have any FIL and has no transaction history on the network. Action: Top up your wallet with FIL.");
-  }
-  let usdfcRaw = await synapse.payments.walletBalance(TOKENS2.USDFC);
-  const allowance = storageInfo.allowances;
-  const availableFunds = accountInfo.availableFunds;
-  const currentMonthlyRate = allowance.rateUsed * TIME_CONSTANTS3.EPOCHS_PER_MONTH;
-  const maxMonthlyRate = prices.perMonth;
+  const storageCosts = calculateStorageCost(prices, storageCapacityBytes);
+  const currentMonthlyRate = operatorApprovals2.rateUsed * TIME_CONSTANTS.EPOCHS_PER_MONTH;
+  const maxMonthlyRate = storageCosts.perMonth;
   const daysLeftAtMaxBurnRate = maxMonthlyRate === 0n ? Infinity : Number(availableFunds) / Number(maxMonthlyRate) * 30;
   const daysLeftAtBurnRate = currentMonthlyRate === 0n ? Infinity : Number(availableFunds) / Number(currentMonthlyRate) * 30;
-  const amountNeeded = prices.perDay * BigInt(persistencePeriodDays);
-  const totalDepositNeeded = daysLeftAtMaxBurnRate >= env.RUNOUT_NOTIFICATION_THRESHOLD_DAYS ? 0n : amountNeeded - accountInfo.availableFunds;
-  const availableToFreeUp = accountInfo.availableFunds > amountNeeded ? accountInfo.availableFunds - amountNeeded : 0n;
-  const isRateSufficient = allowance.rateAllowance === MAX_UINT256;
-  const isLockupSufficient = allowance.lockupAllowance === MAX_UINT256;
+  const amountNeeded = storageCosts.perDay * BigInt(persistencePeriodDays);
+  const totalDepositNeeded = daysLeftAtMaxBurnRate >= env.RUNOUT_NOTIFICATION_THRESHOLD_DAYS ? 0n : amountNeeded - availableFunds;
+  const availableToFreeUp = availableFunds > amountNeeded ? availableFunds - amountNeeded : 0n;
+  const isRateSufficient = operatorApprovals2.rateAllowance === MAX_UINT256;
+  const isLockupSufficient = operatorApprovals2.lockupAllowance === MAX_UINT256;
   const isSufficient = isRateSufficient && isLockupSufficient && daysLeftAtMaxBurnRate >= env.RUNOUT_NOTIFICATION_THRESHOLD_DAYS;
   return {
     filBalance: filRaw,
@@ -513,8 +582,8 @@ var formatStorageBalanceResult = (checkStorageBalanceResult) => {
     isSufficient: checkStorageBalanceResult.isSufficient
   };
 };
-var formatBalance = (balance, ticker) => {
-  return `${Number(Number(formatUnits(balance, 18)).toFixed(8))} ${ticker}`;
+var formatBalance = (balance2, ticker) => {
+  return `${Number(Number(formatUnits(balance2, 18)).toFixed(8))} ${ticker}`;
 };
 var formatTime = (days) => {
   if (days === Infinity) {
@@ -531,17 +600,89 @@ var formatTime = (days) => {
   }
   return `${Math.fround(days / 365)} years`;
 };
+var estimateStorageCost = async (sizeInBytes, durationInMonths, createCDNDataset = false) => {
+  const prices = await WarmStorage.servicePrice(client);
+  const { minimumPricePerMonth, pricePerTiBPerMonthNoCDN } = prices;
+  let pricePerMonth = pricePerTiBPerMonthNoCDN * BigInt(sizeInBytes) / BigInt(SIZE_CONSTANTS3.TiB);
+  const appliedMinimum = pricePerMonth < minimumPricePerMonth;
+  if (appliedMinimum) {
+    pricePerMonth = minimumPricePerMonth;
+  }
+  let totalCost = pricePerMonth * BigInt(durationInMonths);
+  const cdnSetupCost = createCDNDataset ? 10n ** 18n : 0n;
+  totalCost += cdnSetupCost;
+  const sizeInGiB = Number(sizeInBytes) / Number(SIZE_CONSTANTS3.GiB);
+  const sizeInTiB = Number(sizeInBytes) / Number(SIZE_CONSTANTS3.TiB);
+  let sizeFormatted;
+  if (sizeInTiB >= 1) {
+    sizeFormatted = `${sizeInTiB.toFixed(2)} TiB`;
+  } else if (sizeInGiB >= 1) {
+    sizeFormatted = `${sizeInGiB.toFixed(2)} GiB`;
+  } else {
+    const sizeInMiB = Number(sizeInBytes) / Number(SIZE_CONSTANTS3.MiB);
+    sizeFormatted = `${sizeInMiB.toFixed(2)} MiB`;
+  }
+  return {
+    monthlyCost: pricePerMonth,
+    totalCost,
+    totalCostFormatted: formatUnits(totalCost, 18),
+    cdnSetupCost,
+    cdnSetupCostFormatted: formatUnits(cdnSetupCost, 18),
+    details: {
+      sizeInBytes,
+      sizeFormatted,
+      durationInMonths,
+      pricePerTiBPerMonth: pricePerTiBPerMonthNoCDN,
+      minimumPricePerMonth,
+      appliedMinimum
+    }
+  };
+};
+
+// src/services/provider-service.ts
+import { readProviders, getProvider as readProvider } from "@filoz/synapse-core/warm-storage";
+var getProvider = async (providerId) => {
+  const provider = await readProvider(publicClient, {
+    providerId: BigInt(providerId)
+  });
+  return serializeBigInt(provider);
+};
 
 // src/mastra/tools/dataset-tools.ts
-var getDatasets2 = createTool({
+var getDatasets = createTool({
   id: "getDatasets",
   description: "Retrieve all datasets owned by the connected wallet with comprehensive information including piece CIDs, file sizes, provider details, and retrieval URLs. Filter by CDN status or view all datasets. Each dataset contains complete metadata about stored files and their blockchain storage proofs. Use this to inventory files, check storage status, or locate specific uploads.",
   inputSchema: GetDatasetsSchema,
   outputSchema: GetDatasetsOutputSchema,
   execute: async ({ context }) => {
-    const withCDN = context.filterByCDN ?? false;
-    const includeAll = context.includeAllDatasets ?? false;
-    return await getDatasets(withCDN, includeAll);
+    const progressLog = [];
+    const log = (msg) => {
+      progressLog.push(msg);
+    };
+    try {
+      const withCDN = context.filterByCDN ?? false;
+      const includeAll = context.includeAllDatasets ?? false;
+      log("Fetching datasets from blockchain...");
+      const dataSets = await getDatasetsService(withCDN, includeAll);
+      if (dataSets.length > 0) {
+        log(`Retrieved ${dataSets.length} dataset(s)`);
+        log("Processing dataset metadata...");
+      }
+      return {
+        success: true,
+        datasets: dataSets.map((dataset) => serializeBigInt(dataset)),
+        count: dataSets.length,
+        message: `Found ${dataSets.length} dataset(s)`,
+        progressLog
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        message: `Failed to fetch datasets: ${error.message}`,
+        progressLog
+      };
+    }
   }
 });
 var getDataset = createTool({
@@ -551,11 +692,11 @@ var getDataset = createTool({
   outputSchema: GetDatasetOutputSchema,
   execute: async ({ context }) => {
     try {
-      const dataset = await getDatasets(void 0, void 0, Number(context.datasetId));
+      const dataset = await getDataSetService(Number(context.datasetId));
       return {
-        success: dataset.success,
-        dataset: serializeBigInt(dataset.datasets[0]),
-        message: dataset.message
+        success: true,
+        dataset: serializeBigInt(dataset),
+        message: "Dataset fetched successfully"
       };
     } catch (error) {
       return createErrorResponse(
@@ -568,60 +709,60 @@ var getDataset = createTool({
 });
 var createDataset = createTool({
   id: "createDataset",
-  description: "Create a new dataset container on Filecoin for organizing related files with consistent storage settings. Datasets define storage parameters (CDN enabled/disabled, provider selection) that apply to all files added to them. Creating datasets upfront allows for better file organization and consistent retrieval performance. Optionally specify a provider or let the system auto-select the optimal one. Note: Payment is processed automatically for CDN-enabled datasets.",
+  description: "Create a new dataset container on Filecoin for organizing related files with consistent storage settings. Datasets define storage parameters (CDN enabled/disabled, provider selection) that apply to all files added to them. Creating datasets upfront allows for better file organization and consistent retrieval performance. Provider ID is required - use getProviders to list available providers. Payment (1 USDFC) is processed automatically for CDN-enabled datasets. Returns dataset ID, transaction hash, and progress tracking through validation, payment, and creation steps.",
   inputSchema: CreateDatasetSchema,
   outputSchema: CreateDatasetOutputSchema,
   execute: async ({ context }) => {
-    try {
-      const synapse = await getSynapseInstance();
-      const withCDN = true;
-      if (withCDN) {
-        const paymentResult = await processStoragePayment(synapse, BigInt(env.TOTAL_STORAGE_NEEDED_GiB * Number(SIZE_CONSTANTS.GiB)), env.PERSISTENCE_PERIOD_DAYS);
-        if (!paymentResult.success) {
-          return createErrorResponse(
-            "payment_failed",
-            `Failed to process payment: ${paymentResult.txHash ?? "Unknown error"}`,
-            { success: false }
-          );
-        }
+    const progressLog = [];
+    const log = (msg) => {
+      progressLog.push(msg);
+    };
+    if (!context.providerId) {
+      return {
+        success: false,
+        error: "provider_id_required",
+        message: "Provider ID is required. Use getProviders tool to list available providers and select one by ID.",
+        progressLog
+      };
+    }
+    log("Validating provider ID...");
+    const provider = await getProvider(Number(context.providerId));
+    log(`Provider validated (ID: ${context.providerId})`);
+    const withCDN = context.withCDN ?? false;
+    if (withCDN) {
+      log("Processing CDN payment (1 USDFC)...");
+      const { success, error } = await processPaymentService(BigInt(env.CDN_DATASET_FEE));
+      if (!success) {
+        return {
+          success: false,
+          error: "payment_failed",
+          message: `Failed to process CDN payment (1 USDFC required): ${error}. Use processPayment tool to add funds first.`,
+          progressLog
+        };
+      }
+      log("CDN payment processed successfully");
+    }
+    log("Creating dataset on blockchain...");
+    const result = await createDataSetService(provider, withCDN, context.metadata ?? {});
+    if (result.success) {
+      log("Dataset created successfully");
+      if (result.txHash) {
+        log(`View transaction: ${getExplorerUrl(result.txHash)}`);
       }
-      let datasetId;
-      let txHash;
-      await synapse.createStorage({
-        providerId: context.providerId ? parseInt(context.providerId) : void 0,
-        forceCreateDataSet: true,
-        metadata: context.metadata,
-        callbacks: {
-          onDataSetCreationStarted: (txResponse) => {
-            txHash = txResponse.hash;
-            console.log(`[Dataset] Creation started (tx: ${txResponse.hash})`);
-          },
-          onDataSetCreationProgress: (status) => {
-            if (status.serverConfirmed) {
-              datasetId = status.dataSetId?.toString() || void 0;
-              console.log(`[Dataset] Ready (ID: ${status.dataSetId?.toString()})`);
-            }
-          }
-        }
-      });
       return {
-        success: true,
-        datasetId,
-        txHash,
-        message: "Dataset created successfully"
+        ...result,
+        progressLog
       };
-    } catch (error) {
-      return createErrorResponse(
-        "dataset_creation_failed",
-        `Failed to create dataset: ${error.message}`,
-        { success: false }
-      );
     }
+    return {
+      ...result,
+      progressLog
+    };
   }
 });
 var datasetTools = {
   getDataset,
-  getDatasets: getDatasets2,
+  getDatasets,
   createDataset
 };
 
@@ -651,7 +792,6 @@ var uploadFile = createTool2({
       const synapse = await getSynapseInstance();
       log("Checking storage balance...");
       const storageMetrics = await checkStorageBalance(
-        synapse,
         fileInfo.size,
         env.PERSISTENCE_PERIOD_DAYS
       );
@@ -660,22 +800,25 @@ var uploadFile = createTool2({
           return {
             success: false,
             error: "insufficient_balance",
-            message: "Insufficient balance. Enable autoPayment or call processPayment first",
-            required: {
-              deposit: fromBaseUnits(storageMetrics.depositNeeded, 18)
-            }
+            message: `Insufficient balance: ${fromBaseUnits(storageMetrics.depositNeeded, 18)} USDFC required. Enable autoPayment parameter or use processPayment tool to deposit funds first.`
           };
         }
         log(storageMetrics.depositNeeded > 0n ? "Insufficient balance, processing payment..." : "Insufficient service approvals, approving service...");
-        await processStoragePayment(
-          synapse,
-          storageMetrics.depositNeeded,
-          env.PERSISTENCE_PERIOD_DAYS
-        );
-        log(storageMetrics.depositNeeded > 0n ? "Payment processed successfully" : "Service approved successfully");
+        log(`Deposit needed: ${fromBaseUnits(storageMetrics.depositNeeded, 18)} USDFC`);
+        if (storageMetrics.depositNeeded > 0n || !storageMetrics.isSufficient) {
+          const { success } = await processPaymentService(BigInt(storageMetrics.depositNeeded));
+          if (!success) {
+            return createErrorResponse(
+              "payment_failed",
+              "Failed to process payment",
+              { success: false }
+            );
+          }
+          log("Payment processed successfully");
+        }
       }
       log("Creating storage service...");
-      const storageService = await synapse.createStorage({
+      const storageService = await synapse.storage.createContext({
         dataSetId: context.datasetId ? Number(context.datasetId) : void 0,
         withCDN: context.withCDN || false,
         callbacks: {
@@ -684,16 +827,8 @@ var uploadFile = createTool2({
             log(`Dataset provider: ${Number(info.provider.id)}`);
             log(`Is existing dataset: ${info.isExisting}`);
           },
-          onDataSetCreationStarted: (txResponse) => {
-            log(`Dataset creation started (tx: ${txResponse.hash})`);
-          },
-          onDataSetCreationProgress: (status) => {
-            if (status.serverConfirmed) {
-              log(`Dataset ready (ID: ${status.dataSetId})`);
-            }
-          },
-          onProviderSelected: (provider) => {
-            log(`Provider selected: ${provider.id}`);
+          onProviderSelected: (provider2) => {
+            log(`Provider selected: ${provider2.id}`);
           }
         }
       });
@@ -704,19 +839,24 @@ var uploadFile = createTool2({
         onUploadComplete: (piece) => {
           log(`Upload complete (pieceCid: ${piece.toV1().toString()})`);
         },
-        onPieceAdded: (txResponse) => {
-          uploadTxHash = txResponse?.hash;
-          log(`Piece added to dataset (tx: ${txResponse?.hash || "pending"})`);
+        onPieceAdded: (hash) => {
+          uploadTxHash = hash;
+          log(`Piece added to dataset (tx: ${hash || "pending"})`);
         },
         onPieceConfirmed: () => {
           log("Piece confirmed on blockchain");
         }
       });
+      const provider = await getProvider(storageService.provider.id);
       const getRetrievalUrl = async (pieceCid2) => {
         if (context.withCDN) {
-          return `https://${await synapse.getSigner().getAddress()}.calibration.filbeam.io/${pieceCid2}`;
+          const network = env.FILECOIN_NETWORK === "mainnet" ? "mainnet" : "calibration";
+          return `https://${await synapse.getSigner().getAddress()}.${network}.filbeam.io/${pieceCid2}`;
         } else {
-          return `${(await storageService.getProviderInfo()).products.PDP?.data.serviceURL || ""}/piece/${pieceCid2}`;
+          const serviceURL = provider.pdp.serviceURL;
+          const endsWithSlash = serviceURL.endsWith("/");
+          const serviceURLWithoutSlash = endsWithSlash ? serviceURL.slice(0, -1) : serviceURL;
+          return `${serviceURLWithoutSlash}/piece/${pieceCid2}`;
         }
       };
       const retrievalUrl = await getRetrievalUrl(pieceCid.toV1().toString());
@@ -725,6 +865,9 @@ var uploadFile = createTool2({
       console.log(`TX Hash: ${uploadTxHash}`);
       console.log(`File Name: ${fileName}`);
       console.log(`File Size: ${fileInfo.size}`);
+      if (uploadTxHash) {
+        log(`View transaction: ${getExplorerUrl(uploadTxHash)}`);
+      }
       return {
         success: true,
         pieceCid: pieceCid.toV1().toString(),
@@ -755,24 +898,53 @@ var fileTools = {
 import { createTool as createTool3 } from "@mastra/core";
 var getBalances = createTool3({
   id: "getBalances",
-  description: "Check wallet balances (FIL and USDFC tokens) and comprehensive storage metrics including available funds, required deposits, days of storage remaining, and allowance status. Returns both human-readable formatted values and raw data. Use this before upload operations to verify sufficient balance, or to monitor storage budget and plan deposits. Calculates storage needs based on capacity and persistence period parameters.",
+  description: "Check wallet balances (FIL and USDFC tokens) and comprehensive storage metrics including available funds, required deposits, days of storage remaining, and allowance status. Returns both human-readable formatted values and raw data with progress log showing calculation parameters used. \u26A0\uFE0F CRITICAL: Storage providers consider accounts with less than 30 days of available balance as INSOLVENT and may refuse service. Default notice period is 45 days to ensure safe margin. IMPORTANT AGENT INSTRUCTIONS: (1) Before calling this tool, ASK the user if they want to calculate based on default storage requirements (150 GiB capacity, 365 days persistence, 45 days notice period) or if they have specific requirements. (2) After showing results, ALWAYS ASK the user if they want to see calculations for different storage configurations. (3) If days remaining falls below 45, WARN the user that they are approaching insolvency threshold (30 days) and should deposit funds immediately. Use this before upload operations to verify sufficient balance, or to monitor storage budget and plan deposits.",
   inputSchema: GetBalancesSchema,
   outputSchema: GetBalancesOutputSchema,
   execute: async ({ context }) => {
+    const progressLog = [];
+    const log = (msg) => {
+      progressLog.push(msg);
+    };
     try {
-      const synapse = await getSynapseInstance();
-      const checkStorageBalanceResult = await checkStorageBalance(synapse, context.storageCapacityBytes, env.PERSISTENCE_PERIOD_DAYS);
+      const storageCapacityBytes = context.storageCapacityBytes || env.TOTAL_STORAGE_NEEDED_GiB * 1024 * 1024 * 1024;
+      const persistencePeriodDays = context.persistencePeriodDays || env.PERSISTENCE_PERIOD_DAYS;
+      const notificationThresholdDays = context.notificationThresholdDays || env.RUNOUT_NOTIFICATION_THRESHOLD_DAYS;
+      const capacityGB = (storageCapacityBytes / (1024 * 1024 * 1024)).toFixed(2);
+      const capacityTB = (storageCapacityBytes / (1024 * 1024 * 1024 * 1024)).toFixed(2);
+      log(`Calculating balance requirements with:`);
+      log(`- Storage Capacity: ${capacityGB} GB (${capacityTB} TB)`);
+      log(`- Persistence Period: ${persistencePeriodDays} days`);
+      log(`- Notification Threshold: ${notificationThresholdDays} days`);
+      log("Fetching wallet balances from blockchain...");
+      const checkStorageBalanceResult = await checkStorageBalance(storageCapacityBytes, persistencePeriodDays);
+      log("Calculating storage metrics and requirements...");
+      const formattedResult = formatStorageBalanceResult(checkStorageBalanceResult);
+      const serializedResult = serializeBigInt(checkStorageBalanceResult);
+      log(`Balance check complete. Available USDFC: ${formattedResult.usdfcBalance}`);
+      const daysLeft = checkStorageBalanceResult.daysLeftAtBurnRate;
+      if (daysLeft < 45) {
+        if (daysLeft < 30) {
+          log(`\u26D4 CRITICAL INSOLVENCY WARNING: Only ${daysLeft.toFixed(1)} days of balance remaining! Storage providers consider accounts with less than 30 days as INSOLVENT and will REFUSE SERVICE. Deposit funds IMMEDIATELY!`);
+        } else {
+          log(`\u26A0\uFE0F LOW BALANCE WARNING: Only ${daysLeft.toFixed(1)} days remaining (threshold: 45 days). You are approaching the insolvency threshold (30 days). Please deposit funds soon to avoid service interruption.`);
+        }
+      }
+      log("\u{1F4A1} To calculate for different storage requirements, call this tool again with custom storageCapacityBytes and persistencePeriodDays parameters.");
       return {
         success: true,
-        checkStorageBalanceResultFormatted: formatStorageBalanceResult(checkStorageBalanceResult),
-        checkStorageBalanceResult: serializeBigInt(checkStorageBalanceResult)
+        checkStorageBalanceResultFormatted: formattedResult,
+        checkStorageBalanceResult: serializedResult,
+        progressLog,
+        message: `Balance check complete for ${capacityTB} TB over ${persistencePeriodDays} days. Available: ${formattedResult.usdfcBalance}`
       };
     } catch (error) {
-      return createErrorResponse(
-        "balance_fetch_failed",
-        `Failed to fetch balances: ${error.message}`,
-        { success: false }
-      );
+      return {
+        success: false,
+        error: "balance_fetch_failed",
+        message: `Failed to fetch balances: ${error.message}`,
+        progressLog
+      };
     }
   }
 });
@@ -784,61 +956,82 @@ var balanceTools = {
 import { createTool as createTool4 } from "@mastra/core";
 var processPayment = createTool4({
   id: "processPayment",
-  description: "Deposit USDFC tokens and configure storage service allowances in a single transaction using EIP-2612 gasless permits. Sets both rate allowance (per-epoch spending limit) and lockup allowance (total committed funds) to unlimited for seamless storage operations. Use this to fund your storage account before uploads or when balance is insufficient. Validates wallet balance before processing to prevent failed transactions.",
+  description: "Deposit USDFC tokens (not in base units) and configure storage service allowances in a single transaction using EIP-2612 gasless permits. Sets both rate allowance (per-epoch spending limit) and lockup allowance (total committed funds) to unlimited for seamless storage operations. Use this to fund your storage account before uploads or when balance is insufficient. Validates wallet balance before processing to prevent failed transactions.",
   inputSchema: ProcessPaymentSchema,
   outputSchema: ProcessPaymentOutputSchema,
   execute: async ({ context }) => {
-    try {
-      const synapse = await getSynapseInstance();
-      const accountInfo = await synapse.payments.accountInfo(TOKENS.USDFC);
-      const availableFunds = Number(accountInfo.availableFunds);
-      const { depositAmount } = context;
-      if (depositAmount === 0) {
-        return {
-          success: true,
-          message: `You have sufficient balance to cover the storage needs.`,
-          txHash: null,
-          required: {
-            deposit: depositAmount
-          },
-          available: availableFunds
-        };
-      }
-      if (availableFunds < depositAmount) {
-        return {
-          success: false,
-          error: "insufficient_balance",
-          message: `Insufficient USDFC balance. Required: ${depositAmount}, Available: ${availableFunds}`,
-          required: depositAmount,
-          available: Number(availableFunds)
-        };
-      }
-      const result = await processStoragePayment(
-        synapse,
-        BigInt(depositAmount),
-        env.PERSISTENCE_PERIOD_DAYS
-      );
+    const progressLog = [];
+    const log = (msg) => {
+      progressLog.push(msg);
+    };
+    const { depositAmount } = context;
+    log("Converting amount to base units...");
+    const amount = toBaseUnits(depositAmount.toString(), 18);
+    log("Initiating payment transaction...");
+    const { success, txHash, error } = await processPaymentService(amount);
+    if (!success) {
       return {
-        success: result.success,
-        txHash: result.txHash,
-        message: `Payment processed successfully now you can upload files to storage. You paid ${depositAmount} USDFC to cover the storage needs.`
+        success: false,
+        error: "payment_failed",
+        message: `Failed to process payment: ${error}`,
+        progressLog
       };
-    } catch (error) {
-      return createErrorResponse(
-        "payment_failed",
-        `Payment processing failed: ${error.message}`,
-        { success: false }
-      );
     }
+    log("Payment transaction confirmed");
+    if (txHash) {
+      log(`View transaction: ${getExplorerUrl(txHash)}`);
+    }
+    return {
+      success,
+      txHash,
+      message: `Payment processed successfully. You deposited ${depositAmount} USDFC to your storage account.`,
+      progressLog
+    };
+  }
+});
+var processWithdrawal = createTool4({
+  id: "processWithdrawal",
+  description: "Withdraw USDFC tokens (not in base units) from the storage account back to your wallet. Reduces storage service allowances and available balance. Use this to retrieve unused funds from the storage account. Returns transaction hash for verification and progress tracking through conversion, initiation, and confirmation steps.",
+  inputSchema: ProcessWithdrawalSchema,
+  outputSchema: ProcessWithdrawalOutputSchema,
+  execute: async ({ context }) => {
+    const progressLog = [];
+    const log = (msg) => {
+      progressLog.push(msg);
+    };
+    const { withdrawalAmount } = context;
+    log("Converting amount to base units...");
+    const amount = toBaseUnits(withdrawalAmount.toString(), 18);
+    log("Initiating withdrawal transaction...");
+    const { success, txHash, error } = await processWithdrawalService(amount);
+    if (!success) {
+      return {
+        success: false,
+        error: "withdrawal_failed",
+        message: `Failed to process withdrawal: ${error}`,
+        progressLog
+      };
+    }
+    log("Withdrawal transaction confirmed");
+    if (txHash) {
+      log(`View transaction: ${getExplorerUrl(txHash)}`);
+    }
+    return {
+      success: true,
+      txHash,
+      message: `Withdrawal processed successfully. You withdrew ${withdrawalAmount} USDFC from your storage account.`,
+      progressLog
+    };
   }
 });
 var paymentTools = {
-  processPayment
+  processPayment,
+  processWithdrawal
 };
 
 // src/mastra/tools/provider-tools.ts
 import { createTool as createTool5 } from "@mastra/core";
-import { WarmStorageService as WarmStorageService3 } from "@filoz/synapse-sdk";
+import { readProviders as readProviders2 } from "@filoz/synapse-core/warm-storage";
 var getProviders = createTool5({
   id: "getProviders",
   description: "List storage providers available on the Filecoin network with their service details, product offerings, and endpoint URLs. By default returns only approved providers for reliability. Use this to discover available providers, select specific providers for dataset creation, or verify provider availability before operations. Provider information includes service URLs needed for file retrieval.",
@@ -846,21 +1039,11 @@ var getProviders = createTool5({
   outputSchema: GetProvidersOutputSchema,
   execute: async ({ context }) => {
     try {
-      const synapse = await getSynapseInstance();
-      const warmStorageService = await WarmStorageService3.create(
-        synapse.getProvider(),
-        synapse.getWarmStorageAddress()
+      const providers = (await readProviders2(
+        publicClient
+      )).filter(
+        (p) => context.onlyApproved ? p.isActive : true
       );
-      const approvedProviderIds = await warmStorageService.getApprovedProviderIds();
-      const providersInfo = await Promise.all(
-        approvedProviderIds.map(async (providerId) => {
-          const providerInfo = await synapse.getProviderInfo(providerId);
-          return providerInfo;
-        })
-      );
-      const providers = context.onlyApproved !== false ? providersInfo.filter(
-        (p) => approvedProviderIds.includes(p.id)
-      ) : providersInfo;
       return {
         success: true,
         providers: providers.map(serializeBigInt),
@@ -868,10 +1051,12 @@ var getProviders = createTool5({
         message: `Found ${providers.length} provider(s)`
       };
     } catch (error) {
-      return createErrorResponse(
-        "provider_fetch_failed",
-        `Failed to fetch providers: ${error.message}`
-      );
+      return {
+        success: false,
+        providers: [],
+        error: error.message,
+        message: `Failed to fetch providers: ${error.message}`
+      };
     }
   }
 });
@@ -879,35 +1064,496 @@ var providerTools = {
   getProviders
 };
 
+// src/mastra/tools/storage-cost-tools.ts
+import { createTool as createTool6 } from "@mastra/core";
+import { z as z3 } from "zod";
+import { SIZE_CONSTANTS as SIZE_CONSTANTS4 } from "@filoz/synapse-core/utils";
+var EstimateStorageCostSchema = z3.object({
+  sizeInGiB: z3.number().positive().optional().describe("Size of data to store in GiB (gibibytes). Example: 1.5 for 1.5 GiB. Provide either sizeInGiB or sizeInTiB, not both"),
+  sizeInTiB: z3.number().positive().optional().describe("Size of data to store in TiB (tebibytes). Example: 0.5 for 0.5 TiB. Provide either sizeInGiB or sizeInTiB, not both"),
+  durationInMonths: z3.number().positive().int().describe("Duration to store data in months. Example: 12 for one year"),
+  createCDNDataset: z3.boolean().optional().default(false).describe("Whether this is for a new CDN-enabled dataset (adds 1 USDFC one-time cost). Default: false")
+}).refine(
+  (data) => data.sizeInGiB !== void 0 !== (data.sizeInTiB !== void 0),
+  {
+    message: "Exactly one of sizeInGiB or sizeInTiB must be provided"
+  }
+);
+var EstimateStorageCostOutputSchema = z3.object({
+  success: z3.boolean(),
+  // Success fields
+  monthlyCost: z3.string().optional().describe("Monthly storage cost in USDFC"),
+  totalCost: z3.string().optional().describe("Total storage cost for duration in USDFC (includes CDN setup if applicable)"),
+  cdnSetupCost: z3.string().optional().describe("One-time CDN setup cost in USDFC (if createCDNDataset is true)"),
+  cdnEgressCredits: z3.string().optional().describe("CDN egress credits topped up (in GiB) with the 1 USDFC setup cost"),
+  details: z3.object({
+    sizeInBytes: z3.number(),
+    sizeFormatted: z3.string().describe('Human-readable size (e.g., "1.50 GiB")'),
+    durationInMonths: z3.number(),
+    pricePerTiBPerMonth: z3.string(),
+    minimumPricePerMonth: z3.string(),
+    appliedMinimum: z3.boolean().describe("Whether minimum pricing was applied (for storage < 24.567 GiB)")
+  }).optional(),
+  breakdown: z3.string().optional().describe("Human-readable cost breakdown"),
+  pricingExplanation: z3.string().optional().describe("Detailed explanation of how storage pricing works"),
+  cdnPricingExplanation: z3.string().optional().describe("Detailed explanation of how CDN egress pricing works"),
+  // Error fields
+  error: z3.string().optional(),
+  message: z3.string()
+});
+var estimateStoragePricing = createTool6({
+  id: "estimateStoragePricing",
+  description: "Calculate storage costs for Filecoin OnchainCloud and explain pricing models. Provides: (1) Cost estimates with monthly/total breakdowns, (2) Comprehensive explanation of storage pricing (pay-per-epoch, $2.50/TiB/month, $0.06 minimum), (3) CDN egress pricing details ($7/TiB downloads, 1 USDFC = ~146 GiB credits). \u26A0\uFE0F CRITICAL: When explaining budgeting, ALWAYS warn that storage providers consider accounts with less than 30 days of remaining balance as INSOLVENT and may refuse service. Recommend maintaining at least 45 days of balance for safety margin. Use when users ask about storage costs, pricing models, CDN fees, or need to budget for storage. Clarifies that CDN 1 USDFC is NOT a fee but pre-paid egress credits that can be topped up anytime.",
+  inputSchema: EstimateStorageCostSchema,
+  outputSchema: EstimateStorageCostOutputSchema,
+  execute: async ({ context }) => {
+    try {
+      const { sizeInGiB, sizeInTiB, durationInMonths, createCDNDataset } = context;
+      let sizeInBytes;
+      if (sizeInGiB !== void 0) {
+        sizeInBytes = sizeInGiB * Number(SIZE_CONSTANTS4.GiB);
+      } else if (sizeInTiB !== void 0) {
+        sizeInBytes = sizeInTiB * Number(SIZE_CONSTANTS4.TiB);
+      } else {
+        throw new Error("Either sizeInGiB or sizeInTiB must be provided");
+      }
+      const estimate = await estimateStorageCost(
+        sizeInBytes,
+        durationInMonths,
+        createCDNDataset
+      );
+      const cdnEgressCreditsGiB = createCDNDataset ? 1 / CDN_EGRESS_RATE_PER_TIB * 1024 : 0;
+      const breakdown = [
+        `\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`,
+        `Storage Cost Estimate for ${estimate.details.sizeFormatted}`,
+        `Duration: ${durationInMonths} month${durationInMonths !== 1 ? "s" : ""}`,
+        `\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`,
+        ``,
+        `Monthly Storage Cost: ${Number(estimate.monthlyCost) / 1e18} USDFC`,
+        `Total Storage Cost: ${Number(estimate.totalCost - estimate.cdnSetupCost) / 1e18} USDFC`
+      ];
+      if (createCDNDataset && estimate.cdnSetupCost > 0n) {
+        breakdown.push(``);
+        breakdown.push(`CDN Egress Credits Top-up: ${estimate.cdnSetupCostFormatted} USDFC`);
+        breakdown.push(`  \u2192 Provides ~${cdnEgressCreditsGiB.toFixed(2)} GiB of egress credits`);
+        breakdown.push(`  \u2192 You can top up more credits anytime`);
+        breakdown.push(``);
+        breakdown.push(`Grand Total (Storage + CDN Credits): ${estimate.totalCostFormatted} USDFC`);
+      }
+      breakdown.push(``);
+      breakdown.push(`\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`);
+      if (estimate.details.appliedMinimum) {
+        breakdown.push(
+          `Note: Minimum pricing of $0.06/month applied (storage < ~24.567 GiB)`
+        );
+      }
+      const pricingExplanation = [
+        ``,
+        `HOW STORAGE PRICING WORKS:`,
+        `\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`,
+        ``,
+        `Storage operates on a pay-per-epoch model (epochs are 30 seconds):`,
+        ``,
+        `1. BASE RATE: $2.50 per TiB per month`,
+        `   - Calculated per epoch: (size / TiB) \xD7 $2.50/month \xF7 epochs_per_month`,
+        `   - You pay only for the storage space you use`,
+        ``,
+        `2. MINIMUM CHARGE: $0.06 per month`,
+        `   - Applies to storage < ~24.567 GiB`,
+        `   - Ensures service sustainability for small datasets`,
+        ``,
+        `3. PAYMENT MODEL:`,
+        `   - Deposit USDFC tokens into your account`,
+        `   - Set rate allowance (max spending per epoch)`,
+        `   - Set lockup allowance (max total locked funds)`,
+        `   - Storage service deducts costs automatically each epoch`,
+        ``,
+        `4. EPOCHS:`,
+        `   - 1 epoch = 30 seconds`,
+        `   - ~2,880 epochs per day`,
+        `   - ~86,400 epochs per month (30 days)`,
+        ``,
+        `\u26A0\uFE0F CRITICAL - INSOLVENCY WARNING:`,
+        `   - Storage providers consider accounts with LESS THAN 30 DAYS of`,
+        `     remaining balance as INSOLVENT`,
+        `   - Insolvent accounts may be REFUSED SERVICE or have data removed`,
+        `   - ALWAYS maintain at least 45 days of balance for safety margin`,
+        `   - Default notification threshold: 45 days (gives time to deposit)`,
+        `   - Monitor your balance regularly and top up before hitting 30 days`,
+        ``
+      ].join("\n");
+      const cdnPricingExplanation = [
+        ``,
+        `HOW CDN EGRESS PRICING WORKS:`,
+        `\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`,
+        ``,
+        `CDN enables fast file retrieval with egress (download) charges:`,
+        ``,
+        `1. EGRESS RATE: $7 per TiB downloaded`,
+        `   - ~$0.0068 per GiB downloaded`,
+        `   - Only pay for actual data transferred`,
+        ``,
+        `2. CDN CREDITS TOP-UP (Not a Fee!):`,
+        `   - Creating a new CDN dataset requires 1 USDFC top-up`,
+        `   - This is NOT a fee - it's pre-paid egress credits`,
+        `   - 1 USDFC = ~146.29 GiB of download credits`,
+        `   - Credits are deducted as files are downloaded`,
+        ``,
+        `3. REUSING DATASETS:`,
+        `   - Adding files to existing CDN dataset = NO additional top-up`,
+        `   - Only the first dataset creation requires the 1 USDFC top-up`,
+        `   - Your egress credits work across all your CDN datasets`,
+        ``,
+        `4. TOPPING UP CREDITS:`,
+        `   - Top up anytime to avoid running out`,
+        `   - Monitor your remaining egress credits`,
+        `   - No expiration on credits`,
+        ``,
+        `5. EXAMPLE CALCULATIONS:`,
+        `   - 1 USDFC \u2192 ~146 GiB of downloads`,
+        `   - 10 USDFC \u2192 ~1.43 TiB of downloads`,
+        `   - 70 USDFC \u2192 ~10 TiB of downloads`,
+        ``,
+        `6. WHEN TO USE CDN:`,
+        `   - Frequently accessed files`,
+        `   - Public-facing content`,
+        `   - Applications requiring fast retrieval`,
+        `   - Skip CDN for archival/backup storage`,
+        ``
+      ].join("\n");
+      return {
+        success: true,
+        monthlyCost: (Number(estimate.monthlyCost) / 1e18).toString(),
+        totalCost: estimate.totalCostFormatted,
+        cdnSetupCost: estimate.cdnSetupCostFormatted,
+        cdnEgressCredits: createCDNDataset ? `${cdnEgressCreditsGiB.toFixed(2)} GiB (~${(cdnEgressCreditsGiB / 1024).toFixed(4)} TiB)` : "0 GiB",
+        details: {
+          ...estimate.details,
+          pricePerTiBPerMonth: estimate.details.pricePerTiBPerMonth.toString(),
+          minimumPricePerMonth: estimate.details.minimumPricePerMonth.toString()
+        },
+        breakdown: breakdown.join("\n"),
+        pricingExplanation,
+        cdnPricingExplanation,
+        message: `Estimated cost: ${estimate.totalCostFormatted} USDFC for ${estimate.details.sizeFormatted} over ${durationInMonths} month${durationInMonths !== 1 ? "s" : ""}${createCDNDataset ? " (includes 1 USDFC CDN egress credits top-up = ~" + cdnEgressCreditsGiB.toFixed(2) + " GiB of downloads)" : ""}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        message: `Failed to estimate storage cost: ${error.message}`
+      };
+    }
+  }
+});
+var convertStorageSize = createTool6({
+  id: "convertStorageSize",
+  description: "Convert storage sizes between different units (bytes, KiB, MiB, GiB, TiB). Useful when users provide sizes in different formats and you need to calculate storage costs.",
+  inputSchema: z3.object({
+    value: z3.number().positive().describe("The numeric value to convert"),
+    fromUnit: z3.enum(["bytes", "KiB", "MiB", "GiB", "TiB"]).describe("The unit to convert from"),
+    toUnit: z3.enum(["bytes", "KiB", "MiB", "GiB", "TiB"]).optional().describe("The unit to convert to. If not specified, returns all units")
+  }),
+  outputSchema: z3.object({
+    success: z3.boolean(),
+    bytes: z3.number().optional(),
+    KiB: z3.number().optional(),
+    MiB: z3.number().optional(),
+    GiB: z3.number().optional(),
+    TiB: z3.number().optional(),
+    message: z3.string(),
+    error: z3.string().optional()
+  }),
+  execute: async ({ context }) => {
+    try {
+      const { value, fromUnit, toUnit } = context;
+      let bytes;
+      switch (fromUnit) {
+        case "bytes":
+          bytes = value;
+          break;
+        case "KiB":
+          bytes = value * Number(SIZE_CONSTANTS4.KiB);
+          break;
+        case "MiB":
+          bytes = value * Number(SIZE_CONSTANTS4.MiB);
+          break;
+        case "GiB":
+          bytes = value * Number(SIZE_CONSTANTS4.GiB);
+          break;
+        case "TiB":
+          bytes = value * Number(SIZE_CONSTANTS4.TiB);
+          break;
+      }
+      if (toUnit) {
+        let result;
+        switch (toUnit) {
+          case "bytes":
+            result = bytes;
+            break;
+          case "KiB":
+            result = bytes / Number(SIZE_CONSTANTS4.KiB);
+            break;
+          case "MiB":
+            result = bytes / Number(SIZE_CONSTANTS4.MiB);
+            break;
+          case "GiB":
+            result = bytes / Number(SIZE_CONSTANTS4.GiB);
+            break;
+          case "TiB":
+            result = bytes / Number(SIZE_CONSTANTS4.TiB);
+            break;
+        }
+        return {
+          success: true,
+          [toUnit]: result,
+          message: `${value} ${fromUnit} = ${result.toFixed(4)} ${toUnit}`
+        };
+      }
+      return {
+        success: true,
+        bytes,
+        KiB: bytes / Number(SIZE_CONSTANTS4.KiB),
+        MiB: bytes / Number(SIZE_CONSTANTS4.MiB),
+        GiB: bytes / Number(SIZE_CONSTANTS4.GiB),
+        TiB: bytes / Number(SIZE_CONSTANTS4.TiB),
+        message: `Converted ${value} ${fromUnit} to all units`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        message: `Failed to convert storage size: ${error.message}`
+      };
+    }
+  }
+});
+var getStoragePricingInfo = createTool6({
+  id: "getStoragePricingInfo",
+  description: "Get comprehensive information about Filecoin OnchainCloud storage pricing, including cost structure, CDN egress pricing, payment model, and a detailed example of storing 1 TiB for 1 year. \u26A0\uFE0F CRITICAL: ALWAYS include the insolvency warning (accounts with less than 30 days balance are considered insolvent and may be refused service). Recommend 45-day minimum balance. Use this when users ask general questions about 'how much does storage cost', 'explain storage pricing', 'how does billing work', or want to understand the pricing model before calculating specific costs.",
+  inputSchema: z3.object({
+    includeCDNExample: z3.boolean().optional().default(true).describe("Include CDN pricing example. Default: true")
+  }),
+  outputSchema: z3.object({
+    success: z3.boolean(),
+    pricingOverview: z3.string().optional(),
+    storageModel: z3.object({
+      baseRate: z3.string(),
+      minimumCharge: z3.string(),
+      minimumThreshold: z3.string(),
+      epochDuration: z3.string(),
+      epochsPerDay: z3.number(),
+      epochsPerMonth: z3.number()
+    }).optional(),
+    cdnModel: z3.object({
+      egressRate: z3.string(),
+      creditsTopUp: z3.string(),
+      creditsPerUSDFC: z3.string(),
+      isTopUpAFee: z3.boolean(),
+      canTopUpMore: z3.boolean()
+    }).optional(),
+    exampleCalculation: z3.object({
+      scenario: z3.string(),
+      size: z3.string(),
+      duration: z3.string(),
+      monthlyCost: z3.string(),
+      yearlyStorageCost: z3.string(),
+      cdnTopUp: z3.string().optional(),
+      cdnEgressCredits: z3.string().optional(),
+      totalCost: z3.string(),
+      breakdown: z3.string()
+    }).optional(),
+    paymentModel: z3.string().optional(),
+    error: z3.string().optional(),
+    message: z3.string()
+  }),
+  execute: async ({ context }) => {
+    try {
+      const { includeCDNExample } = context;
+      const exampleSizeBytes = Number(SIZE_CONSTANTS4.TiB);
+      const exampleDurationMonths = 12;
+      const estimate = await estimateStorageCost(
+        exampleSizeBytes,
+        exampleDurationMonths,
+        includeCDNExample
+      );
+      const cdnEgressCreditsGiB = includeCDNExample ? 1 / CDN_EGRESS_RATE_PER_TIB * 1024 : 0;
+      const pricingOverview = [
+        `FILECOIN ONCHAINCLOUD STORAGE PRICING`,
+        `\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`,
+        ``,
+        `Filecoin OnchainCloud provides decentralized storage with transparent,`,
+        `usage-based pricing. You only pay for what you store, when you store it.`,
+        ``,
+        `COST COMPONENTS:`,
+        `  \u2022 Storage: Pay per epoch (30-second intervals) for stored data`,
+        `  \u2022 CDN Egress: Pay per TiB downloaded (optional, for fast retrieval)`,
+        `  \u2022 No hidden fees, no minimum contracts, no lock-in periods`,
+        ``
+      ].join("\n");
+      const storageModel = {
+        baseRate: "$2.50 per TiB per month",
+        minimumCharge: "$0.06 per month",
+        minimumThreshold: "~24.567 GiB (applies to storage smaller than this)",
+        epochDuration: "30 seconds",
+        epochsPerDay: 2880,
+        epochsPerMonth: 86400
+        // 30 days
+      };
+      const cdnModel = includeCDNExample ? {
+        egressRate: "$7 per TiB downloaded (~$0.0068 per GiB)",
+        creditsTopUp: "1 USDFC required when creating first CDN dataset",
+        creditsPerUSDFC: "~146.29 GiB of egress credits",
+        isTopUpAFee: false,
+        canTopUpMore: true
+      } : void 0;
+      const exampleBreakdown = [
+        `DETAILED CALCULATION:`,
+        `\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`,
+        ``,
+        `Size: 1 TiB (1,099,511,627,776 bytes)`,
+        `Duration: 12 months (1 year)`,
+        ``,
+        `STORAGE COSTS:`,
+        `  Base Rate: $2.50/TiB/month`,
+        `  Calculation: 1 TiB \xD7 $2.50/month \xD7 12 months`,
+        `  Monthly Cost: ${(Number(estimate.monthlyCost) / 1e18).toFixed(4)} USDFC`,
+        `  Yearly Storage: ${(Number(estimate.totalCost - estimate.cdnSetupCost) / 1e18).toFixed(4)} USDFC`,
+        ``
+      ];
+      if (includeCDNExample) {
+        exampleBreakdown.push(
+          `CDN EGRESS CREDITS (Optional):`,
+          `  Initial Top-up: 1.0 USDFC (pre-paid credits, NOT a fee)`,
+          `  Provides: ~${cdnEgressCreditsGiB.toFixed(2)} GiB of download credits`,
+          `  Reusing dataset: No additional top-up required`,
+          `  Additional top-ups: Available anytime`,
+          ``
+        );
+      }
+      exampleBreakdown.push(
+        `TOTAL COST:`,
+        `  Storage (12 months): ${(Number(estimate.totalCost - estimate.cdnSetupCost) / 1e18).toFixed(4)} USDFC`
+      );
+      if (includeCDNExample) {
+        exampleBreakdown.push(
+          `  CDN Credits Top-up: ${estimate.cdnSetupCostFormatted} USDFC`,
+          `  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`,
+          `  Grand Total: ${estimate.totalCostFormatted} USDFC`,
+          ``,
+          `Note: The CDN top-up gives you ${cdnEgressCreditsGiB.toFixed(2)} GiB of downloads.`,
+          `      If you download your 1 TiB once, you'd need ~7 USDFC more in credits.`
+        );
+      } else {
+        exampleBreakdown.push(
+          `  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`,
+          `  Total: ${estimate.totalCostFormatted} USDFC`
+        );
+      }
+      const paymentModel = [
+        ``,
+        `HOW PAYMENT WORKS:`,
+        `\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`,
+        ``,
+        `1. DEPOSIT FUNDS:`,
+        `   \u2022 Add USDFC tokens to your storage account`,
+        `   \u2022 Funds are held securely in your account`,
+        `   \u2022 You maintain full control and can withdraw anytime`,
+        ``,
+        `2. SET ALLOWANCES (Safety Limits):`,
+        `   \u2022 Rate Allowance: Max spending per epoch (prevents runaway costs)`,
+        `   \u2022 Lockup Allowance: Max total funds that can be locked`,
+        `   \u2022 Max Lockup Period: Maximum duration for any payment rail`,
+        ``,
+        `3. AUTOMATIC DEDUCTION:`,
+        `   \u2022 Every epoch (30 seconds), storage costs are calculated`,
+        `   \u2022 Amount is automatically deducted from your balance`,
+        `   \u2022 No manual payments, no invoices, fully automated`,
+        ``,
+        `4. MONITORING:`,
+        `   \u2022 Check your balance anytime`,
+        `   \u2022 See your burn rate (spending per day/month)`,
+        `   \u2022 Get notified when balance is low`,
+        `   \u2022 Top up as needed to avoid service interruption`,
+        ``,
+        `5. TRANSPARENCY:`,
+        `   \u2022 All costs calculated on-chain`,
+        `   \u2022 Real-time pricing information available`,
+        `   \u2022 No surprise charges or hidden fees`,
+        ``,
+        `\u26A0\uFE0F CRITICAL - INSOLVENCY WARNING:`,
+        `   \u2022 Storage providers consider accounts with LESS THAN 30 DAYS of`,
+        `     remaining balance as INSOLVENT`,
+        `   \u2022 Insolvent accounts may be REFUSED SERVICE or have data removed`,
+        `   \u2022 ALWAYS maintain at least 45 days of balance for safety margin`,
+        `   \u2022 Default notification threshold: 45 days (gives time to deposit)`,
+        `   \u2022 Set up monitoring and alerts to avoid running low on funds`,
+        ``
+      ].join("\n");
+      return {
+        success: true,
+        pricingOverview,
+        storageModel,
+        cdnModel,
+        exampleCalculation: {
+          scenario: "Storing 1 TiB for 1 year" + (includeCDNExample ? " with CDN" : ""),
+          size: "1 TiB (1,099,511,627,776 bytes)",
+          duration: "12 months (1 year)",
+          monthlyCost: `${(Number(estimate.monthlyCost) / 1e18).toFixed(4)} USDFC`,
+          yearlyStorageCost: `${(Number(estimate.totalCost - estimate.cdnSetupCost) / 1e18).toFixed(4)} USDFC`,
+          cdnTopUp: includeCDNExample ? estimate.cdnSetupCostFormatted + " USDFC" : void 0,
+          cdnEgressCredits: includeCDNExample ? `~${cdnEgressCreditsGiB.toFixed(2)} GiB of downloads` : void 0,
+          totalCost: estimate.totalCostFormatted + " USDFC",
+          breakdown: exampleBreakdown.join("\n")
+        },
+        paymentModel,
+        message: `Storage pricing: $2.50/TiB/month (minimum $0.06/month). Example: 1 TiB for 1 year = ${estimate.totalCostFormatted} USDFC${includeCDNExample ? " (includes 1 USDFC CDN credits = ~" + cdnEgressCreditsGiB.toFixed(2) + " GiB downloads)" : ""}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        message: `Failed to get pricing info: ${error.message}`
+      };
+    }
+  }
+});
+var storageCostTools = {
+  estimateStoragePricing,
+  convertStorageSize,
+  getStoragePricingInfo
+};
+
 // src/mastra/tools/index.ts
 var focStorageTools = {
   ...datasetTools,
   ...fileTools,
   ...balanceTools,
   ...paymentTools,
-  ...providerTools
+  ...providerTools,
+  ...storageCostTools
 };
 var focStorageToolsArray = Object.values(focStorageTools);
 
 // src/mastra/workflows/e2e-file-upload.ts
 import { createStep, createWorkflow } from "@mastra/core/workflows";
-import { z as z3 } from "zod";
-var e2eFileUploadInputSchema = z3.object({
-  filePath: z3.string().describe("Absolute path to the file to upload"),
-  datasetId: z3.string().optional().describe("Existing dataset ID to use"),
-  withCDN: z3.boolean().optional().describe("Enable CDN for faster retrieval").default(false),
-  persistenceDays: z3.number().optional().describe("Storage duration in days (default: 180)").default(env.PERSISTENCE_PERIOD_DAYS),
-  notificationThresholdDays: z3.number().optional().describe("Notification threshold in days (default: 10)").default(env.RUNOUT_NOTIFICATION_THRESHOLD_DAYS),
-  fileMetadata: z3.record(z3.string(), z3.string()).optional().describe("Metadata for the file (max 4 key-value pairs)")
+import { z as z4 } from "zod";
+var e2eFileUploadInputSchema = z4.object({
+  filePath: z4.string().describe("Absolute path to the file to upload"),
+  datasetId: z4.string().optional().describe("Existing dataset ID to use"),
+  withCDN: z4.boolean().optional().describe("Enable CDN for faster retrieval").default(false),
+  persistenceDays: z4.number().optional().describe("Storage duration in days (default: 180)").default(env.PERSISTENCE_PERIOD_DAYS),
+  notificationThresholdDays: z4.number().optional().describe("Notification threshold in days (default: 10)").default(env.RUNOUT_NOTIFICATION_THRESHOLD_DAYS),
+  fileMetadata: z4.record(z4.string(), z4.string()).optional().describe("Metadata for the file (max 4 key-value pairs)")
 });
 var checkBalanceStep = createStep({
   id: "checkBalance",
   description: "Check current FIL/USDFC balances and storage metrics",
   inputSchema: e2eFileUploadInputSchema,
-  outputSchema: z3.object({
-    balances: z3.any(),
-    needsPayment: z3.boolean(),
-    depositNeeded: z3.number()
+  outputSchema: z4.object({
+    balances: z4.any(),
+    needsPayment: z4.boolean(),
+    depositNeeded: z4.number()
   }),
   execute: async ({ inputData, runtimeContext }) => {
     console.log("\u{1F4CA} STEP 1: Checking balances and storage metrics...");
@@ -934,16 +1580,16 @@ var checkBalanceStep = createStep({
 var processPaymentStep = createStep({
   id: "processPayment",
   description: "Deposit USDFC if insufficient balance detected",
-  inputSchema: z3.object({
-    balances: z3.any(),
-    needsPayment: z3.boolean(),
-    depositNeeded: z3.number()
+  inputSchema: z4.object({
+    balances: z4.any(),
+    needsPayment: z4.boolean(),
+    depositNeeded: z4.number()
   }),
-  outputSchema: z3.object({
-    skipped: z3.boolean(),
-    txHash: z3.string().optional(),
-    depositAmount: z3.string().optional(),
-    message: z3.string().optional()
+  outputSchema: z4.object({
+    skipped: z4.boolean(),
+    txHash: z4.string().optional(),
+    depositAmount: z4.string().optional(),
+    message: z4.string().optional()
   }),
   execute: async ({ getStepResult, getInitData, runtimeContext }) => {
     const balanceInfo = getStepResult("checkBalance");
@@ -994,18 +1640,18 @@ var processPaymentStep = createStep({
 var uploadFileStep = createStep({
   id: "uploadFile",
   description: "Upload file to Filecoin storage",
-  inputSchema: z3.object({
-    skipped: z3.boolean(),
-    txHash: z3.string().optional(),
-    depositAmount: z3.string().optional(),
-    message: z3.string().optional()
+  inputSchema: z4.object({
+    skipped: z4.boolean(),
+    txHash: z4.string().optional(),
+    depositAmount: z4.string().optional(),
+    message: z4.string().optional()
   }),
-  outputSchema: z3.object({
-    pieceCid: z3.string(),
-    txHash: z3.string().optional(),
-    fileName: z3.string(),
-    fileSize: z3.number(),
-    progressLog: z3.array(z3.string()).optional()
+  outputSchema: z4.object({
+    pieceCid: z4.string(),
+    txHash: z4.string().optional(),
+    fileName: z4.string(),
+    fileSize: z4.number(),
+    progressLog: z4.array(z4.string()).optional()
   }),
   execute: async ({ getInitData, runtimeContext }) => {
     const initData = getInitData();
@@ -1042,19 +1688,19 @@ var uploadFileStep = createStep({
 var summaryStep = createStep({
   id: "summary",
   description: "Generate final summary of the upload process",
-  inputSchema: z3.object({
-    pieceCid: z3.string(),
-    txHash: z3.string().optional(),
-    fileName: z3.string(),
-    fileSize: z3.number(),
-    progressLog: z3.array(z3.string()).optional()
+  inputSchema: z4.object({
+    pieceCid: z4.string(),
+    txHash: z4.string().optional(),
+    fileName: z4.string(),
+    fileSize: z4.number(),
+    progressLog: z4.array(z4.string()).optional()
   }),
-  outputSchema: z3.object({
-    success: z3.boolean(),
-    summary: z3.object({
-      balance: z3.any(),
-      payment: z3.any(),
-      upload: z3.any()
+  outputSchema: z4.object({
+    success: z4.boolean(),
+    summary: z4.object({
+      balance: z4.any(),
+      payment: z4.any(),
+      upload: z4.any()
     })
   }),
   execute: async ({ getStepResult }) => {
@@ -1092,12 +1738,12 @@ var e2eFileUploadWorkflow = createWorkflow({
   id: "e2eFileUpload",
   description: "Upload a file to Filecoin storage",
   inputSchema: e2eFileUploadInputSchema,
-  outputSchema: z3.object({
-    success: z3.boolean(),
-    summary: z3.object({
-      balance: z3.any(),
-      payment: z3.any(),
-      upload: z3.any()
+  outputSchema: z4.object({
+    success: z4.boolean(),
+    summary: z4.object({
+      balance: z4.any(),
+      payment: z4.any(),
+      upload: z4.any()
     })
   })
 }).then(checkBalanceStep).then(processPaymentStep).then(uploadFileStep).then(summaryStep).commit();
@@ -1132,6 +1778,7 @@ DATASET MANAGEMENT:
 
 - Returns: Datasets with piece CIDs, file sizes, provider details, retrieval URLs, blockchain storage proofs
 - Parameters: includeAllDatasets (boolean), filterByCDN (boolean)
+- Progress Tracking: Returns progressLog showing blockchain fetch and metadata processing steps
 - Use when: User wants to inventory files, check storage status, or locate specific uploads
 
 \u2022 getDataset: Retrieve detailed information about a specific dataset by its ID
@@ -1142,18 +1789,24 @@ DATASET MANAGEMENT:
 
 \u2022 createDataset: Create a new dataset container on Filecoin for organizing related files
 
-- Parameters: withCDN (optional), providerId (optional), metadata (up to 10 key-value pairs)
+- Parameters: withCDN (optional), providerId (required), metadata (up to 10 key-value pairs)
 - Purpose: Define storage parameters (CDN, provider selection) that apply to all files added
 - Benefits: Better file organization, consistent retrieval performance
-- Note: Payment is processed automatically for CDN-enabled datasets
+- Note: Payment is processed automatically for CDN-enabled datasets (1 USDFC)
+- Progress Tracking: Returns progressLog showing validation, CDN payment (if applicable), and dataset creation steps
 - Use when: User wants dedicated dataset or specific storage configuration
+- Important: providerId is required - use getProviders to list available providers first
 
 BALANCE & PAYMENT:
 \u2022 getBalances: Check wallet balances (FIL and USDFC tokens) and comprehensive storage metrics
 
 - Returns: Available funds, required deposits, days of storage remaining, allowance status
-- Output: Both human-readable formatted values and raw data
-- Parameters: storageCapacityBytes (optional), persistencePeriodDays (optional), notificationThresholdDays (optional)
+- Output: Both human-readable formatted values and raw data with progress log showing calculation parameters
+- Parameters: storageCapacityBytes (optional, default: 150 GiB), persistencePeriodDays (optional, default: 365 days), notificationThresholdDays (optional, default: 45 days)
+- Progress Log: Shows exact values used for calculations (capacity, persistence period, threshold)
+- \u26A0\uFE0F INSOLVENCY WARNING: Storage providers consider accounts with less than 30 days of remaining balance as INSOLVENT and may refuse service or remove data
+- Safety Margin: Default notification threshold is 45 days to ensure users have time to deposit before hitting the 30-day insolvency threshold
+- Agent Behavior: ALWAYS ask user before calling if they want default calculations or custom requirements. After showing results, ALWAYS offer to recalculate with different parameters. If days remaining is below 45, WARN user immediately about insolvency risk
 - Use when: Before upload operations to verify sufficient balance, or to monitor storage budget and plan deposits
 
 \u2022 processPayment: Deposit USDFC tokens and configure storage service allowances in a single transaction
@@ -1162,8 +1815,17 @@ BALANCE & PAYMENT:
 - Parameters: depositAmount (optional, default: 0)
 - Actions: Sets both rate allowance (per-epoch spending) and lockup allowance (total committed funds) to unlimited
 - Validation: Checks wallet balance before processing to prevent failed transactions
+- Progress Tracking: Returns progressLog showing conversion, transaction initiation, and confirmation steps
 - Use when: User needs to fund storage account before uploads or when balance is insufficient
 
+\u2022 processWithdrawal: Withdraw USDFC tokens from the storage account
+
+- Parameters: withdrawalAmount (optional, default: 0)
+- Actions: Withdraws available funds from storage account back to wallet
+- Reduces storage service allowances and available balance
+- Progress Tracking: Returns progressLog showing conversion, transaction initiation, and confirmation steps
+- Use when: User wants to retrieve unused funds from storage account
+
 PROVIDER MANAGEMENT:
 \u2022 getProviders: List storage providers available on the Filecoin network
 
@@ -1192,7 +1854,9 @@ PROVIDER MANAGEMENT:
 
 5. MONITOR STORAGE METRICS AND PERSISTENCE:
    - Check persistence days remaining regularly
-   - Top up allowances before they run out to avoid service interruption
+   - \u26A0\uFE0F CRITICAL: Maintain at least 45 days of balance (insolvency threshold is 30 days)
+   - Storage providers will refuse service if balance falls below 30 days
+   - Top up allowances before they run out to avoid service interruption and potential data loss
 
 6. VALIDATE FILE PATHS:
    - Ensure filePath is absolute path
@@ -1218,10 +1882,11 @@ FOR DATASET MANAGEMENT:
 
 FOR BALANCE MANAGEMENT:
 
-1. Check Current State: getBalances with includeMetrics
-2. Calculate Needs: Estimate storage requirements
-3. Process Payment: processPayment with appropriate amounts
-4. Verify: Check balances again to confirm deposit
+1. Check Current State: getBalances to view current balances and storage metrics
+2. Evaluate Risk: If days remaining < 45, URGENT deposit needed (< 30 = INSOLVENT)
+3. Calculate Needs: Estimate storage requirements using getBalances output
+4. Process Payment: processPayment with appropriate depositAmount to maintain 45+ day buffer
+5. Verify: Check balances again to confirm deposit and ensure above insolvency threshold
 
 \u{1F4A1} STRATEGIC CONSIDERATIONS:
 
@@ -1243,6 +1908,8 @@ COST MANAGEMENT:
 \u2022 Rate allowance: Controls per-epoch spending
 \u2022 Lockup allowance: Total committed for long-term storage
 \u2022 Monitor both to avoid overspending or service interruption
+\u2022 \u26A0\uFE0F INSOLVENCY THRESHOLD: Keep balance above 30 days minimum (recommend 45+ days)
+\u2022 Providers refuse service below 30 days - plan deposits accordingly
 
 \u{1F6A8} ERROR HANDLING:
 
@@ -1259,7 +1926,8 @@ DURING UPLOAD:
 \u2022 Each phase has status updates
 
 COMMON ERRORS:
-\u2022 "Insufficient tUSDFC balance": Need to deposit more USDFC \u2192 call processPayment
+\u2022 "Insufficient tUSDFC balance": Need to deposit more USDFC \u2192 call processPayment (ensure 45+ days buffer)
+\u2022 "Insolvency detected": Balance below 30 days \u2192 URGENT deposit required, providers may refuse service
 \u2022 "Signer not found": Wallet not connected properly \u2192 check PRIVATE_KEY env var
 \u2022 "Transaction failed": User rejected signature or gas issue \u2192 explain and retry
 \u2022 "Provider connection failed": Try different provider or retry
@@ -1294,12 +1962,14 @@ ERROR RESPONSES:
 \u{1F3AF} AGENT BEHAVIOR GUIDELINES:
 
 1. BE PROACTIVE: Suggest checking balances before uploads
-2. BE CLEAR: Explain blockchain concepts simply
-3. BE PATIENT: Uploads take time (30-60 seconds typical)
-4. BE HELPFUL: Guide users through wallet signatures
-5. BE ACCURATE: Provide precise pieceCids and txHashes
-6. BE EFFICIENT: Reuse datasets when appropriate
-7. BE SECURE: Never store sensitive data without user confirmation
+2. BE VIGILANT: ALWAYS warn if balance days remaining < 45 (insolvency risk at < 30)
+3. BE CLEAR: Explain blockchain concepts simply
+4. BE PATIENT: Uploads take time (30-60 seconds typical)
+5. BE HELPFUL: Guide users through wallet signatures
+6. BE ACCURATE: Provide precise pieceCids and txHashes
+7. BE EFFICIENT: Reuse datasets when appropriate
+8. BE SECURE: Never store sensitive data without user confirmation
+9. BE URGENT: Treat insolvency warnings as critical - emphasize immediate action needed
 
 \u{1F510} SECURITY CONSIDERATIONS:
 \u2022 Never expose private keys or wallet seeds
@@ -1352,7 +2022,7 @@ var focStorageResources = {
 // src/mastra/index.ts
 var mcpServer = new MCPServer({
   name: "FOC Storage MCP",
-  version: "0.1.0",
+  version: "0.1.3",
   description: "Professional-grade MCP server for decentralized file storage on Filecoin Onchain Cloud. Powered by the FOC-Synapse SDK, this server provides AI agents with seamless access to Filecoin's distributed storage network. Upload files with automatic payment handling, organize content in datasets, monitor storage balances, and manage providers - all through intuitive MCP tools. Supports both standard storage and CDN-enabled fast retrieval. Perfect for building AI applications that need persistent, censorship-resistant storage.",
   tools: focStorageTools,
   repository: {