@b3dotfun/p2pswap

P2P Swap SDK

A TypeScript SDK for peer-to-peer asset swaps on EVM-compatible networks. Enables direct and open-ended swaps of ERC20, ERC721, and ERC1155 tokens.

Installation

npm install @b3dotfun/p2pswap

Features

• Direct Swaps: Specify exact assets to offer and request
• Open Swaps: Post available assets and receive multiple offers
• Multi-Asset Support: Combine different token types in a single swap
• Cross-Chain Compatible: Works with any EVM-compatible network
• Type Safety: Full TypeScript support

Swap Workflows

Direct Swap Workflow

Direct swap enables a specific asset-for-asset exchange between two parties:

• Initiator (User A)

  • Specifies offered assets (ERC20/721/1155)
  • Specifies requested assets
  • Sets deadline
  • Optionally specifies target user address

• Responder (User B)

  • Views swap details
  • Provides exact requested assets
  • Accepts the swap

• Contract Actions

  • Validates assets and permissions
  • Transfers offered assets to contract (on propose)
  • Transfers requested assets to initiator (on accept)
  • Transfers offered assets to responder (on accept)

sequenceDiagram
    participant A as User A
    participant C as Contract
    participant B as User B
    
    A->>C: proposeDirectSwap(offered, requested)
    Note over C: Hold offered assets
    B->>C: acceptDirectSwap(swapId)
    C->>A: Transfer requested assets
    C->>B: Transfer offered assets

Open Swap Workflow

Open swap allows multiple users to make different offers for posted assets:

• Initiator (User A)

  • Posts available assets
  • Sets deadline
  • Reviews incoming offers
  • Accepts preferred offer

• Potential Buyers (Users B, C, ...)

  • View available swaps
  • Make offers with their assets
  • Can cancel offers before acceptance
  • Multiple offers can exist simultaneously

• Contract Actions

  • Holds initiator's assets
  • Holds all offer assets
  • Executes transfer on acceptance
  • Returns assets on cancellation

sequenceDiagram
    participant A as User A
    participant C as Contract
    participant B as User B
    participant D as User C
    
    A->>C: proposeOpenSwap(assets)
    Note over C: Hold A's assets
    B->>C: makeOffer(swapId, assets1)
    Note over C: Hold B's assets
    D->>C: makeOffer(swapId, assets2)
    Note over C: Hold C's assets
    A->>C: acceptOffer(swapId, offerId)
    C->>A: Transfer offered assets
    C->>B: Transfer posted assets
    Note over C: Return assets to User C

Usage

Direct Swap

import { createPublicClient, createWalletClient, http } from 'viem';
import { b3 } from 'viem/chains';
import { SwapSDK } from '@b3dotfun/p2pswap';

const sdk = new SwapSDK({
  contractAddress: '0x...',
  publicClient,
  walletClient
});

// User A: Propose a swap
const { swapId } = await sdk.direct.proposeDirectSwap(
  [{ // Offered assets
    tokenAddress: '0x...',
    amount: 1000000000000000000n,
    tokenType: 'ERC20'
  }],
  [{ // Requested assets
    tokenAddress: '0x...',
    tokenId: 123n,
    tokenType: 'ERC721'
  }],
  deadline
);

// User B: Accept the swap
await sdk.direct.acceptDirectSwap(swapId, requestedAssets);

Open Swap

The Open Swap feature allows users to:

• Post assets without specifying what they want in return
• Receive multiple offers from different users
• Choose which offer to accept

import { createPublicClient, createWalletClient, http } from 'viem';
import { mainnet } from 'viem/chains';
import { SwapSDK } from '@b3dotfun/p2pswap';

const sdk = new SwapSDK({
  contractAddress: '0x...',
  publicClient,
  walletClient
});

// User A: Create open swap
const { swapId } = await sdk.open.proposeOpenSwap(
  [{ // Available assets
    tokenAddress: '0x...',
    tokenId: 456n,
    tokenType: 'ERC721'
  }],
  deadline
);

// User B: View available swaps and make an offer
const { offerId } = await sdk.open.makeOfferForOpenSwap(
  swapId,
  [{ // Offered assets
    tokenAddress: '0x...',
    amount: 5000000000000000000n,
    tokenType: 'ERC20'
  }]
);

// User C: Make another offer for the same swap
const { offerId: secondOfferId } = await sdk.open.makeOfferForOpenSwap(
  swapId,
  [{ // Different offer
    tokenAddress: '0x...',
    tokenId: 789n,
    tokenType: 'ERC721'
  }]
);

// User A: View all offers for their swap
const offers = await sdk.open.getSwapOffers(swapId);

// User A: Accept their preferred offer
await sdk.open.acceptOffer(swapId, offerId);

// User C: Cancel their offer if not accepted
await sdk.open.cancelOffer(swapId, secondOfferId);

// User A: Cancel the entire swap if needed
await sdk.open.cancelOpenSwap(swapId);

Open Swap Features

• Multiple Offers: Receive various offers for your assets
• Offer Management: View, accept, or cancel offers
• Flexible Assets: Accept any combination of ERC20/ERC721/ERC1155 tokens
• Deadline Control: Set expiration time for the swap
• Event Notifications: Track swap and offer status through events

Supported Networks

Compatible with all EVM-based networks including:

• Ethereum
• BNB Chain
• Arbitrum
• Optimism
• Polygon
• Avalanche
• And other EVM-compatible chains

Documentation

For detailed documentation, visit docs.b3.fun

License

MIT