@lumiapassport/core 1.12.0 → 1.13.0

package/README.md

@@ -170,6 +170,183 @@ wallets.forEach(w => {
 
 **See [Server Wallets Documentation](../../docs/SERVER_WALLETS.md) for complete guide.**
 
+### Smart Contract Interactions
+
+The SDK provides utilities for encoding smart contract calls for use with `sendUserOperation()`.
+
+#### ERC20 Token Transfer
+
+```typescript
+import {
+  createServerWalletManager,
+  MemoryKeyshareStorage,
+  encodeERC20Transfer,
+} from '@lumiapassport/core';
+
+const manager = createServerWalletManager({
+  apiKey: process.env.LUMIA_PASSPORT_API_KEY!,
+  storage: new MemoryKeyshareStorage(),
+});
+
+const wallet = await manager.getWallet('treasury_main');
+
+// Encode ERC20 transfer call
+const callData = await encodeERC20Transfer(
+  '0xRecipientAddress...',
+  1000n * 10n ** 18n  // 1000 tokens (18 decimals)
+);
+
+// Send the transaction
+const userOpHash = await wallet.sendUserOperation(
+  '0xTokenContractAddress...',  // to = token contract
+  '0',                          // value = 0 (no native token)
+  callData,                     // encoded transfer call
+  'standard'
+);
+
+// Wait for confirmation
+const receipt = await manager.waitForUserOperationReceipt(userOpHash);
+console.log('Transaction hash:', receipt.transactionHash);
+```
+
+#### ERC20 Approve + TransferFrom Pattern
+
+```typescript
+import { encodeERC20Approve } from '@lumiapassport/core';
+
+// Step 1: Approve DEX router to spend tokens
+const approveData = await encodeERC20Approve(
+  '0xDEXRouterAddress...',
+  2n ** 256n - 1n  // MaxUint256 for unlimited approval
+);
+
+await wallet.sendUserOperation(
+  '0xTokenContractAddress...',
+  '0',
+  approveData,
+  'standard'
+);
+```
+
+#### Arbitrary Contract Call
+
+For any smart contract method, use `encodeContractCall()`:
+
+```typescript
+import { encodeContractCall } from '@lumiapassport/core';
+
+// Define ABI for the function you want to call
+const stakingAbi = [
+  {
+    type: 'function',
+    name: 'stake',
+    stateMutability: 'nonpayable',
+    inputs: [
+      { name: 'amount', type: 'uint256' },
+      { name: 'lockPeriod', type: 'uint256' },
+    ],
+    outputs: [],
+  },
+] as const;
+
+// Encode the call
+const callData = await encodeContractCall(
+  stakingAbi,
+  'stake',
+  [1000n * 10n ** 18n, 30n * 24n * 60n * 60n]  // amount, lock period in seconds
+);
+
+// Send transaction
+await wallet.sendUserOperation(
+  '0xStakingContractAddress...',
+  '0',
+  callData,
+  'standard'
+);
+```
+
+#### Payable Functions (Sending Native Token + Data)
+
+```typescript
+import { encodeContractCall } from '@lumiapassport/core';
+
+// Example: Wrap ETH to WETH
+const wethAbi = [
+  {
+    type: 'function',
+    name: 'deposit',
+    stateMutability: 'payable',
+    inputs: [],
+    outputs: [],
+  },
+] as const;
+
+const callData = await encodeContractCall(wethAbi, 'deposit', []);
+
+await wallet.sendUserOperation(
+  '0xWETHContractAddress...',
+  '1000000000000000000',  // 1 ETH in wei
+  callData,
+  'standard'
+);
+```
+
+#### NFT Transfers (ERC721 / ERC1155)
+
+```typescript
+import {
+  encodeERC721TransferFrom,
+  encodeERC721SafeTransferFrom,
+  encodeERC1155SafeTransferFrom,
+} from '@lumiapassport/core';
+
+// ERC721 transfer
+const nftData = await encodeERC721TransferFrom(
+  wallet.smartAccountAddress,  // from
+  '0xRecipientAddress...',     // to
+  123n                          // tokenId
+);
+
+await wallet.sendUserOperation('0xNFTContract...', '0', nftData, 'standard');
+
+// ERC1155 transfer
+const multiTokenData = await encodeERC1155SafeTransferFrom(
+  wallet.smartAccountAddress,
+  '0xRecipientAddress...',
+  1n,      // tokenId
+  100n,    // amount
+  '0x'     // data
+);
+
+await wallet.sendUserOperation('0xERC1155Contract...', '0', multiTokenData, 'standard');
+```
+
+#### Available Encoding Helpers
+
+| Function | Description |
+|----------|-------------|
+| `encodeContractCall(abi, functionName, args)` | Generic encoder for any contract |
+| `encodeERC20Transfer(to, amount)` | ERC20 transfer |
+| `encodeERC20Approve(spender, amount)` | ERC20 approve |
+| `encodeERC20TransferFrom(from, to, amount)` | ERC20 transferFrom |
+| `encodeERC721TransferFrom(from, to, tokenId)` | ERC721 transfer |
+| `encodeERC721SafeTransferFrom(from, to, tokenId, data?)` | ERC721 safe transfer |
+| `encodeERC721Approve(to, tokenId)` | ERC721 approve |
+| `encodeERC721SetApprovalForAll(operator, approved)` | ERC721 approval for all |
+| `encodeERC1155SafeTransferFrom(from, to, id, amount, data)` | ERC1155 transfer |
+| `encodeERC1155SafeBatchTransferFrom(from, to, ids, amounts, data)` | ERC1155 batch transfer |
+| `encodeERC1155SetApprovalForAll(operator, approved)` | ERC1155 approval for all |
+
+#### Standard ABIs
+
+The SDK exports standard ABIs for common token standards:
+
+```typescript
+import { ERC20_ABI, ERC721_ABI, ERC1155_ABI } from '@lumiapassport/core';
+
+// Use with viem directly or with encodeContractCall
+```
+
 ## API
 
 ### Modules

package/dist/index.cjs

@@ -1543,11 +1543,11 @@ var server_wallet_send_userop_exports = {};
 __export(server_wallet_send_userop_exports, {
   sendUserOperationForServerWallet: () => sendUserOperationForServerWallet
 });
-async function loadViem() {
-  if (!viemModule) {
-    viemModule = await import('viem');
+async function loadViem2() {
+  if (!viemModule2) {
+    viemModule2 = await import('viem');
   }
-  return viemModule;
+  return viemModule2;
 }
 async function loadBundler() {
   if (!bundlerModule) {
@@ -1571,7 +1571,7 @@ async function sendUserOperationForServerWallet(params) {
     maxVerificationGasLimit,
     debug = false
   } = params;
-  const viem = await loadViem();
+  const viem = await loadViem2();
   const bundler = await loadBundler();
   const { encodeFunctionData } = viem;
   const {
@@ -1890,10 +1890,10 @@ function normalizeSignature(signature) {
   const canonicalVHex = canonicalV.toString(16).padStart(2, "0");
   return `0x${r}${canonicalSHex}${canonicalVHex}`;
 }
-var viemModule, bundlerModule, DEFAULT_MAX_CALL_GAS_LIMIT, MAX_BUNDLER_VERIFICATION_GAS, PAYMASTER_VERIFICATION_GAS, executeAbi, factoryAbi;
+var viemModule2, bundlerModule, DEFAULT_MAX_CALL_GAS_LIMIT, MAX_BUNDLER_VERIFICATION_GAS, PAYMASTER_VERIFICATION_GAS, executeAbi, factoryAbi;
 var init_server_wallet_send_userop = __esm({
   "src/clients/server-wallet-send-userop.ts"() {
-    viemModule = null;
+    viemModule2 = null;
     bundlerModule = null;
     DEFAULT_MAX_CALL_GAS_LIMIT = 0x4C4B40n;
     MAX_BUNDLER_VERIFICATION_GAS = 5000000n;
@@ -1996,6 +1996,458 @@ init_project_id();
 init_env();
 init_helpers();
 
+// src/utils/abis.ts
+var ERC20_ABI = [
+  // Read functions
+  {
+    type: "function",
+    name: "name",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }]
+  },
+  {
+    type: "function",
+    name: "symbol",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }]
+  },
+  {
+    type: "function",
+    name: "decimals",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint8" }]
+  },
+  {
+    type: "function",
+    name: "totalSupply",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "allowance",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  // Write functions
+  {
+    type: "function",
+    name: "transfer",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "transferFrom",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  // Events
+  {
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      { name: "from", type: "address", indexed: true },
+      { name: "to", type: "address", indexed: true },
+      { name: "value", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "Approval",
+    inputs: [
+      { name: "owner", type: "address", indexed: true },
+      { name: "spender", type: "address", indexed: true },
+      { name: "value", type: "uint256", indexed: false }
+    ]
+  }
+];
+var ERC721_ABI = [
+  // Read functions
+  {
+    type: "function",
+    name: "name",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }]
+  },
+  {
+    type: "function",
+    name: "symbol",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }]
+  },
+  {
+    type: "function",
+    name: "tokenURI",
+    stateMutability: "view",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ name: "", type: "string" }]
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "ownerOf",
+    stateMutability: "view",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    type: "function",
+    name: "getApproved",
+    stateMutability: "view",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    type: "function",
+    name: "isApprovedForAll",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "operator", type: "address" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  // Write functions
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "tokenId", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "setApprovalForAll",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "operator", type: "address" },
+      { name: "approved", type: "bool" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "transferFrom",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "tokenId", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "safeTransferFrom",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "tokenId", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "safeTransferFrom",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "tokenId", type: "uint256" },
+      { name: "data", type: "bytes" }
+    ],
+    outputs: []
+  },
+  // Events
+  {
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      { name: "from", type: "address", indexed: true },
+      { name: "to", type: "address", indexed: true },
+      { name: "tokenId", type: "uint256", indexed: true }
+    ]
+  },
+  {
+    type: "event",
+    name: "Approval",
+    inputs: [
+      { name: "owner", type: "address", indexed: true },
+      { name: "approved", type: "address", indexed: true },
+      { name: "tokenId", type: "uint256", indexed: true }
+    ]
+  },
+  {
+    type: "event",
+    name: "ApprovalForAll",
+    inputs: [
+      { name: "owner", type: "address", indexed: true },
+      { name: "operator", type: "address", indexed: true },
+      { name: "approved", type: "bool", indexed: false }
+    ]
+  }
+];
+var ERC1155_ABI = [
+  // Read functions
+  {
+    type: "function",
+    name: "uri",
+    stateMutability: "view",
+    inputs: [{ name: "id", type: "uint256" }],
+    outputs: [{ name: "", type: "string" }]
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [
+      { name: "account", type: "address" },
+      { name: "id", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "balanceOfBatch",
+    stateMutability: "view",
+    inputs: [
+      { name: "accounts", type: "address[]" },
+      { name: "ids", type: "uint256[]" }
+    ],
+    outputs: [{ name: "", type: "uint256[]" }]
+  },
+  {
+    type: "function",
+    name: "isApprovedForAll",
+    stateMutability: "view",
+    inputs: [
+      { name: "account", type: "address" },
+      { name: "operator", type: "address" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  // Write functions
+  {
+    type: "function",
+    name: "setApprovalForAll",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "operator", type: "address" },
+      { name: "approved", type: "bool" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "safeTransferFrom",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "id", type: "uint256" },
+      { name: "amount", type: "uint256" },
+      { name: "data", type: "bytes" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "safeBatchTransferFrom",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "ids", type: "uint256[]" },
+      { name: "amounts", type: "uint256[]" },
+      { name: "data", type: "bytes" }
+    ],
+    outputs: []
+  },
+  // Events
+  {
+    type: "event",
+    name: "TransferSingle",
+    inputs: [
+      { name: "operator", type: "address", indexed: true },
+      { name: "from", type: "address", indexed: true },
+      { name: "to", type: "address", indexed: true },
+      { name: "id", type: "uint256", indexed: false },
+      { name: "value", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "TransferBatch",
+    inputs: [
+      { name: "operator", type: "address", indexed: true },
+      { name: "from", type: "address", indexed: true },
+      { name: "to", type: "address", indexed: true },
+      { name: "ids", type: "uint256[]", indexed: false },
+      { name: "values", type: "uint256[]", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "ApprovalForAll",
+    inputs: [
+      { name: "account", type: "address", indexed: true },
+      { name: "operator", type: "address", indexed: true },
+      { name: "approved", type: "bool", indexed: false }
+    ]
+  }
+];
+
+// src/utils/contract-encoding.ts
+var viemModule = null;
+async function loadViem() {
+  if (!viemModule) {
+    viemModule = await import('viem');
+  }
+  return viemModule;
+}
+async function encodeContractCall(abi, functionName, args) {
+  const { encodeFunctionData } = await loadViem();
+  return encodeFunctionData({
+    abi,
+    functionName,
+    args
+  });
+}
+async function encodeERC20Transfer(to, amount) {
+  const { encodeFunctionData } = await loadViem();
+  return encodeFunctionData({
+    abi: ERC20_ABI,
+    functionName: "transfer",
+    args: [to, amount]
+  });
+}
+async function encodeERC20Approve(spender, amount) {
+  const { encodeFunctionData } = await loadViem();
+  return encodeFunctionData({
+    abi: ERC20_ABI,
+    functionName: "approve",
+    args: [spender, amount]
+  });
+}
+async function encodeERC20TransferFrom(from, to, amount) {
+  const { encodeFunctionData } = await loadViem();
+  return encodeFunctionData({
+    abi: ERC20_ABI,
+    functionName: "transferFrom",
+    args: [from, to, amount]
+  });
+}
+async function encodeERC721TransferFrom(from, to, tokenId) {
+  const { encodeFunctionData } = await loadViem();
+  return encodeFunctionData({
+    abi: ERC721_ABI,
+    functionName: "transferFrom",
+    args: [from, to, tokenId]
+  });
+}
+async function encodeERC721SafeTransferFrom(from, to, tokenId, data) {
+  const { encodeFunctionData } = await loadViem();
+  if (data) {
+    return encodeFunctionData({
+      abi: ERC721_ABI,
+      functionName: "safeTransferFrom",
+      args: [from, to, tokenId, data]
+    });
+  }
+  return encodeFunctionData({
+    abi: ERC721_ABI,
+    functionName: "safeTransferFrom",
+    args: [from, to, tokenId]
+  });
+}
+async function encodeERC721Approve(to, tokenId) {
+  const { encodeFunctionData } = await loadViem();
+  return encodeFunctionData({
+    abi: ERC721_ABI,
+    functionName: "approve",
+    args: [to, tokenId]
+  });
+}
+async function encodeERC721SetApprovalForAll(operator, approved) {
+  const { encodeFunctionData } = await loadViem();
+  return encodeFunctionData({
+    abi: ERC721_ABI,
+    functionName: "setApprovalForAll",
+    args: [operator, approved]
+  });
+}
+async function encodeERC1155SafeTransferFrom(from, to, id, amount, data = "0x") {
+  const { encodeFunctionData } = await loadViem();
+  return encodeFunctionData({
+    abi: ERC1155_ABI,
+    functionName: "safeTransferFrom",
+    args: [from, to, id, amount, data]
+  });
+}
+async function encodeERC1155SafeBatchTransferFrom(from, to, ids, amounts, data = "0x") {
+  const { encodeFunctionData } = await loadViem();
+  return encodeFunctionData({
+    abi: ERC1155_ABI,
+    functionName: "safeBatchTransferFrom",
+    args: [from, to, ids, amounts, data]
+  });
+}
+async function encodeERC1155SetApprovalForAll(operator, approved) {
+  const { encodeFunctionData } = await loadViem();
+  return encodeFunctionData({
+    abi: ERC1155_ABI,
+    functionName: "setApprovalForAll",
+    args: [operator, approved]
+  });
+}
+
 // src/index.ts
 init_bundler();
 
@@ -3150,6 +3602,9 @@ var VERSION = "0.1.0";
 
 exports.BlockscoutApiError = BlockscoutApiError;
 exports.BlockscoutClient = BlockscoutClient;
+exports.ERC1155_ABI = ERC1155_ABI;
+exports.ERC20_ABI = ERC20_ABI;
+exports.ERC721_ABI = ERC721_ABI;
 exports.MemoryKeyshareStorage = MemoryKeyshareStorage;
 exports.ServerWalletClient = ServerWalletClient;
 exports.ServerWalletManager = ServerWalletManager;
@@ -3178,6 +3633,17 @@ exports.createServerWalletClient = createServerWalletClient;
 exports.createServerWalletManager = createServerWalletManager;
 exports.createUserOperationV06WithDynamicFees = createUserOperationV06WithDynamicFees;
 exports.createUserOperationWithDynamicFees = createUserOperationWithDynamicFees;
+exports.encodeContractCall = encodeContractCall;
+exports.encodeERC1155SafeBatchTransferFrom = encodeERC1155SafeBatchTransferFrom;
+exports.encodeERC1155SafeTransferFrom = encodeERC1155SafeTransferFrom;
+exports.encodeERC1155SetApprovalForAll = encodeERC1155SetApprovalForAll;
+exports.encodeERC20Approve = encodeERC20Approve;
+exports.encodeERC20Transfer = encodeERC20Transfer;
+exports.encodeERC20TransferFrom = encodeERC20TransferFrom;
+exports.encodeERC721Approve = encodeERC721Approve;
+exports.encodeERC721SafeTransferFrom = encodeERC721SafeTransferFrom;
+exports.encodeERC721SetApprovalForAll = encodeERC721SetApprovalForAll;
+exports.encodeERC721TransferFrom = encodeERC721TransferFrom;
 exports.ensureValidToken = ensureValidToken;
 exports.estimateUserOperationGas = estimateUserOperationGas;
 exports.estimateUserOperationGasWithDynamicFees = estimateUserOperationGasWithDynamicFees;