Troubleshooting

// Check resolution status
(bool resolved, uint256 outcome, uint256 confidence, uint256 timestamp) =
    delphaiOracle.getResolution(marketId);

if (!resolved) {
    // Check if resolution time has passed
    uint256 resolutionTime = delphaiOracle.getResolutionTime(marketId);
    require(block.timestamp >= resolutionTime, "Too early");

    // If more than 1 hour late, contact support
    if (block.timestamp > resolutionTime + 1 hours) {
        // Implement fallback or emergency resolution
    }
}

"Check if Bitcoin price is high by end of year"

"Use CoinGecko API endpoint /api/v3/simple/price?ids=bitcoin
Check BTC price at 2025-12-31 23:59:59 UTC
If price >= $100,000 → YES
If price < $100,000 → NO
Backup: CoinMarketCap if CoinGecko down"

// Check resolution details
const resolution = await oracle.getResolution(marketId);
const proof = await oracle.getProof(marketId);

console.log('Confidence:', resolution.confidence);
console.log('Proof:', ethers.utils.toUtf8String(proof));

// Proof shows what data sources were queried and why confidence is low

Primary: CoinGecko API
Backup: CoinMarketCap API
Tertiary: Binance API
Fallback: Delay 1 hour and retry

# Test if API is reachable
curl "https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd"

// Get resolution proof
bytes memory proof = delphaiOracle.getProof(marketId);

// Get attestation
(bytes memory attestation, bytes32 codeHash, address teeAddress) =
    delphaiOracle.getAttestation(marketId);

// Proof contains:
// - Data sources queried
// - Raw data received
// - Resolution logic applied
// - Timestamps

// ✅ 1. Does your contract implement the interface?
contract MyMarket is IPlatformCallback {
    // ...
}

// ✅ 2. Is the function marked external?
function resolveMarket(
    uint256 marketId,
    uint256 outcome,
    bytes memory attestation,
    bytes memory proof
) external override {  // Must be external
    // ...
}

// ✅ 3. Does it have correct access control?
function resolveMarket(...) external {
    // Should only check it's from oracle
    require(msg.sender == delphaiOracle, "Only oracle");
    // Don't add other restrictions that might block it
}

// ✅ 4. Does callback revert?
function resolveMarket(...) external {
    // Avoid require() that might fail
    require(markets[marketId].exists, "Market not found"); // Could fail!

    // Use try-catch or check conditions first
    if (!markets[marketId].exists) return;
}

// Test callback directly on testnet
const platformContract = await ethers.getContractAt("MyMarket", address);

// Call resolveMarket manually to test
await platformContract.resolveMarket(
    marketId,
    1, // outcome
    "0x", // attestation (empty for test)
    "0x"  // proof (empty for test)
);

// Should update market state without reverting

// Listen for ResolutionCallbackFailed event
oracle.on('ResolutionCallbackFailed', (marketId, platform, reason) => {
    console.error('Callback failed!');
    console.error('Market:', marketId.toString());
    console.error('Reason:', ethers.utils.toUtf8String(reason));
});

// Check if code hash is approved
bytes32 codeHash = extractCodeHash(attestation);

if (!approvedCodeHashes[codeHash]) {
    // Add to approved hashes
    approvedCodeHashes[codeHash] = true;

    // Or get approved hashes from oracle
    require(
        delphaiOracle.isApprovedCodeHash(codeHash),
        "Unknown AI version"
    );
}

// Check attestation timestamp
uint256 attestationTime = extractTimestamp(attestation);
require(
    block.timestamp - attestationTime <= 1 hours,
    "Attestation too old"
);

// Use correct TEE verification library
import "@delphai/contracts/TEEVerifier.sol";

function verifyAttestation(bytes memory attestation)
    internal
    view
    returns (bool)
{
    return TEEVerifier.verify(attestation);
}

// Check TEE address
(, , address teeAddress) = delphaiOracle.getAttestation(marketId);
require(
    delphaiOracle.isAuthorizedTEE(teeAddress),
    "Unauthorized TEE"
);

// Test attestation verification
const attestation = await oracle.getAttestation(marketId);
const isValid = await TEEVerifier.verify(attestation.attestation);
console.log('Attestation valid:', isValid);

// ❌ Expensive: Store full strings
struct Market {
    string question;
    string criteria;
}

// ✅ Efficient: Store hashes
struct Market {
    bytes32 questionHash;
    bytes32 criteriaHash;
}

function resolveMarket(...) external {
    // ✅ Simple: Just update state
    markets[marketId].resolved = true;
    markets[marketId].outcome = outcome;

    // ❌ Expensive: Complex calculations
    // Do these in separate user-triggered transactions
    // calculateAndDistributeWinnings(marketId);
}

// If resolving multiple markets, batch them
function resolveMarkets(
    uint256[] memory marketIds,
    uint256[] memory outcomes,
    bytes[] memory attestations
) external {
    for (uint i = 0; i < marketIds.length; i++) {
        _resolveMarket(marketIds[i], outcomes[i], attestations[i]);
    }
}

// Store minimal data onchain
markets[marketId].outcome = outcome;

// Emit detailed data in events (cheaper)
emit MarketResolved(marketId, outcome, attestation, proof);

constructor(address _oracle) {
    require(_oracle != address(0), "Invalid oracle");
    delphaiOracle = _oracle;
}

// Must implement IPlatformCallback
contract MyMarket is IPlatformCallback {
    function resolveMarket(...) external override {
        // Implementation
    }
}

# Check contract size
forge build --sizes

# If too large, optimize:
# - Remove unused functions
# - Use libraries for common code
# - Enable optimizer

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

// Send with higher gas if needed
const tx = await oracle.requestResolution(..., {
    gasPrice: gasPrice.mul(120).div(100) // 20% higher
});

// Replace transaction with higher gas
const newTx = await signer.sendTransaction({
    ...originalTx,
    nonce: originalTx.nonce, // Same nonce
    gasPrice: higherGasPrice  // Higher gas
});

// Send 0 ETH to yourself with same nonce but higher gas
await signer.sendTransaction({
    to: signer.address,
    value: 0,
    nonce: stuckTx.nonce,
    gasPrice: higherGasPrice
});

// Use multiple providers as fallback
const providers = [
    new ethers.providers.JsonRpcProvider('https://eth-mainnet.alchemyapi.io/...'),
    new ethers.providers.JsonRpcProvider('https://mainnet.infura.io/...'),
    new ethers.providers.JsonRpcProvider('https://eth-mainnet.public.blastapi.io')
];

// Fallback provider
const provider = new ethers.providers.FallbackProvider(providers);

async function callWithRetry(fn, retries = 3) {
    for (let i = 0; i < retries; i++) {
        try {
            return await fn();
        } catch (error) {
            if (i === retries - 1) throw error;
            await sleep(1000 * Math.pow(2, i)); // Exponential backoff
        }
    }
}

// Usage
const resolution = await callWithRetry(() =>
    oracle.getResolution(marketId)
);