Payment Treasury Flow

import { CAMPAIGN_INFO_FACTORY_EVENTS } from "@oaknetwork/contracts-sdk";

const platformHash = keccak256(toHex("celomarket"));
const identifierHash = keccak256(toHex("celomarket-storefront-2026"));
const currency = toHex("USD", { size: 32 });
const now = getCurrentTimestamp();

const txHash = await factory.createCampaign({
  creator: process.env.CELOMARKET_ADMIN_ADDRESS! as `0x${string}`,
  identifierHash,
  selectedPlatformHash: [platformHash],
  campaignData: {
    launchTime: now,
    deadline: addDays(now, 365),    // storefront open for 1 year
    goalAmount: 0n,                 // no funding goal for e-commerce
    currency,
  },
  nftName: "CeloMarket Receipts",
  nftSymbol: "CMR",
  nftImageURI: "ipfs://QmXyz.../celomarket-receipt.png",
  contractURI: "ipfs://QmXyz.../metadata.json",
});

const receipt = await oak.waitForReceipt(txHash);

let campaignInfoAddress: `0x${string}` | undefined;

for (const log of receipt.logs) {
  try {
    const decoded = factory.events.decodeLog({
      topics: log.topics as [`0x${string}`, ...`0x${string}`[]],
      data: log.data as `0x${string}`,
    });

    if (decoded.eventName === CAMPAIGN_INFO_FACTORY_EVENTS.CampaignCreated) {
      campaignInfoAddress = decoded.args?.campaignInfoAddress as `0x${string}`;
      break;
    }
  } catch {
    // Log belongs to a different contract — skip
  }
}

console.log("CampaignInfo (from receipt):", campaignInfoAddress);

const lookedUp = await factory.identifierToCampaignInfo(identifierHash);
console.log("CampaignInfo (from lookup):", lookedUp);

import { TREASURY_FACTORY_EVENTS } from "@oaknetwork/contracts-sdk";

const platformHash = keccak256(toHex("celomarket"));
const paymentTreasuryImplementationId = 2n;

const deployTxHash = await treasuryFactory.deploy(
  platformHash,
  campaignInfoAddress,
  paymentTreasuryImplementationId,
);

const deployReceipt = await oak.waitForReceipt(deployTxHash);

// Decode the TreasuryDeployed event from the receipt
let treasuryAddress: `0x${string}` | undefined;

for (const log of deployReceipt.logs) {
  try {
    const decoded = treasuryFactory.events.decodeLog({
      topics: log.topics as [`0x${string}`, ...`0x${string}`[]],
      data: log.data as `0x${string}`,
    });

    if (decoded.eventName === TREASURY_FACTORY_EVENTS.TreasuryDeployed) {
      treasuryAddress = decoded.args?.treasuryAddress as `0x${string}`;
      break;
    }
  } catch {
    // Log belongs to a different contract — skip
  }
}

console.log("PaymentTreasury deployed at:", treasuryAddress);

const paymentId = keccak256(toHex("order-12345"));
const buyerId = keccak256(toHex("sam-user-id"));
const itemId = keccak256(toHex("handcrafted-vase-001"));
const paymentToken = process.env.USDC_TOKEN_ADDRESS! as `0x${string}`;
const totalAmount = 135_000_000n; // $135 (product + shipping)
const expiration = BigInt(Math.floor(Date.now() / 1000)) + 86400n; // 24 hours

const lineItems: LineItem[] = [
  { typeId: keccak256(toHex("product")),  amount: 120_000_000n }, // $120
  { typeId: keccak256(toHex("shipping")), amount: 15_000_000n },  // $15
];

const externalFees: ExternalFees[] = [
  { feeType: keccak256(toHex("payment-processor")), feeAmount: 2_700_000n }, // $2.70
];

await paymentTreasury.createPayment(
  paymentId, buyerId, itemId, paymentToken,
  totalAmount, expiration, lineItems, externalFees,
);

const paymentId = keccak256(toHex("order-12345"));
const paymentToken = process.env.USDC_TOKEN_ADDRESS! as `0x${string}`;

// Prerequisite: Sam has approved the treasury to spend his USDC
const cryptoPaymentTxHash = await paymentTreasury.processCryptoPayment(
  paymentId,
  itemId,
  process.env.SAM_ADDRESS! as `0x${string}`,
  paymentToken,
  135_000_000n,
  lineItems,
  externalFees,
);

const paymentId = keccak256(toHex("order-12345"));

await paymentTreasury.confirmPayment(
  paymentId,
  process.env.SAM_ADDRESS! as `0x${string}`,
);

const paymentData = await paymentTreasury.getPaymentData(paymentId);
console.log("Buyer:", paymentData.buyerAddress);
console.log("Confirmed:", paymentData.isConfirmed);
console.log("Is crypto payment:", paymentData.isCryptoPayment);

const raised = await paymentTreasury.getRaisedAmount();
const available = await paymentTreasury.getAvailableRaisedAmount();
const expected = await paymentTreasury.getExpectedAmount();
const refunded = await paymentTreasury.getRefundedAmount();

// Path C: crypto payment refund (NFT owner)
// Approve the treasury on CampaignInfo where the NFT lives
const approveTxHash = await samCampaign.approve(treasuryAddress, tokenId);
await samOak.waitForReceipt(approveTxHash);

const selfRefundTxHash = await samTreasury.claimRefundSelf(paymentId);
await samOak.waitForReceipt(selfRefundTxHash);

const feeTxHash = await paymentTreasury.disburseFees();
await oak.waitForReceipt(feeTxHash);

const withdrawTxHash = await paymentTreasury.withdraw();
await oak.waitForReceipt(withdrawTxHash);

const claimTxHash = await paymentTreasury.claimExpiredFunds();

const usdcToken = process.env.USDC_TOKEN_ADDRESS! as `0x${string}`;
await paymentTreasury.claimNonGoalLineItems(usdcToken);

await paymentTreasury.pauseTreasury(keccak256(toHex("fraud-investigation")));
// ... later ...
await paymentTreasury.unpauseTreasury(keccak256(toHex("investigation-cleared")));

await paymentTreasury.cancelTreasury(keccak256(toHex("terms-violation")));