Creating Deposits (Maker Side)

Learn how to create liquidity deposits as a maker in the ZKP2P protocol

As a maker (liquidity provider), you create deposits to offer USDC for purchase in exchange for fiat payments. This guide walks through the process of creating and managing deposits.

Overview

Deposits are created on the Escrow contract and define:

• The amount of USDC available for trading
• Accepted payment methods (Venmo, PayPal, Wise, etc.)
• Supported fiat currencies and minimum conversion rates
• Intent amount limits (min/max per trade)
• Optional access control and delegation

Creating a Deposit

1. Approve token transfer

   First, approve the Escrow contract to transfer USDC on your behalf:

   import { ethers } from "ethers";
   import { Escrow } from "@typechain/Escrow";
   import { ERC20 } from "@typechain/ERC20";
   
   const USDC_ADDRESS = "0x...";
   const ESCROW_ADDRESS = "0x...";
   
   const usdc = new ethers.Contract(USDC_ADDRESS, ERC20_ABI, signer) as ERC20;
   const escrow = new ethers.Contract(ESCROW_ADDRESS, Escrow_ABI, signer) as Escrow;
   
   // Approve escrow to transfer 1000 USDC (6 decimals)
   const amount = ethers.utils.parseUnits("1000", 6);
   await usdc.approve(ESCROW_ADDRESS, amount);
   
2. Prepare payment method configuration

   Define which payment methods you accept and their parameters:

   // Generate payment method hashes
   const venmoHash = ethers.utils.keccak256(
     ethers.utils.toUtf8Bytes("venmo")
   );
   const paypalHash = ethers.utils.keccak256(
     ethers.utils.toUtf8Bytes("paypal")
   );
   
   // Your payment account identifiers (hashed for privacy)
   const venmoPayeeDetails = ethers.utils.keccak256(
     ethers.utils.toUtf8Bytes("your-venmo-username")
   );
   const paypalPayeeDetails = ethers.utils.keccak256(
     ethers.utils.toUtf8Bytes("your-paypal-email")
   );
   
   // Configure payment method data
   const paymentMethods = [venmoHash, paypalHash];
   const paymentMethodData = [
     {
       intentGatingService: "0x...", // Optional: address(0) for no gating
       payeeDetails: venmoPayeeDetails,
       data: "0x" // Additional verification data if needed
     },
     {
       intentGatingService: "0x0000000000000000000000000000000000000000",
       payeeDetails: paypalPayeeDetails,
       data: "0x"
     }
   ];
   
3. Define currency conversion rates

   Set minimum conversion rates for each payment method’s supported currencies:

   // Currency codes (keccak256 hashed)
   const USD = ethers.utils.keccak256(ethers.utils.toUtf8Bytes("USD"));
   const EUR = ethers.utils.keccak256(ethers.utils.toUtf8Bytes("EUR"));
   
   // Conversion rates in 18 decimals (1e18 = 1:1 rate)
   const currencies = [
     // Venmo: support USD only
     [
       {
         code: USD,
         minConversionRate: ethers.utils.parseEther("1.0") // 1 USDC = 1 USD
       }
     ],
     // PayPal: support USD and EUR
     [
       {
         code: USD,
         minConversionRate: ethers.utils.parseEther("1.0")
       },
       {
         code: EUR,
         minConversionRate: ethers.utils.parseEther("0.92") // 1 USDC = 0.92 EUR min
       }
     ]
   ];
   
4. Create the deposit

   Call createDeposit with all parameters:

   const tx = await escrow.createDeposit({
     token: USDC_ADDRESS,
     amount: ethers.utils.parseUnits("1000", 6), // 1000 USDC
     intentAmountRange: {
       min: ethers.utils.parseUnits("10", 6),   // Min 10 USDC per trade
       max: ethers.utils.parseUnits("500", 6)   // Max 500 USDC per trade
     },
     paymentMethods: paymentMethods,
     paymentMethodData: paymentMethodData,
     currencies: currencies,
     delegate: "0x0000000000000000000000000000000000000000", // Optional
     intentGuardian: "0x0000000000000000000000000000000000000000", // Optional
     retainOnEmpty: true // Keep deposit config when funds depleted
   });
   
   const receipt = await tx.wait();
   console.log("Deposit created!", receipt.transactionHash);
   
   // Extract depositId from event
   const event = receipt.events?.find(e => e.event === "DepositReceived");
   const depositId = event?.args?.depositId;
   console.log("Deposit ID:", depositId.toString());
   

