Smart accounts, session keys, gasless Permit2 approvals, batch execution, and EIP-7702 delegation — all from one SDK. Same contract addresses on every chain.
<!-- Drop this into any HTML page -->
<script src="https://yourdomain.com/sdk/dist/script.js"></script>
<!-- Or self-host from the repo -->
<script src="./dist/script.js"></script>// Import directly from the SDK source
import { initSDK, loadContract, writeContract } from "./sdk/index.js";
const { wallet } = initSDK({
projectId: "YOUR_WALLETCONNECT_PROJECT_ID",
chains: [1, 56, 137, 42161, 8453],
});
const { account } = await wallet.connect();
const signer = await wallet.getSigner();
const contract = loadContract("0x...", abi, signer);
await writeContract(contract, "mint", [account, 1000n]);Everything you need to ship Web3 products — from smart accounts to gasless UX.
Deploy smart wallets via CREATE2 — deterministic addresses across all chains. ERC-4337 compatible with the Factory and Stage modules.
On-chain session key validation with contract/function allowlists and spending limits. Users sign once — your app acts within those bounds.
Permit2 and ERC-2612 executors collect token approvals without users paying gas. Backend sponsorship submits transactions on their behalf.
Bundle any number of reads or writes into a single transaction via Multicall3 and BatchMulticall with per-call ETH forwarding.
Turn any existing EOA into a smart account without deploying a new wallet. Users keep their address — gain smart account features.
Same contract addresses on Ethereum, BSC, Polygon, Avalanche, Arbitrum, Base, and Optimism. Deploy once, work everywhere.
CREATE2 deployed — identical addresses on every EVM chain. Fully verified on Etherscan.
| Contract | Address | Purpose |
|---|---|---|
Factory |
0x653c…ceF | Smart account deployment via CREATE2 |
ERC4337FactoryWrapper |
0xC67c…1ff9 | ERC-4337 UserOp account factory |
SessionManager |
0x4AE4…5cb | On-chain session key validation |
BatchMulticall |
0xF93E…54D | Batch execution with per-call ETH |
Permit2Executor |
0x4593…773 | Gasless Permit2 token collection |
ERC2612Executor |
0xb8eF…900 | ERC-2612 permit + collection |
EIP7702Module |
0x1f82…E5d | EOA → smart account delegation |
Stage1Module |
0xfBC5…99f4 | Initial account logic module |
Stage2Module |
0x5C9C…94f | Upgraded account logic module |
Guest |
0x2d21…0Ee6 | Gasless guest session entry |
Import only what you need. Every module works standalone or composed together.
WalletConnect v2 / Reown AppKit integration. Connect, disconnect, switch chains — event-driven.
await wallet.connect();
Load any contract by address + ABI. Read/write with event bus, transaction previews, and error handling.
await writeContract(c, "mint", [to, amt]);
Gasless ERC-20 approvals via EIP-712 signed messages. Single or batch permits with MAX defaults.
await signPermitSingle(provider, acct, 1, permit);
Batch reads and writes into a single RPC call. Supports per-call ETH value via BatchMulticall.
await multicallWrite(signer, calls);
EIP-712 typed data construction and signing. Domain builders, type encoders, signature splitting.
await signTypedData(provider, acct, data);
Chain info, address validation, amount parsing, explorer URLs, deadlines — zero-dependency helpers.
getExplorerUrl(137, addr);
Read, write, and listen to events on any EVM contract — with automatic previews and error handling.
import { loadContract, readContract } from "@integrateddex/waas-sdk";
const token = loadContract(tokenAddr, erc20Abi, provider);
const balance = await readContract(token, "balanceOf", [account]);
const symbol = await readContract(token, "symbol");import { loadContract, writeContract } from "@integrateddex/waas-sdk";
const signer = await wallet.getSigner();
const nft = loadContract(nftAddr, nftAbi, signer);
// Transaction preview logged before signing
const receipt = await writeContract(nft, "mint", [to, tokenId]);import { multicallWrite, buildCall } from "@integrateddex/waas-sdk";
const calls = [
buildCall(tokenA, approveData),
buildCall(router, swapData),
buildCall(vault, depositData),
];
// One transaction — three operations
await multicallWrite(signer, calls);import { contractEvents } from "@integrateddex/waas-sdk";
contractEvents.on("contractCallSuccess", (detail) => {
console.log(`✅ ${detail.functionName}`, detail.txHash);
});
contractEvents.on("contractCallError", (detail) => {
console.error(`❌ ${detail.functionName}`, detail.error);
});Pay gas on behalf of your users. Estimate costs, submit sponsored transactions, monitor balance.
Get gas cost estimates before submitting. Know exactly what a sponsored transaction will cost you.
Submit sponsored transactions from your backend wallet. Users never see gas prompts.
Track your sponsor wallet balance across chains. Set up alerts when running low.
Users sign once. Your app transacts within scoped permissions — contracts, functions, spending limits, and expiry.
Restrict session keys to specific contracts and function signatures.
Cap the total value a session key can spend — in ETH or any ERC-20.
Sessions auto-expire. Revoke any session instantly from the backend.
The SessionManager contract validates every session key usage on-chain.
// 1. Create a session key with scoped permissions
const session = {
id: crypto.randomUUID(),
userAddress: account,
sessionKey: sessionKeyPair.address,
allowedContracts: ["0xF93E...54D"],
allowedFunctions: ["batch", "batchStatic"],
spendingLimit: "1000000000000000000", // 1 ETH
expiresAt: Math.floor(Date.now() / 1000) + 86400, // 24 hours
chainId: 1,
};
// 2. Register on-chain via SessionManager
await writeContract(sessionManager, "registerSession", [session]);
// 3. Your app uses the session key for subsequent transactions
await writeContract(contract, "executeWithSession", [sessionId, calldata]);Fastify + MongoDB + Telegram alerts. Deploy with Docker in minutes.
/api/sessions/api/sessions/active/api/sessions/address/:addr/api/sessions/:id/api/transactions/api/transactions/api/transactions/address/:addr/api/transactions/tx/:hash/api/sponsor/estimate/api/sponsor/submit/api/sponsor/balance/api/health/api/analytics/api/webhooknpm install @integrateddex/waas-sdk ethersimport { initSDK } from "@integrateddex/waas-sdk";
const { wallet } = initSDK({ projectId: "...", chains: [1, 137] });
await wallet.connect();import { loadContract, writeContract, CONTRACTS } from "@integrateddex/waas-sdk";
const signer = await wallet.getSigner();
const factory = loadContract(CONTRACTS.Factory.address, CONTRACTS.Factory.abi, signer);
await writeContract(factory, "deploy", [owner, salt]);cd backend && docker compose up -dOpen-source wallet infrastructure. No vendor lock-in. No token gates. Just code.