A Peer.xyz / zkp2p V3 post-intent hook that bridges the deposit token from Base to a SKALE chain through SKALE IMA immediately after an intent is fulfilled on zkp2p.

Post-intent hooks run during fulfillIntent on the OrchestratorV2, after the payment proof has been verified and all fees have been deducted. The flow:

  User → OrchestratorV2 (Base) ─── fulfillIntent ──▶  SkaleBridgeHook (Base)
                                                        │
                                                        │ depositERC20Direct
                                                        ▼
                                                    DepositBoxERC20 (Base)
                                                        │
                                                        │ IMA message
                                                        ▼
                                                    SKALE chain → recipient

At fulfill time the Orchestrator:

1. Computes executableAmount = releaseAmount − fees.
2. Approves the hook to pull exactly executableAmount of the deposit token.
3. Calls hook.execute(ctx, fulfillHookData).
4. Verifies the hook pulled exactly executableAmount and did not send tokens back to the Orchestrator, then resets the allowance to 0.

SkaleBridgeHook uses that allowance to pull the tokens from the Orchestrator, approves the IMA DepositBoxERC20, and calls depositERC20Direct to deliver them to ctx.intent.to on the configured SKALE chain.

See docs.peer.xyz — Post-intent hooks for the full hook lifecycle and invariants.

Implements IPostIntentHookV2 and ISkaleBridgeHook.

Constructor parameters:

Owner-only configuration:

• addTokenToWhitelist(address token) — mark a token as bridgeable by this hook.
• removeTokenFromWhitelist(address token) — revoke a token.

A deposit is allowed if the token is whitelisted on the DepositBoxERC20 for the destination SKALE chain or whitelisted locally on this hook.

contracts/              Solidity sources (Hardhat + Foundry)
  SkaleBridgeHook.sol
  interfaces/
  mocks/                Test-only mock contracts
script/                 Foundry deploy scripts
migrations/             Hardhat deploy scripts (TypeScript)
test/                   Hardhat/Mocha tests (TypeScript)
  utils.ts              Typed deploy helpers shared across test files
foundry-test/           Foundry tests (Solidity)

Both toolchains compile the same source tree but write artifacts to separate folders so they never clobber each other:

# Node / Hardhat toolchain
yarn install

# Foundry toolchain (installs forge-std into lib/)
forge install foundry-rs/forge-std --no-git

Copy .env.example to .env and fill in the deployment variables.

# Hardhat
yarn compile

# Foundry
forge build

yarn lint            # solhint
forge fmt --check

yarn test

Runs TypeScript compilation then the full Mocha suite via Hardhat. Coverage report is generated with:

yarn hardhat coverage

forge test -vvv

Deploy-script tests live in foundry-test/ and are executed as part of the normal forge test run — no separate step is needed.

Set environment variables (see .env.example):

yarn hardhat run migrations/deploySkaleBridgeHook.ts --network custom

forge script script/DeploySkaleBridgeHook.s.sol:DeploySkaleBridgeHook \
  --rpc-url "$ENDPOINT" \
  --private-key "$PRIVATE_KEY" \
  --broadcast \
  -vvvv

Pass the deployed hook address as postIntentHook when signaling an intent:

await orchestrator.signalIntent({
  escrow,
  depositId,
  amount,
  to,                                    // default recipient on SKALE
  paymentMethod,
  fiatCurrency,
  conversionRate,
  referralFees: [],
  gatingServiceSignature,
  signatureExpiration,
  postIntentHook: skaleBridgeHookAddress,
  preIntentHookData: "0x",
  data: "0x",                            // signalHookData (unused by this hook)
});

At fulfill time, this hook always bridges to ctx.intent.to.

Always re-verify the IMA and zkp2p addresses against their official docs before deploying.

MIT

Post-intent hook for Peer.xyz/zkp2p that automatically bridges USDC from Base to SKALE Base when users onramp.

User → zkp2p (Base) → SkaleBridgeHook → IMA Message → SkaleReceiver (SKALE Base) → User

• Post-intent hook implementing IPostIntentHookV2
• Receives USDC from zkp2p Orchestrator after intent fulfillment
• Sends IMA message to SKALE Base
• Locks tokens for liquidity-based bridging

• Receives IMA messages from Base
• Releases mapped USDC to recipients
• Must be registered with SKALE's MessageProxy

# Install dependencies

# Deploy to Base Sepolia


# Deploy to SKALE Base Sepolia

# Deploy to Base


# Deploy to SKALE Base

After deploying SkaleReceiver, register it with SKALE's MessageProxy:

cast send 0xd2AAa00100000000000000000000000000000000 \
  "grantRole(bytes32,address)" \
  0x96e3fc3be15159903e053027cff8a23f39a990e0194abcd8ac1cf1b355b8b93c \
  <RECEIVER_ADDRESS> \
  --rpc-url <SKALE_RPC>

import { OrchestratorV2 } from "@peerxyz/orchestrator";

await orchestrator.signalIntent({
  escrow: escrowAddress,
  depositId: depositId,
  amount: amount,
  to: recipientAddress,
  paymentMethod: keccak256("card"),
  postIntentHook: hookAddress, // SkaleBridgeHook address
  data: "0x" // Can pass arbitrary bytes, but currently unused by Skale
});

The SkaleReceiver contract needs to be funded with mapped USDC to release to recipients:

SKALE's native DepositBox is designed for Ethereum → SKALE bridging. For Base → SKALE, this implementation uses:

1. IMA Messaging: Cross-chain communication between Base and SKALE Base
2. Liquidity Model: Tokens locked on Base, released from pre-funded liquidity on SKALE Base

1. Verify if MessageProxy exists on Base for direct IMA communication
2. Find actual DepositBox address on Base (if exists)
3. Confirm SKALE Base mainnet USDC address
4. Set up automated liquidity management for SkaleReceiver

MIT