Troubleshooting Guide

func.skip = async (hre: HardhatRuntimeEnvironment): Promise<boolean> => {
  const network = hre.network.name;
  if (network === "localhost" || network === "hardhat") {
    return false;
  }
  return true; // Frozen for production networks
};

// Check if payment method is registered
const isRegistered = await unifiedVerifier.isPaymentMethod(paymentMethodHash);

if (!isRegistered) {
  // Register payment method (owner only)
  await unifiedVerifier.addPaymentMethod(paymentMethodHash);
}

// Verify intent snapshot
const intent = await orchestrator.getIntent(intentHash);

// All these must match:
assert(snapshot.intentHash === intentHash);
assert(snapshot.payeeDetails === intent.payeeId);
assert(snapshot.amount === intent.amount);
assert(snapshot.paymentMethod === intent.paymentMethod);
assert(snapshot.fiatCurrency === intent.fiatCurrency);
assert(snapshot.conversionRate === intent.conversionRate);
assert(snapshot.signalTimestamp === intent.timestamp);

const MAX_TIMESTAMP_BUFFER_MS = 48 * 60 * 60 * 1000; // 48 hours
assert(snapshot.timestampBuffer <= MAX_TIMESTAMP_BUFFER_MS);

// Recompute data hash
const dataHash = ethers.utils.keccak256(attestation.data);

// Update attestation
attestation.dataHash = dataHash;

// Add payment method to registry (owner only)
await paymentVerifierRegistry.addPaymentMethod(
  paymentMethodHash,
  unifiedVerifierAddress,
  [Currency.USD, Currency.EUR] // Supported currencies
);

// Check available deposit amount
const deposit = await escrow.getDeposit(depositId);
const available = deposit.availableAmount;

if (intentAmount > available) {
  // Reduce intent amount or choose different deposit
}

// Check minimum amount for payment method
const minAmount = await escrow.getMinAmount(depositId, paymentMethodHash);

if (intentAmount < minAmount) {
  // Increase intent amount
}

// Check deposit expiry
const deposit = await escrow.getDeposit(depositId);
const currentTime = Math.floor(Date.now() / 1000);

if (currentTime > deposit.expiryTimestamp) {
  // Deposit has expired, choose another
}

// If orchestrator requires gating signature
const gatingSignature = await generateGatingServiceSignature(
  gatingServiceWallet,
  intentOwner,
  escrowAddress,
  depositId,
  // ... other params
);

await orchestrator.signalIntent({
  // ... intent params
}, gatingSignature); // Include signature

// Check intent expiry
const intent = await orchestrator.getIntent(intentHash);
const currentTime = Math.floor(Date.now() / 1000);

if (currentTime > intent.expiryTimestamp) {
  // Intent has expired, must cancel instead
  await orchestrator.cancelIntent(intentHash);
}

// Intent must be in SIGNALED state
const intent = await orchestrator.getIntent(intentHash);
const IntentState = {
  NONE: 0,
  SIGNALED: 1,
  FULFILLED: 2,
  CANCELLED: 3
};

assert(intent.state === IntentState.SIGNALED);

const intent = await orchestrator.getIntent(intentHash);
const currentTime = Math.floor(Date.now() / 1000);

if (currentTime <= intent.expiryTimestamp) {
  // Wait until expiry before canceling
  const waitTime = intent.expiryTimestamp - currentTime;
  console.log(`Wait ${waitTime} seconds before canceling`);
}

// Example: Configure mock USDC
usdcToken = await deployer.deployUSDCMock(
  ethers.utils.parseUnits("1000000", 6),
  "USDC",
  "USDC"
);

// Transfer to test accounts
await usdcToken.transfer(maker.address, depositAmount);
await usdcToken.connect(maker.wallet).approve(escrow.address, depositAmount);

# Full rebuild
yarn build

# Or just regenerate types
yarn compile
yarn typechain

import { getDeployedContractAddress } from "./deployments/helpers";

const orchestratorAddress = getDeployedContractAddress(
  network,
  "Orchestrator"
);

// Listen for IntentSignaled event
const filter = orchestrator.filters.IntentSignaled();
const events = await orchestrator.queryFilter(filter, fromBlock, toBlock);

events.forEach(event => {
  const { intentHash, escrow, depositId } = event.args;
  console.log(`Intent ${intentHash} signaled`);
});

// Check current owner
const owner = await paymentVerifierRegistry.owner();

// Transfer ownership if needed (current owner only)
await paymentVerifierRegistry.transferOwnership(newOwner);

// Grant write permission (owner only)
await nullifierRegistry.addWritePermission(unifiedVerifierAddress);

// Check current gas price
const gasPrice = await ethers.provider.getGasPrice();
console.log(`Current gas price: ${ethers.utils.formatUnits(gasPrice, "gwei")} gwei`);

// Exponential backoff retry
const retry = async (fn, retries = 3) => {
  for (let i = 0; i < retries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (i === retries - 1) throw error;
      await new Promise(resolve => setTimeout(resolve, 1000 * Math.pow(2, i)));
    }
  }
};

const usdcMock = await deployer.deployUSDCMock(
  ethers.utils.parseUnits("1000000", 6),
  "USDC",
  "USDC"
);

{
  "compilerOptions": {
    "paths": {
      "@utils/*": ["./utils/*"],
      "@typechain/*": ["./typechain/*"]
    }
  }
}