@getpara/aa-porto 2.16.0

package/dist/action.d.ts

@@ -0,0 +1,13 @@
+import type { SmartAccount7702 } from '@getpara/viem-v2-integration';
+import type { CreatePortoSmartAccountParams } from './types.js';
+export type { CreatePortoSmartAccountParams } from './types.js';
+/**
+ * Creates a Porto smart account by upgrading a Para EOA to a Porto 7702 smart account.
+ *
+ * Porto uses EIP-7702 to delegate the EOA to a smart account contract, enabling
+ * session keys, transaction batching, and gas sponsorship while keeping the same address.
+ *
+ * @param params - Configuration parameters
+ * @returns Unified SmartAccount interface wrapping Porto account, or null if no EVM wallet exists
+ */
+export declare function createPortoSmartAccount(params: CreatePortoSmartAccountParams): Promise<SmartAccount7702 | null>;

package/dist/action.js

@@ -0,0 +1,165 @@
+import { Account, Key, RelayActions } from "porto/viem";
+import { createClient, createPublicClient, http } from "viem";
+import { createParaAccount } from "@getpara/viem-v2-integration";
+import { wrapProviderError, resolveWalletIdentifier } from "@getpara/viem-v2-integration";
+const PORTO_RELAY_RPC = "https://rpc.porto.sh";
+const PORTO_POLL_MAX_ATTEMPTS = 30;
+const PORTO_POLL_INTERVAL_MS = 2e3;
+const PORTO_UPGRADE_POLL_MAX = 6;
+const PORTO_UPGRADE_POLL_MS = 500;
+async function sendCallsViaRelay(portoClient, portoAccount, adminKey, calls, merchantUrl, feeToken) {
+  const { capabilities, context, digest } = await RelayActions.prepareCalls(
+    portoClient,
+    {
+      account: portoAccount,
+      key: adminKey,
+      calls,
+      ...merchantUrl ? { merchantUrl } : {},
+      ...feeToken ? { feeToken } : {}
+    }
+  );
+  const signature = await portoAccount.sign({ hash: digest });
+  const caps = capabilities;
+  const result = await RelayActions.sendPreparedCalls(portoClient, {
+    capabilities: caps.feeSignature ? { feeSignature: caps.feeSignature } : void 0,
+    context,
+    key: adminKey,
+    signature
+  });
+  return result.id;
+}
+async function createPortoSmartAccount(params) {
+  const { para, chain, merchantUrl, feeToken } = params;
+  const walletAddress = resolveWalletIdentifier(para, params);
+  if (!walletAddress) return null;
+  const viemAccount = createParaAccount(para, walletAddress);
+  const portoClient = createClient({
+    chain,
+    transport: http(PORTO_RELAY_RPC)
+  });
+  const publicClient = createPublicClient({
+    chain,
+    transport: http()
+  });
+  const adminKey = Key.fromSecp256k1({ address: viemAccount.address, role: "admin" });
+  const portoAccount = Account.from({
+    address: viemAccount.address,
+    async sign({ hash }) {
+      return viemAccount.sign({ hash });
+    }
+  });
+  const buildAccount = () => Account.from({
+    address: viemAccount.address,
+    keys: [adminKey],
+    async sign({ hash }) {
+      return viemAccount.sign({ hash });
+    }
+  });
+  const upgradeAndWait = async (expectedCode) => {
+    const ephemeralP256Key = Key.createP256({ role: "admin" });
+    const prepared = await RelayActions.prepareUpgradeAccount(portoClient, {
+      address: portoAccount.address,
+      authorizeKeys: [ephemeralP256Key, adminKey],
+      chain
+    });
+    const signatures = {
+      auth: await viemAccount.sign({ hash: prepared.digests.auth }),
+      exec: await viemAccount.sign({ hash: prepared.digests.exec })
+    };
+    await RelayActions.upgradeAccount(portoClient, {
+      ...prepared,
+      signatures
+    });
+    for (let i = 0; i < PORTO_UPGRADE_POLL_MAX; i++) {
+      const code = await publicClient.getCode({ address: viemAccount.address });
+      const isReady = expectedCode ? code?.toLowerCase() === expectedCode : code && code.length > 4;
+      if (isReady) break;
+      await new Promise((r) => setTimeout(r, PORTO_UPGRADE_POLL_MS));
+    }
+    return buildAccount();
+  };
+  const withTimeout = (promise, ms) => Promise.race([
+    promise.then((v) => v).catch(() => void 0),
+    new Promise((resolve) => setTimeout(() => resolve(void 0), ms))
+  ]);
+  const [capsResult, currentCode] = await Promise.all([
+    (async () => {
+      try {
+        const caps = await withTimeout(RelayActions.getCapabilities(portoClient, { chainId: chain.id }), 3e3);
+        const chainKey = `0x${chain.id.toString(16)}`;
+        const capsAny = caps;
+        return capsAny?.[chainKey]?.contracts?.accountProxy?.address ?? capsAny?.contracts?.accountProxy?.address;
+      } catch {
+        return void 0;
+      }
+    })(),
+    publicClient.getCode({ address: viemAccount.address })
+  ]);
+  const portoExpectedCode = capsResult ? `0xef0100${capsResult.slice(2).toLowerCase()}` : void 0;
+  const isEip7702 = currentCode && currentCode.length === 48 && currentCode.startsWith("0xef0100");
+  let account;
+  try {
+    if (isEip7702 && portoExpectedCode && currentCode.toLowerCase() === portoExpectedCode) {
+      account = buildAccount();
+    } else if (isEip7702 && portoExpectedCode) {
+      const otherTarget = `0x${currentCode.slice(8)}`;
+      throw new Error(
+        `This account is already delegated to another EIP-7702 provider (${otherTarget}). Porto cannot be used alongside another 7702 provider.`
+      );
+    } else {
+      account = await upgradeAndWait(portoExpectedCode);
+    }
+  } catch (error) {
+    throw wrapProviderError(error, "PORTO");
+  }
+  const sendBatchTransaction = async (calls, isRetry = false) => {
+    try {
+      const id = await sendCallsViaRelay(
+        portoClient,
+        account,
+        adminKey,
+        calls.map((c) => ({
+          to: c.to,
+          value: c.value || BigInt(0),
+          data: c.data || "0x"
+        })),
+        merchantUrl,
+        feeToken
+      );
+      let status;
+      for (let i = 0; i < PORTO_POLL_MAX_ATTEMPTS; i++) {
+        status = await RelayActions.getCallsStatus(portoClient, { id });
+        if (status.status !== 100 && status.receipts?.length) break;
+        await new Promise((r) => setTimeout(r, PORTO_POLL_INTERVAL_MS));
+      }
+      const receipt = status?.receipts?.[0];
+      const txHash = receipt?.transactionHash ?? id;
+      return publicClient.getTransactionReceipt({ hash: txHash });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      if (!isRetry && (msg.includes("ORCHESTRATOR") || msg.includes("returned no data"))) {
+        try {
+          account = await upgradeAndWait(portoExpectedCode);
+          return await sendBatchTransaction(calls, true);
+        } catch (retryError) {
+          throw wrapProviderError(retryError, "PORTO");
+        }
+      }
+      throw wrapProviderError(error, "PORTO");
+    }
+  };
+  const sendTransaction = async (tx) => sendBatchTransaction([tx], false);
+  return {
+    smartAccountAddress: account.address,
+    signer: viemAccount,
+    chain,
+    mode: "7702",
+    provider: "PORTO",
+    sendBatchTransaction,
+    sendTransaction,
+    client: { portoAccount: account, portoClient }
+  };
+}
+export {
+  createPortoSmartAccount
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { createPortoSmartAccount } from './action.js';
+export type { PortoAccountConfig, CreatePortoSmartAccountParams, UsePortoSmartAccountParams } from './types.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+import { createPortoSmartAccount } from "./action.js";
+export {
+  createPortoSmartAccount
+};

package/dist/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/types.d.ts

@@ -0,0 +1,51 @@
+import type { ChainBasedSmartAccountConfig, CreateSmartAccountParams } from '@getpara/viem-v2-integration';
+/**
+ * Configuration for Porto smart account.
+ *
+ * EIP-7702 only. Uses Porto's relay (`https://rpc.porto.sh`). No API key required.
+ *
+ * Porto supports multiple chains including Base, Optimism, Arbitrum, Ethereum,
+ * and several testnets. See https://porto.sh/relay for the full list.
+ *
+ * @example
+ * ```ts
+ * const { smartAccount } = usePortoSmartAccount({ chain: baseSepolia });
+ * ```
+ */
+export interface PortoAccountConfig extends Omit<ChainBasedSmartAccountConfig, 'rpcUrl'> {
+    /**
+     * URL of your Porto merchant endpoint for gas sponsorship.
+     * The merchant account covers transaction fees for your users.
+     *
+     * Required for mainnet — without it, transactions will fail unless the user's
+     * account has native tokens to pay gas. On testnets, Porto's relay sponsors
+     * fees by default so this can be omitted during development.
+     *
+     * See https://porto.sh/sdk/guides/sponsoring for setup instructions.
+     *
+     * @example '/porto/merchant'
+     * @example 'https://myapi.com/porto/merchant'
+     */
+    merchantUrl?: string;
+    /**
+     * ERC-20 token address used to pay gas fees.
+     *
+     * On Base Sepolia testnet, use Porto's EXP token:
+     * `0xfca413a634c4df6b98ebb970a44d9a32f8f5c64e`
+     *
+     * When omitted, Porto's relay uses native gas sponsorship via the ORCHESTRATOR
+     * contract. If the ORCHESTRATOR is not deployed on the target chain (e.g. Base
+     * Sepolia), transactions will fail. Providing a feeToken bypasses this path.
+     */
+    feeToken?: `0x${string}`;
+}
+/**
+ * Parameters for `createPortoSmartAccount`.
+ * Includes all config fields plus `para` (the Para SDK instance).
+ */
+export type CreatePortoSmartAccountParams = CreateSmartAccountParams<PortoAccountConfig>;
+/**
+ * Parameters for the `usePortoSmartAccount` hook.
+ * Same as {@link PortoAccountConfig} — `para` is provided automatically via context.
+ */
+export type UsePortoSmartAccountParams = PortoAccountConfig;

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@getpara/aa-porto",
+  "version": "2.16.0",
+  "description": "Porto smart account integration for Para",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf dist && yarn typegen && node ./scripts/build.mjs",
+    "typegen": "tsc --emitDeclarationOnly --outDir dist",
+    "test": "vitest run --coverage"
+  },
+  "dependencies": {
+    "@getpara/viem-v2-integration": "2.16.0",
+    "porto": "^0.2.37"
+  },
+  "peerDependencies": {
+    "viem": ">=2.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "fbe96a062b308d04105213378c12c38ee973c798"
+}