Managing Your Deposit

Adding Funds

Add more USDC to an existing deposit:

// Approve additional funds first
await usdc.approve(ESCROW_ADDRESS, ethers.utils.parseUnits("500", 6));

// Add to deposit
await escrow.addFunds(
  depositId,
  ethers.utils.parseUnits("500", 6)
);

Removing Funds

Withdraw available liquidity (automatically prunes expired intents if needed):

await escrow.removeFunds(
  depositId,
  ethers.utils.parseUnits("200", 6)
);

Updating Conversion Rates

Update Single Currency

await escrow.setCurrencyMinRate(
  depositId,
  venmoHash,
  USD,
  ethers.utils.parseEther("1.01") // New rate: 1 USDC = 1.01 USD
);

const GBP = ethers.utils.keccak256(ethers.utils.toUtf8Bytes("GBP"));

await escrow.addCurrencies(
  depositId,
  paypalHash,
  [
    {
      code: GBP,
      minConversionRate: ethers.utils.parseEther("0.79")
    }
  ]
);

Updating Intent Limits

await escrow.setIntentRange(
  depositId,
  {
    min: ethers.utils.parseUnits("20", 6),  // New min: 20 USDC
    max: ethers.utils.parseUnits("1000", 6) // New max: 1000 USDC
  }
);

Pausing/Resuming Intent Acceptance

Pause

// Stop accepting new intents
await escrow.setAcceptingIntents(depositId, false);

// Resume accepting intents (only if sufficient liquidity)
await escrow.setAcceptingIntents(depositId, true);

Managing Payment Methods

Add Payment Method

const zelle = ethers.utils.keccak256(ethers.utils.toUtf8Bytes("zelle"));

await escrow.addPaymentMethods(
  depositId,
  [zelle],
  [{
    intentGatingService: "0x0000000000000000000000000000000000000000",
    payeeDetails: ethers.utils.keccak256(
      ethers.utils.toUtf8Bytes("your-zelle-email")
    ),
    data: "0x"
  }],
  [[
    { code: USD, minConversionRate: ethers.utils.parseEther("1.0") }
  ]]
);

// Deactivate without deleting (existing intents can still be fulfilled)
await escrow.setPaymentMethodActive(depositId, venmoHash, false);

await escrow.setPaymentMethodActive(depositId, venmoHash, true);

Delegation

Delegate deposit management to another address:

Set Delegate

const delegateAddress = "0x...";
await escrow.setDelegate(depositId, delegateAddress);

await escrow.removeDelegate(depositId);

Delegates can perform all deposit management functions except withdrawing funds.

Withdrawing Your Deposit

Fully close a deposit and withdraw all available funds:

// Withdraws all available liquidity
// Prunes expired intents automatically
// Closes deposit if no active intents remain
await escrow.withdrawDeposit(depositId);

If active (non-expired) intents exist, the deposit won’t close completely. Call withdrawDeposit again after intents expire or are fulfilled.

Reading Deposit State

// Get full deposit info
const deposit = await escrow.getDeposit(depositId);
console.log("Depositor:", deposit.depositor);
console.log("Available:", deposit.remainingDeposits.toString());
console.log("Locked in intents:", deposit.outstandingIntentAmount.toString());
console.log("Accepting intents:", deposit.acceptingIntents);

// Get payment methods
const methods = await escrow.getDepositPaymentMethods(depositId);

// Get currencies for a payment method
const venmocurrencies = await escrow.getDepositCurrencies(depositId, venmoHash);

// Get conversion rate for a specific currency
const usdRate = await escrow.getDepositCurrencyMinRate(
  depositId,
  venmoHash,
  USD
);
console.log("Venmo USD rate:", ethers.utils.formatEther(usdRate));

// Check for expired intents
const [expiredHashes, reclaimable] = await escrow.getExpiredIntents(depositId);
console.log("Expired intents:", expiredHashes.length);
console.log("Reclaimable amount:", reclaimable.toString());

Best Practices

Monitor Liquidity

Regularly check remainingDeposits and add funds when low to ensure continuous availability.

Set Competitive Rates

Adjust conversion rates based on market conditions to attract more takers.

Use Reasonable Limits

Set intent amount ranges that balance accessibility with risk tolerance.

Enable Retention

Set retainOnEmpty: true to keep your deposit configuration when funds are depleted.

Contract Reference

See the full Escrow contract interface for all available functions and events.