@trustvc/trustvc 2.14.1 → 2.15.0-beta.2

package/README.md

@@ -28,6 +28,15 @@ TrustVC is a comprehensive wrapper library designed to simplify the signing and
     - [8. **Document Builder**](#8-document-builder)
     - [9. **Document Store**](#9-document-store)
     - [10. **Transaction Cancel**](#10-transaction-cancel)
+    - [11. **Gasless Operations (EIP-7702)**](#11-gasless-operations-eip-7702)
+      - [Overview](#overview-1)
+      - [deployPlatformPaymaster](#deployplatformpaymaster)
+      - [deployTokenRegistryGasless](#deploytokenregistrygasless)
+      - [mintGasless](#mintgasless)
+      - [Transfer Functions](#transfer-functions)
+      - [Reject Transfer Functions](#reject-transfer-functions)
+      - [Return to Issuer Functions](#return-to-issuer-functions)
+      - [Admin Functions](#admin-functions)
 
 ## Installation
 
@@ -1203,3 +1212,297 @@ const replacementHash2 = await cancelTransaction(signer, {
   gasPrice: '25000000000', // 25 gwei in wei
 });
 ```
+
+---
+
+## 11. **Gasless Operations (EIP-7702)**
+
+> **Beta:** Gasless transactions are currently in beta. APIs and contract addresses may change before the stable release. Use on testnet only.
+
+### Overview
+
+TrustVC supports gasless trade document operations via **EIP-7702** (smart account delegation) and **ERC-4337** (account abstraction). Users can deploy token registries, mint documents, and perform all title escrow operations without holding ETH — gas is sponsored by a **PlatformPaymaster** deployed per platform.
+
+**How it works:**
+
+1. An EOA signs an EIP-7702 authorization, delegating to the `EIP7702Implementation` contract. Its bytecode becomes `0xef0100 || impl_address` while keeping the same address and private key.
+2. The platform deploys a `PlatformPaymaster` clone via `PlatformAccountFactory`.
+3. Users submit `UserOperation`s through a bundler (Pimlico). The paymaster validates and sponsors gas for authorized operations.
+
+All gasless functions accept a `smartAccountClient` built with [permissionless](https://docs.pimlico.io/permissionless) and return `Promise<string>` (transaction hash).
+
+```ts
+import { buildSmartAccountClient } from './your-pimlico-setup';
+
+const { smartAccountClient } = await buildSmartAccountClient(
+  ownerAddress,     // delegated EOA
+  paymasterAddress, // platform's PlatformPaymaster
+);
+```
+
+---
+
+### deployPlatformPaymaster
+
+Deploys a new `PlatformPaymaster` clone for your platform via `PlatformAccountFactory`. Accepts a viem `WalletClient` or ethers v5/v6 signer.
+
+```ts
+import { deployPlatformPaymaster } from '@trustvc/trustvc';
+import { createWalletClient, createPublicClient, http } from 'viem';
+import { sepolia } from 'viem/chains';
+
+const { txHash, paymasterAddress } = await deployPlatformPaymaster(
+  walletClient,
+  {
+    platformAddress: '0xYourPlatformOwner...',
+    dailyLimit: 0n,                    // 0n = unlimited; set in wei to cap per-user daily spend
+    salt: `0x${'ab'.repeat(32)}`,      // bytes32 CREATE2 salt — must be unique per platform
+  },
+  publicClient,
+);
+
+console.log('Paymaster deployed at:', paymasterAddress);
+```
+
+---
+
+### deployTokenRegistryGasless
+
+Deploys a new `TradeTrustToken` registry clone through the paymaster. The caller must have at least 1 deployment credit (`setUserWhitelist`). Emits `RegistryDeployed(user, deployed, creditsLeft)`.
+
+```ts
+import { deployTokenRegistryGasless } from '@trustvc/trustvc';
+
+const txHash = await deployTokenRegistryGasless(
+  'My Shipping Line',  // registry name
+  'MSL',               // registry symbol
+  smartAccountClient,
+  {
+    paymasterAddress:         '0xYourPaymaster...',
+    tokenRegistryImplAddress: '0x64bc665056DC8bE4092e569ED13a7F273Be28cD2', // TDocDeployer on Sepolia
+  },
+);
+```
+
+---
+
+### mintGasless
+
+Mints a new trade document on an authorized registry. Automatically authorizes the beneficiary, holder, and the new `TitleEscrow` on the paymaster. Emits `TitleEscrowLinked(titleEscrow, registry)`.
+
+```ts
+import { mintGasless } from '@trustvc/trustvc';
+
+const txHash = await mintGasless(
+  {
+    paymasterAddress:     '0xYourPaymaster...',
+    tokenRegistryAddress: '0xYourRegistry...',
+  },
+  smartAccountClient,
+  {
+    beneficiaryAddress: '0xBeneficiary...',
+    holderAddress:      '0xHolder...',
+    tokenId:            '0xdeadbeef',
+    remarks:            'Initial issuance',  // optional — encrypted on-chain with options.id
+  },
+  { id: 'document-uuid' },
+);
+```
+
+---
+
+### Transfer Functions
+
+All transfer functions target the `TitleEscrow` contract. Remarks are automatically encrypted with `options.id` before being sent on-chain.
+
+#### transferHolderGasless
+
+Transfers the **holder** role. Caller must be the current holder.
+
+```ts
+import { transferHolderGasless } from '@trustvc/trustvc';
+
+const txHash = await transferHolderGasless(
+  { titleEscrowAddress: '0xTitleEscrow...' },
+  smartAccountClient,
+  { holderAddress: '0xNewHolder...', remarks: 'Transferring to forwarder' },
+  { id: 'document-uuid' },
+);
+```
+
+#### transferBeneficiaryGasless
+
+Transfers the **beneficiary** role. Caller must be the current beneficiary.
+
+```ts
+import { transferBeneficiaryGasless } from '@trustvc/trustvc';
+
+const txHash = await transferBeneficiaryGasless(
+  { titleEscrowAddress: '0xTitleEscrow...' },
+  smartAccountClient,
+  { newBeneficiaryAddress: '0xNewBeneficiary...', remarks: 'Endorsing to buyer' },
+  { id: 'document-uuid' },
+);
+```
+
+#### transferOwnersGasless
+
+Transfers both holder and beneficiary in one transaction. Caller must be both.
+
+```ts
+import { transferOwnersGasless } from '@trustvc/trustvc';
+
+const txHash = await transferOwnersGasless(
+  { titleEscrowAddress: '0xTitleEscrow...' },
+  smartAccountClient,
+  {
+    newBeneficiaryAddress: '0xNewBeneficiary...',
+    newHolderAddress:      '0xNewHolder...',
+    remarks:               'Full transfer',
+  },
+  { id: 'document-uuid' },
+);
+```
+
+#### nominateGasless
+
+Nominates a new beneficiary without immediately completing the transfer.
+
+```ts
+import { nominateGasless } from '@trustvc/trustvc';
+
+const txHash = await nominateGasless(
+  { titleEscrowAddress: '0xTitleEscrow...' },
+  smartAccountClient,
+  { newBeneficiaryAddress: '0xNominated...', remarks: 'Nomination' },
+  { id: 'document-uuid' },
+);
+```
+
+---
+
+### Reject Transfer Functions
+
+Mirror of Token Registry v5's rejection methods — see [section 7](#b-token-registry-v5) for the on-chain rules.
+
+```ts
+import {
+  rejectTransferHolderGasless,
+  rejectTransferBeneficiaryGasless,
+  rejectTransferOwnersGasless,
+} from '@trustvc/trustvc';
+
+// Reject a pending holder transfer (caller = current holder)
+await rejectTransferHolderGasless(
+  { titleEscrowAddress: '0xTitleEscrow...' },
+  smartAccountClient,
+  { remarks: 'Rejecting transfer' },
+  { id: 'document-uuid' },
+);
+
+// Reject a pending beneficiary nomination (caller = current beneficiary)
+await rejectTransferBeneficiaryGasless(
+  { titleEscrowAddress: '0xTitleEscrow...' },
+  smartAccountClient,
+  { remarks: 'Rejecting nomination' },
+  { id: 'document-uuid' },
+);
+
+// Reject a combined transfer (caller = both holder and beneficiary)
+await rejectTransferOwnersGasless(
+  { titleEscrowAddress: '0xTitleEscrow...' },
+  smartAccountClient,
+  { remarks: 'Rejecting combined transfer' },
+  { id: 'document-uuid' },
+);
+```
+
+---
+
+### Return to Issuer Functions
+
+#### returnToIssuerGasless
+
+Returns the document to the issuer. Caller must be both holder and beneficiary.
+
+```ts
+import { returnToIssuerGasless } from '@trustvc/trustvc';
+
+await returnToIssuerGasless(
+  { titleEscrowAddress: '0xTitleEscrow...' },
+  smartAccountClient,
+  { remarks: 'Surrendering document' },
+  { id: 'document-uuid' },
+);
+```
+
+#### rejectReturnedGasless
+
+Restores the document back to the title escrow (registry admin rejects the return).
+
+```ts
+import { rejectReturnedGasless } from '@trustvc/trustvc';
+
+await rejectReturnedGasless(
+  { tokenRegistryAddress: '0xYourRegistry...' },
+  smartAccountClient,
+  { tokenId: '0xdeadbeef', remarks: 'Return rejected' },
+  { id: 'document-uuid' },
+);
+```
+
+#### acceptReturnedGasless
+
+Burns the document (registry admin accepts the return).
+
+```ts
+import { acceptReturnedGasless } from '@trustvc/trustvc';
+
+await acceptReturnedGasless(
+  { tokenRegistryAddress: '0xYourRegistry...' },
+  smartAccountClient,
+  { tokenId: '0xdeadbeef', remarks: 'Document accepted and destroyed' },
+  { id: 'document-uuid' },
+);
+```
+
+---
+
+### Admin Functions
+
+`onlyOwner` functions for managing the `PlatformPaymaster`. All accept a viem `WalletClient` or ethers v5/v6 signer and return `Promise<string>` (tx hash).
+
+```ts
+import {
+  setUserWhitelist,
+  removeUserFromWhitelist,
+  addRegistry,
+  removeRegistry,
+  addTitleEscrow,
+  removeTitleEscrow,
+  addAuthorizedCaller,
+  removeAuthorizedCaller,
+  setDailyLimit,
+} from '@trustvc/trustvc';
+
+// Grant a user 2 registry deployment credits (max 3)
+await setUserWhitelist(ownerSigner, paymasterAddress, '0xUser...', 2n);
+
+// Remove a user from the whitelist
+await removeUserFromWhitelist(ownerSigner, paymasterAddress, '0xUser...');
+
+// Authorize a registry so the paymaster will sponsor its calls
+await addRegistry(ownerSigner, paymasterAddress, '0xRegistry...');
+await removeRegistry(ownerSigner, paymasterAddress, '0xRegistry...');
+
+// Authorize a title escrow
+await addTitleEscrow(ownerSigner, paymasterAddress, '0xTitleEscrow...');
+await removeTitleEscrow(ownerSigner, paymasterAddress, '0xTitleEscrow...');
+
+// Manage authorized callers (beneficiary / holder addresses for Path A)
+await addAuthorizedCaller(ownerSigner, paymasterAddress, '0xCaller...');
+await removeAuthorizedCaller(ownerSigner, paymasterAddress, '0xCaller...');
+
+// Update the per-user daily gas spend cap (0n = unlimited)
+await setDailyLimit(ownerSigner, paymasterAddress, 0n);
+```

package/dist/cjs/eip7702-functions/deploy/index.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var platformPaymaster = require('./platform-paymaster');
+var tokenRegistry = require('./token-registry');
+
+
+
+Object.keys(platformPaymaster).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return platformPaymaster[k]; }
+	});
+});
+Object.keys(tokenRegistry).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return tokenRegistry[k]; }
+	});
+});

package/dist/cjs/eip7702-functions/deploy/platform-paymaster.js

@@ -0,0 +1,82 @@
+'use strict';
+
+var viem = require('viem');
+var eip7702 = require('@trustvc/eip7702');
+var ethers = require('../../utils/ethers');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const deployPlatformPaymaster = /* @__PURE__ */ __name(async (signer, options, publicClient) => {
+  const { chainId = eip7702.constants.ChainId.Sepolia, dailyLimit = 0n, salt } = options;
+  const factoryAddress = options.factoryAddress ?? eip7702.constants.contractAddress.PlatformAccountFactory[chainId];
+  if (!factoryAddress) {
+    throw new Error(
+      `No PlatformAccountFactory address found for chainId ${chainId}. Supply factoryAddress in options.`
+    );
+  }
+  if ("writeContract" in signer) {
+    if (!publicClient) throw new Error("publicClient is required when signer is a WalletClient");
+    const platformAddress2 = options.platformAddress ?? signer.account?.address;
+    const txHash2 = await signer.writeContract({
+      address: factoryAddress,
+      abi: eip7702.abis.platformAccountFactoryAbi,
+      functionName: "deployPlatformPaymaster",
+      args: [platformAddress2, dailyLimit, salt],
+      chain: signer.chain,
+      account: signer.account
+    });
+    const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash2 });
+    const logs2 = viem.parseEventLogs({
+      abi: eip7702.abis.platformAccountFactoryAbi,
+      logs: receipt.logs,
+      eventName: "PlatformOnboarded"
+    });
+    const paymasterAddress = logs2[0]?.args?.paymaster;
+    if (!paymasterAddress)
+      throw new Error("Deployment failed \u2014 PlatformOnboarded event not found in transaction logs");
+    return { txHash: txHash2, paymasterAddress };
+  }
+  const ethSigner = signer;
+  const platformAddress = options.platformAddress ?? await ethSigner.getAddress();
+  const Contract = ethers.getEthersContractFromProvider(ethSigner.provider);
+  const contract = new Contract(
+    factoryAddress,
+    eip7702.abis.platformAccountFactoryAbi,
+    ethSigner
+    // eslint-disable-line @typescript-eslint/no-explicit-any
+  );
+  const isV6 = ethers.isV6EthersProvider(ethSigner.provider);
+  let txHash;
+  let logs;
+  if (isV6) {
+    const tx = await contract.deployPlatformPaymaster(
+      platformAddress,
+      dailyLimit,
+      salt
+    );
+    const receipt = await tx.wait();
+    txHash = receipt.hash;
+    logs = receipt.logs;
+  } else {
+    const tx = await contract.deployPlatformPaymaster(
+      platformAddress,
+      dailyLimit,
+      salt
+    );
+    const receipt = await tx.wait();
+    txHash = receipt.transactionHash;
+    logs = receipt.logs;
+  }
+  for (const log of logs) {
+    try {
+      const parsed = contract.interface.parseLog(log);
+      if (parsed?.name === "PlatformOnboarded") {
+        return { txHash, paymasterAddress: parsed.args.paymaster };
+      }
+    } catch {
+    }
+  }
+  throw new Error("Deployment failed \u2014 PlatformOnboarded event not found in transaction logs");
+}, "deployPlatformPaymaster");
+
+exports.deployPlatformPaymaster = deployPlatformPaymaster;

package/dist/cjs/eip7702-functions/deploy/token-registry.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var viem = require('viem');
+var eip7702 = require('@trustvc/eip7702');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const deployTokenRegistryGasless = /* @__PURE__ */ __name(async (registryName, registrySymbol, smartAccountClient, options) => {
+  const { paymasterAddress, tokenRegistryImplAddress } = options;
+  if (!paymasterAddress) throw new Error("paymasterAddress is required");
+  if (!tokenRegistryImplAddress) throw new Error("tokenRegistryImplAddress is required");
+  const data = viem.encodeFunctionData({
+    abi: eip7702.abis.platformPaymasterAbi,
+    functionName: "deployRegistry",
+    args: [tokenRegistryImplAddress, registryName, registrySymbol]
+  });
+  return smartAccountClient.sendTransaction({
+    to: paymasterAddress,
+    value: 0n,
+    data
+  });
+}, "deployTokenRegistryGasless");
+
+exports.deployTokenRegistryGasless = deployTokenRegistryGasless;

package/dist/cjs/eip7702-functions/index.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var tokenRegistryFunctionsGasless = require('./token-registry-functions-gasless');
+var deploy = require('./deploy');
+var platformPaymasterFunctions = require('./platform-paymaster-functions');
+var eip7702 = require('@trustvc/eip7702');
+
+
+
+Object.defineProperty(exports, "eip7702Abis", {
+  enumerable: true,
+  get: function () { return eip7702.abis; }
+});
+Object.keys(tokenRegistryFunctionsGasless).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return tokenRegistryFunctionsGasless[k]; }
+  });
+});
+Object.keys(deploy).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return deploy[k]; }
+  });
+});
+Object.keys(platformPaymasterFunctions).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return platformPaymasterFunctions[k]; }
+  });
+});

package/dist/cjs/eip7702-functions/platform-paymaster-functions/admin.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var eip7702 = require('@trustvc/eip7702');
+var ethers = require('../../utils/ethers');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+async function sendAdminTx(signer, paymasterAddress, functionName, args) {
+  if ("writeContract" in signer) {
+    return signer.writeContract({
+      address: paymasterAddress,
+      abi: eip7702.abis.platformPaymasterAbi,
+      functionName,
+      args,
+      chain: signer.chain,
+      account: signer.account
+    });
+  }
+  const ethSigner = signer;
+  const Contract = ethers.getEthersContractFromProvider(ethSigner.provider);
+  const contract = new Contract(
+    paymasterAddress,
+    eip7702.abis.platformPaymasterAbi,
+    ethSigner
+    // eslint-disable-line @typescript-eslint/no-explicit-any
+  );
+  const isV6 = ethers.isV6EthersProvider(ethSigner.provider);
+  const tx = await contract[functionName](...args);
+  if (isV6) {
+    return tx.hash;
+  }
+  const receipt = await tx.wait();
+  return receipt.transactionHash;
+}
+__name(sendAdminTx, "sendAdminTx");
+const setUserWhitelist = /* @__PURE__ */ __name(async (signer, paymasterAddress, user, credits) => sendAdminTx(signer, paymasterAddress, "setUserWhitelist", [user, credits]), "setUserWhitelist");
+const removeUserFromWhitelist = /* @__PURE__ */ __name(async (signer, paymasterAddress, user) => sendAdminTx(signer, paymasterAddress, "removeUserFromWhitelist", [user]), "removeUserFromWhitelist");
+const addRegistry = /* @__PURE__ */ __name(async (signer, paymasterAddress, registry) => sendAdminTx(signer, paymasterAddress, "addRegistry", [registry]), "addRegistry");
+const removeRegistry = /* @__PURE__ */ __name(async (signer, paymasterAddress, registry) => sendAdminTx(signer, paymasterAddress, "removeRegistry", [registry]), "removeRegistry");
+const addTitleEscrow = /* @__PURE__ */ __name(async (signer, paymasterAddress, titleEscrow) => sendAdminTx(signer, paymasterAddress, "addTitleEscrow", [titleEscrow]), "addTitleEscrow");
+const removeTitleEscrow = /* @__PURE__ */ __name(async (signer, paymasterAddress, titleEscrow) => sendAdminTx(signer, paymasterAddress, "removeTitleEscrow", [titleEscrow]), "removeTitleEscrow");
+const addAuthorizedCaller = /* @__PURE__ */ __name(async (signer, paymasterAddress, caller) => sendAdminTx(signer, paymasterAddress, "addAuthorizedCaller", [caller]), "addAuthorizedCaller");
+const removeAuthorizedCaller = /* @__PURE__ */ __name(async (signer, paymasterAddress, caller) => sendAdminTx(signer, paymasterAddress, "removeAuthorizedCaller", [caller]), "removeAuthorizedCaller");
+const setDailyLimit = /* @__PURE__ */ __name(async (signer, paymasterAddress, dailyLimit) => sendAdminTx(signer, paymasterAddress, "setDailyLimit", [dailyLimit]), "setDailyLimit");
+
+exports.addAuthorizedCaller = addAuthorizedCaller;
+exports.addRegistry = addRegistry;
+exports.addTitleEscrow = addTitleEscrow;
+exports.removeAuthorizedCaller = removeAuthorizedCaller;
+exports.removeRegistry = removeRegistry;
+exports.removeTitleEscrow = removeTitleEscrow;
+exports.removeUserFromWhitelist = removeUserFromWhitelist;
+exports.setDailyLimit = setDailyLimit;
+exports.setUserWhitelist = setUserWhitelist;

package/dist/cjs/eip7702-functions/platform-paymaster-functions/index.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var admin = require('./admin');
+
+
+
+Object.keys(admin).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return admin[k]; }
+	});
+});

package/dist/cjs/eip7702-functions/token-registry-functions-gasless/index.js

@@ -0,0 +1,33 @@
+'use strict';
+
+var mint = require('./mint');
+var rejectTransfers = require('./rejectTransfers');
+var returnToken = require('./returnToken');
+var transfer = require('./transfer');
+
+
+
+Object.keys(mint).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return mint[k]; }
+	});
+});
+Object.keys(rejectTransfers).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return rejectTransfers[k]; }
+	});
+});
+Object.keys(returnToken).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return returnToken[k]; }
+	});
+});
+Object.keys(transfer).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return transfer[k]; }
+	});
+});

package/dist/cjs/eip7702-functions/token-registry-functions-gasless/mint.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var viem = require('viem');
+var core = require('../../core');
+var eip7702 = require('@trustvc/eip7702');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const mintGasless = /* @__PURE__ */ __name(async (contractOptions, smartAccountClient, params, options) => {
+  const { paymasterAddress, tokenRegistryAddress } = contractOptions;
+  const { beneficiaryAddress, holderAddress, tokenId, remarks } = params;
+  if (!paymasterAddress) throw new Error("paymasterAddress is required");
+  if (!tokenRegistryAddress) throw new Error("tokenRegistryAddress is required");
+  const encryptedRemarks = remarks ? `0x${core.encrypt(remarks, options.id)}` : "0x";
+  return smartAccountClient.sendTransaction({
+    to: paymasterAddress,
+    value: 0n,
+    data: viem.encodeFunctionData({
+      abi: eip7702.abis.platformPaymasterAbi,
+      functionName: "mintDocument",
+      args: [
+        tokenRegistryAddress,
+        beneficiaryAddress,
+        holderAddress,
+        BigInt(tokenId),
+        encryptedRemarks
+      ]
+    })
+  });
+}, "mintGasless");
+
+exports.mintGasless = mintGasless;

package/dist/cjs/eip7702-functions/token-registry-functions-gasless/rejectTransfers.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var viem = require('viem');
+var core = require('../../core');
+var tokenRegistryV5 = require('../../token-registry-v5');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const rejectTransferHolderGasless = /* @__PURE__ */ __name(async (contractOptions, smartAccountClient, params, options) => {
+  const { titleEscrowAddress } = contractOptions;
+  const { remarks } = params;
+  if (!titleEscrowAddress) throw new Error("titleEscrowAddress is required");
+  const encryptedRemarks = remarks ? `0x${core.encrypt(remarks, options.id)}` : "0x";
+  return smartAccountClient.sendTransaction({
+    to: titleEscrowAddress,
+    value: 0n,
+    data: viem.encodeFunctionData({
+      abi: tokenRegistryV5.v5Contracts.TitleEscrow__factory.abi,
+      functionName: "rejectTransferHolder",
+      args: [encryptedRemarks]
+    })
+  });
+}, "rejectTransferHolderGasless");
+const rejectTransferBeneficiaryGasless = /* @__PURE__ */ __name(async (contractOptions, smartAccountClient, params, options) => {
+  const { titleEscrowAddress } = contractOptions;
+  const { remarks } = params;
+  if (!titleEscrowAddress) throw new Error("titleEscrowAddress is required");
+  const encryptedRemarks = remarks ? `0x${core.encrypt(remarks, options.id)}` : "0x";
+  return smartAccountClient.sendTransaction({
+    to: titleEscrowAddress,
+    value: 0n,
+    data: viem.encodeFunctionData({
+      abi: tokenRegistryV5.v5Contracts.TitleEscrow__factory.abi,
+      functionName: "rejectTransferBeneficiary",
+      args: [encryptedRemarks]
+    })
+  });
+}, "rejectTransferBeneficiaryGasless");
+const rejectTransferOwnersGasless = /* @__PURE__ */ __name(async (contractOptions, smartAccountClient, params, options) => {
+  const { titleEscrowAddress } = contractOptions;
+  const { remarks } = params;
+  if (!titleEscrowAddress) throw new Error("titleEscrowAddress is required");
+  const encryptedRemarks = remarks ? `0x${core.encrypt(remarks, options.id)}` : "0x";
+  return smartAccountClient.sendTransaction({
+    to: titleEscrowAddress,
+    value: 0n,
+    data: viem.encodeFunctionData({
+      abi: tokenRegistryV5.v5Contracts.TitleEscrow__factory.abi,
+      functionName: "rejectTransferOwners",
+      args: [encryptedRemarks]
+    })
+  });
+}, "rejectTransferOwnersGasless");
+
+exports.rejectTransferBeneficiaryGasless = rejectTransferBeneficiaryGasless;
+exports.rejectTransferHolderGasless = rejectTransferHolderGasless;
+exports.rejectTransferOwnersGasless = rejectTransferOwnersGasless;