@inco/shield-js 0.1.0 → 0.2.0

package/dist/shield/types.d.ts

@@ -1,119 +1,24 @@
 import type { Transport as ConnectTransport } from '@connectrpc/connect';
-import type { Hex, Transport as ViemTransport, WalletClient } from 'viem';
-/** Minimal signer interface, structurally compatible with viem LocalAccount. */
+import type { Hex, TypedDataDefinition, Transport as ViemTransport, WalletClient } from 'viem';
 export interface ShieldSigner {
     address: Hex;
     sign(params: {
         hash: Hex;
     }): Promise<Hex>;
 }
-/**
- * Accepted signer types. Either:
- * - A viem `WalletClient` (browser wallets or backend with privateKeyToAccount)
- * - A `ShieldSigner` (custom signer with raw hash signing)
- */
+export interface ResolvedSigner {
+    address: Hex;
+    signTypedData(typedData: TypedDataDefinition): Promise<Hex>;
+}
 export type ShieldSignerInput = WalletClient | ShieldSigner;
-/** Configuration for creating a ShieldClient. */
 export interface ShieldConfig {
     grpcTransport: ConnectTransport;
-    /**
-     * RPC transport for Ethereum-compatible chains.
-     */
     viemTransport?: ViemTransport;
     chainId: bigint;
     shieldAddress: Hex;
     signer: ShieldSignerInput;
-    /**
-     * Serialized TEE public key for encrypting envelopes (known out of band).
-     * TODO: SDK should fetch this from the IncoShield contract rather than
-     * requiring it as config. Tracked separately.
-     */
     teePublicKey: Uint8Array;
-    /** Bundler URL. Defaults to the Pimlico public bundler if not provided. */
     bundlerUrl?: string;
+    feeAccrualAdapter: Hex;
+    protocolFeeTreasury: Hex;
 }
-/** Parameters for the `getBalance` RPC call. */
-export interface GetBalanceParams {
-    address: Hex;
-    assetId: Hex;
-    /** Query balance at a specific block. Defaults to latest. */
-    atBlock?: bigint;
-}
-/** Balance breakdown for an account and asset. */
-export interface Balance {
-    confirmed: bigint;
-    pending: bigint;
-    available: bigint;
-}
-/**
- * Per-issuance salt — 32-byte hex. Distinguishes intents that are otherwise
- * field-identical and gives `permissionId` cryptographic unguessability against
- * outside observers of revocation events.
- */
-export type Salt = Hex;
-/**
- * Owner's terms for a delegated-spend grant. Owner signs this struct (EIP-712)
- * once and submits it to the TEE during issuance; the TEE returns a
- * `PermissionAttestation` and the spender carries that attestation thereafter.
- *
- * `permissionId` is recomputed from these fields by both sides; it is not
- * carried in the intent itself. The TEE's `draftingHandle` anchor is chosen
- * at issuance from enclave state, not supplied by the user.
- *
- * @deprecated
- * TODO: Remove as part of https://github.com/Inco-fhevm/shield/issues/499
- */
-export interface PermissionIntent {
-    owner: Hex;
-    spender: Hex;
-    assetId: Hex;
-    allowance: bigint;
-    start: bigint;
-    end: bigint;
-    period: bigint;
-    agreementHash: Hex;
-    salt: Salt;
-    intentExpiry: bigint;
-}
-/** Parameters for the `requestDepositAttestation` RPC call. */
-export interface RequestDepositAttestationParams {
-    recipient: Hex;
-    assetAdapter: Hex;
-    assetIdentificationArgs: Hex;
-    memo: Hex;
-    escapeHatch: Hex;
-}
-/** TEE-issued deposit attestation: ciphertext for the recipient and signature over it. */
-export interface DepositAttestation {
-    toCiphertext: Hex;
-    teeSignature: Hex;
-}
-export interface GetPermissionsByOwnerParams {
-    includeExpired?: boolean;
-}
-export interface GetPermissionsBySpenderParams {
-    includeExpired?: boolean;
-}
-export type PermissionStatusType = 'unspecified' | 'active' | 'not_yet_active' | 'expired' | 'revoked' | 'generation_revoked';
-export interface PermissionInfo {
-    permissionId: Hex;
-    owner: Hex;
-    spender: Hex;
-    assetId: Hex;
-    allowance: bigint;
-    start: bigint;
-    end: bigint;
-    period: bigint;
-    agreementHash: Hex;
-    spentInCurrentPeriod: bigint;
-    availableAllowance: bigint;
-    status: PermissionStatusType;
-}
-export interface GetPermissionDetailsParams {
-    permissionId: Hex;
-}
-export interface PermissionDetails {
-    permission: PermissionInfo;
-    found: boolean;
-}
-export { ShieldError } from '../errors.js';

package/dist/shield/types.js

@@ -1,4 +1 @@
-// ---------------------------------------------------------------------------
-// Errors (re-export — concrete classes live in `../errors.ts`)
-// ---------------------------------------------------------------------------
-export { ShieldError } from '../errors.js';
+export {};

package/dist/shield/userop/gas-estimation.d.ts

@@ -1,21 +1,14 @@
-/**
- * Constitution: Creates an intent with gas estimation.
- *
- * The flow is:
- * 1. Create a placeholder UserOp from the user's intent op
- * 2. Get the gas estimate from the bundler using the placeholder UserOp
- * 3. Assemble the final intent with the gas estimate
- */
 import { type Address, type Hex, type PublicClient } from 'viem';
 import { type UserOperation } from 'viem/account-abstraction';
 import type { IntentOp, UserGasParams } from '../intent.js';
-import type { ShieldConfig, ShieldSigner } from '../types.js';
+import type { ShieldConfig } from '../types.js';
 declare const ENTRYPOINT_VERSION = "0.7";
-/** Placeholder `abi.encode(bytes[] signers, bytes[] sigs)`. Real signer addresses
- *  required: OZ's `isSigner` check runs before any `ecrecover`, so zero-address
- *  signers short-circuit the validation loop and under-quote gas. */
+export interface EstimationPlaceholder {
+    readonly userOp: UserOperation<typeof ENTRYPOINT_VERSION>;
+    readonly signerCount: number;
+}
+export declare function reserveUnmeasuredSignatureGas(verificationGasLimit: bigint, signerCount: number): bigint;
 export declare function placeholderMultisig(signers: readonly Address[]): Hex;
-/** Exported for tests that pin the expected placeholder byte counts. */
 export declare const PLACEHOLDER_SIZES: {
     readonly transferCiphertext: number;
     readonly withdrawalCiphertext: number;
@@ -24,13 +17,5 @@ export declare const PLACEHOLDER_SIZES: {
     readonly erc20AssetIdentificationArgs: 32;
     readonly erc20MovementArgs: 32;
 };
-/**
- * Build an unsigned UserOp for bundler gas estimation.
- *
- * Invariant: every wire-shape field matches the size of what the conductor will
- * submit. Cheque fields are sized against worst-case plaintexts (over-estimate,
- * never under); adapter args are ERC-20-sized — new adapters need entries in
- * `PLACEHOLDER_SIZES`.
- */
-export declare function userOpFromIntentForGasEstimation(intentOp: IntentOp, signer: ShieldSigner, shieldConfig: ShieldConfig, publicClient: PublicClient, gas: UserGasParams): Promise<UserOperation<typeof ENTRYPOINT_VERSION>>;
+export declare function userOpFromIntentForGasEstimation(intentOp: IntentOp, shieldConfig: ShieldConfig, publicClient: PublicClient, gas: UserGasParams, paymaster?: Address): Promise<EstimationPlaceholder>;
 export {};

package/dist/shield/userop/gas-estimation.js

@@ -1,110 +1,83 @@
-/**
- * Constitution: Creates an intent with gas estimation.
- *
- * The flow is:
- * 1. Create a placeholder UserOp from the user's intent op
- * 2. Get the gas estimate from the bundler using the placeholder UserOp
- * 3. Assemble the final intent with the gas estimate
- */
-import { bytesToHex, concat, encodeAbiParameters, isAddress, isHex, maxUint64, maxUint256, zeroAddress, zeroHash, } from 'viem';
+import { bytesToHex, concat, encodeAbiParameters, isAddress, maxUint64, maxUint256, zeroAddress, zeroHash, } from 'viem';
 import { entryPoint07Abi, entryPoint07Address, } from 'viem/account-abstraction';
-import { incoShieldAbi, shieldAbiStubAbi, teeSmartAccountAbi, } from '../../contracts/abi.js';
-import { getAbiFromUnitFunction } from '../../contracts/utils.js';
+import { incoShieldAbi, teeSmartAccountAbi } from '../../contracts/abi.js';
+import { erc20Asset, NATIVE_ASSET } from '../../contracts/utils.js';
 import { InvalidContractReturnType } from '../../errors.js';
 import { IntentKind } from '../../generated/inco/shield/v2/drafting_pb.js';
+import { encodeStruct } from '../abi.js';
 import { chequeBlobSize } from '../encryption.js';
 import { assembleUserOp, buildUnsignedUserOp } from './userOp.js';
+const ESTIMATION_STUB_PAYMASTER_DATA = encodeAbiParameters([{ type: 'bytes' }, { type: 'bytes' }], ['0x', '0x']);
 const ENTRYPOINT_VERSION = '0.7';
-/** Pimlico-style dummy ECDSA sig: EIP-2 canonical `s` keeps OZ's
- * `ECDSA.tryRecover` on the `ecrecover` path (else verification gas under-quotes). */
+const GENESIS_HANDLE = zeroHash;
+const PER_SIGNATURE_VERIFICATION_GAS = 4000n;
+export function reserveUnmeasuredSignatureGas(verificationGasLimit, signerCount) {
+    const unmeasuredSignatures = BigInt(Math.max(0, signerCount - 1));
+    return (verificationGasLimit + unmeasuredSignatures * PER_SIGNATURE_VERIFICATION_GAS);
+}
 const PLACEHOLDER_ECDSA_SIG = concat([
-    bytesToHex(new Uint8Array(32).fill(0xff)), // r
-    `0x7${'a'.repeat(63)}`, // s (top nibble 0x7 → s < n/2)
-    '0x1c', // v
+    bytesToHex(new Uint8Array(32).fill(0xff)),
+    `0x7${'a'.repeat(63)}`,
+    '0x1c',
 ]);
-/** Placeholder `abi.encode(bytes[] signers, bytes[] sigs)`. Real signer addresses
- *  required: OZ's `isSigner` check runs before any `ecrecover`, so zero-address
- *  signers short-circuit the validation loop and under-quote gas. */
 export function placeholderMultisig(signers) {
     const sigs = signers.map(() => PLACEHOLDER_ECDSA_SIG);
     return encodeAbiParameters([{ type: 'bytes[]' }, { type: 'bytes[]' }], [signers, sigs]);
 }
-/**
- * Given a plaintext encoded as a 0x-prefixed hex string, return the ciphertext size.
- */
 function ptToCtSize(pt) {
-    // TODO FIXME https://github.com/Inco-fhevm/shield/issues/496
-    // We should use ciphertext size.
-    return chequeBlobSize(pt.length / 2 - 1); // Hex to bytes length
+    return chequeBlobSize(pt.length / 2 - 1);
 }
-const TRANSFER_PLAINTEXT = encodeAbiParameters([getAbiFromUnitFunction(shieldAbiStubAbi, 'transferPlaintext')], [
-    {
-        sender: zeroAddress,
-        receiver: zeroAddress,
-        amount: maxUint256,
-        assetId: zeroHash,
-    },
-]);
-const WITHDRAWAL_PLAINTEXT = encodeAbiParameters([getAbiFromUnitFunction(shieldAbiStubAbi, 'withdrawalPlaintext')], [{ sender: zeroAddress }]);
-const SENDER_ESCAPE_PLAINTEXT = encodeAbiParameters([getAbiFromUnitFunction(shieldAbiStubAbi, 'senderEscapePlaintext')], [
-    {
-        sender: zeroAddress,
-        assetId: zeroHash,
-        draftingHandle: zeroHash,
-        spendAmount: maxUint256,
-        balanceSnapshot: maxUint256,
-        chequeNumber: maxUint64,
-        oldestPossiblyOutstanding: maxUint64,
-    },
-]);
-const RECEIVER_ESCAPE_PLAINTEXT = encodeAbiParameters([getAbiFromUnitFunction(shieldAbiStubAbi, 'receiverEscapePlaintext')], [
-    {
-        receiver: zeroAddress,
-        assetId: zeroHash,
-        draftingHandle: zeroHash,
-        receiveAmount: maxUint256,
-        balanceSnapshot: maxUint256,
-        chequeNullifier: zeroHash,
-        senderChequeNumber: maxUint64,
-        oldestPossiblyOutstandingSend: maxUint64,
-    },
-]);
-const INDIVIDUAL_REVOCATION_PLAINTEXT = encodeAbiParameters([getAbiFromUnitFunction(shieldAbiStubAbi, 'individualRevocationPlaintext')], [{ owner: zeroAddress, permissionId: zeroHash }]);
-const USER_WIDE_REVOCATION_PLAINTEXT = encodeAbiParameters([getAbiFromUnitFunction(shieldAbiStubAbi, 'userWideRevocationPlaintext')], [{ owner: zeroAddress }]);
-/** `abi.encode(address)` is one ABI word (32 bytes) regardless of adapter. */
+const TRANSFER_PLAINTEXT = encodeStruct('TransferPlaintext', {
+    sender: zeroAddress,
+    receiver: zeroAddress,
+    amount: maxUint256,
+    assetId: zeroHash,
+});
+const WITHDRAWAL_PLAINTEXT = encodeStruct('WithdrawalPlaintext', {
+    sender: zeroAddress,
+});
+const SENDER_ESCAPE_PLAINTEXT = encodeStruct('SenderEscapePlaintext', {
+    sender: zeroAddress,
+    assetId: zeroHash,
+    draftingHandle: zeroHash,
+    spendAmount: maxUint256,
+    balanceSnapshot: maxUint256,
+    chequeNumber: maxUint64,
+    oldestPossiblyOutstanding: maxUint64,
+});
+const RECEIVER_ESCAPE_PLAINTEXT = encodeStruct('ReceiverEscapePlaintext', {
+    receiver: zeroAddress,
+    assetId: zeroHash,
+    draftingHandle: zeroHash,
+    receiveAmount: maxUint256,
+    balanceSnapshot: maxUint256,
+    chequeNullifier: zeroHash,
+    senderChequeNumber: maxUint64,
+    oldestPossiblyOutstandingSend: maxUint64,
+});
+const INDIVIDUAL_REVOCATION_PLAINTEXT = encodeStruct('IndividualRevocationPlaintext', { owner: zeroAddress, permissionId: zeroHash });
+const USER_WIDE_REVOCATION_PLAINTEXT = encodeStruct('UserWideRevocationPlaintext', {
+    owner: zeroAddress,
+});
 const ERC20_ASSET_IDENTIFICATION_ARGS_SIZE = 32;
-/** `abi.encode(uint256)` is one ABI word (32 bytes). */
 const ERC20_MOVEMENT_ARGS_SIZE = 32;
-/** Non-zero hex of `byteLength` bytes. Zero bytes cost 4 gas vs 16 for non-zero,
- *  so `zeroHash`-style placeholders under-quote calldata gas by ~4×. */
 function nonZeroPlaceholder(byteLength) {
     return bytesToHex(new Uint8Array(byteLength).fill(0xaa));
 }
-/** Build a placeholder {@link SettlementOp} from an `IntentOp`: intent-supplied fields
- *  (memo, recipient, asset movement, …) are real; enclave-derived fields use
- *  worst-case-sized placeholders so the estimate never under-quotes. Per-kind
- *  cases keep TS narrowing intact across the discriminated union.
- *
- *  `draftingHandle` must be a handle known on-chain — `IncoShield.transfer` and
- *  `processWithdrawalCore` revert with `PastShieldHandleNotFound` against an
- *  unknown handle. Caller reads the live handle via `IncoShield.getHandle()` and
- *  threads it in, though it need not be the handle the enclave ultimately drafts
- *  against. `bytes32` slots use a nonzero placeholder so calldata gas (16/byte)
- *  matches the eventual real values rather than zero bytes (4/byte). */
-function toPlaceholderSettlementOp(intentOp, currentHandle) {
+function toPlaceholderSettlementOp(intentOp) {
     switch (intentOp.kind) {
         case IntentKind.TRANSFER:
         case IntentKind.DELEGATED_TRANSFER:
             return {
                 kind: intentOp.kind,
-                op: transferPlaceholder(intentOp.op.memo, currentHandle),
+                op: transferPlaceholder(intentOp.op.memo),
             };
         case IntentKind.WITHDRAW:
         case IntentKind.DELEGATED_WITHDRAW:
             return {
                 kind: intentOp.kind,
                 op: {
-                    core: withdrawalCorePlaceholder(intentOp.op.core, currentHandle),
+                    core: withdrawalCorePlaceholder(intentOp.op.core),
                     memo: intentOp.op.memo,
                 },
             };
@@ -113,7 +86,7 @@ function toPlaceholderSettlementOp(intentOp, currentHandle) {
             return {
                 kind: intentOp.kind,
                 op: {
-                    withdrawal: withdrawalCorePlaceholder(intentOp.op.withdrawal, currentHandle),
+                    withdrawal: withdrawalCorePlaceholder(intentOp.op.withdrawal),
                     defiAdapter: intentOp.op.defiAdapter,
                     adapterArgs: intentOp.op.adapterArgs,
                     memo: intentOp.op.memo,
@@ -139,9 +112,9 @@ function toPlaceholderSettlementOp(intentOp, currentHandle) {
             };
     }
 }
-function transferPlaceholder(memo, currentHandle) {
+function transferPlaceholder(memo) {
     return {
-        draftingHandle: currentHandle,
+        draftingHandle: GENESIS_HANDLE,
         draftingTimestamp: maxUint64,
         nullifier: nonZeroPlaceholder(32),
         senderEscapeCommitment: nonZeroPlaceholder(32),
@@ -152,20 +125,18 @@ function transferPlaceholder(memo, currentHandle) {
         memo,
     };
 }
-function withdrawalCorePlaceholder(core, currentHandle) {
+function withdrawalCorePlaceholder(core) {
     return {
-        to: core.to,
+        asset: core.asset,
+        assetMovements: core.assetMovements,
         nullifier: nonZeroPlaceholder(32),
-        amount: maxUint256,
-        draftingHandle: currentHandle,
+        draftingHandle: GENESIS_HANDLE,
         draftingTimestamp: maxUint64,
-        assetMovement: core.assetMovement,
         ciphertext: nonZeroPlaceholder(ptToCtSize(WITHDRAWAL_PLAINTEXT)),
         senderEscapeCommitment: nonZeroPlaceholder(32),
         senderEscapeData: nonZeroPlaceholder(ptToCtSize(SENDER_ESCAPE_PLAINTEXT)),
     };
 }
-/** Exported for tests that pin the expected placeholder byte counts. */
 export const PLACEHOLDER_SIZES = {
     transferCiphertext: ptToCtSize(TRANSFER_PLAINTEXT),
     withdrawalCiphertext: ptToCtSize(WITHDRAWAL_PLAINTEXT),
@@ -174,23 +145,22 @@ export const PLACEHOLDER_SIZES = {
     erc20AssetIdentificationArgs: ERC20_ASSET_IDENTIFICATION_ARGS_SIZE,
     erc20MovementArgs: ERC20_MOVEMENT_ARGS_SIZE,
 };
-/**
- * Build an unsigned UserOp for bundler gas estimation.
- *
- * Invariant: every wire-shape field matches the size of what the conductor will
- * submit. Cheque fields are sized against worst-case plaintexts (over-estimate,
- * never under); adapter args are ERC-20-sized — new adapters need entries in
- * `PLACEHOLDER_SIZES`.
- */
-export async function userOpFromIntentForGasEstimation(intentOp, signer, shieldConfig, publicClient, gas) {
-    const [nonce, signersForPlaceholder, currentHandle, paymasterGasLimits] = await Promise.all([
-        getEntryPointNonce(publicClient, signer.address),
-        getQuorumSignersForPlaceholder(publicClient, signer.address),
-        getCurrentHandle(publicClient, shieldConfig.shieldAddress),
+export async function userOpFromIntentForGasEstimation(intentOp, shieldConfig, publicClient, gas, paymaster) {
+    const teeSmartAccount = await getTeeSmartAccount(publicClient, shieldConfig.shieldAddress);
+    const [nonce, signersForPlaceholder, paymasterGasLimits] = await Promise.all([
+        getEntryPointNonce(publicClient, teeSmartAccount),
+        getQuorumSignersForPlaceholder(publicClient, teeSmartAccount),
         getPaymasterGasLimits(),
     ]);
     const placeholderGas = {
-        ...gas,
+        asset: gas.feeToken === undefined ? NATIVE_ASSET : erc20Asset(gas.feeToken),
+        assetMovement: {
+            account: zeroAddress,
+            assetAdapter: zeroAddress,
+            movementArgs: '0x',
+        },
+        maxFeePerGas: gas.maxFeePerGas,
+        maxPriorityFeePerGas: gas.maxPriorityFeePerGas,
         callGasLimit: 0n,
         verificationGasLimit: 0n,
         preVerificationGas: 0n,
@@ -198,16 +168,26 @@ export async function userOpFromIntentForGasEstimation(intentOp, signer, shieldC
         paymasterPostOpGasLimit: paymasterGasLimits.paymasterPostOpGasLimit,
         maxAmount: 0n,
     };
+    const paymasterFields = paymaster === undefined
+        ? undefined
+        : {
+            paymaster,
+            paymasterVerificationGasLimit: paymasterGasLimits.paymasterVerificationGasLimit,
+            paymasterPostOpGasLimit: paymasterGasLimits.paymasterPostOpGasLimit,
+            paymasterData: ESTIMATION_STUB_PAYMASTER_DATA,
+        };
     const unsigned = buildUnsignedUserOp({
-        settlementOp: toPlaceholderSettlementOp(intentOp, currentHandle),
-        sender: signer.address,
+        settlementOp: toPlaceholderSettlementOp(intentOp),
+        sender: teeSmartAccount,
         nonce,
         shieldAddress: shieldConfig.shieldAddress,
         gas: placeholderGas,
+        paymaster: paymasterFields,
     });
-    return assembleUserOp(unsigned, placeholderMultisig(signersForPlaceholder));
-    /** Read the v0.7 EntryPoint sequential nonce for `sender` under default key 0. */
-    // TODO: implement of parrallelised (2D nonce behaviour) using some random key dont use 0 @chiranjeev13
+    return {
+        userOp: assembleUserOp(unsigned, placeholderMultisig(signersForPlaceholder)),
+        signerCount: signersForPlaceholder.length,
+    };
     async function getEntryPointNonce(publicClient, sender) {
         const nonce = await publicClient.readContract({
             address: entryPoint07Address,
@@ -224,23 +204,13 @@ export async function userOpFromIntentForGasEstimation(intentOp, signer, shieldC
         }
         return nonce;
     }
-    /** Read the TEE quorum signers from `TeeSmartAccount` and slice to threshold T.
-     *  Real addresses let the bundler's `isSigner` loop traverse fully before
-     *  short-circuiting on `DUMMY_ECDSA_SIG`. */
     async function getQuorumSignersForPlaceholder(publicClient, account) {
-        const [signersRaw, thresholdRaw] = await Promise.all([
-            publicClient.readContract({
-                address: account,
-                abi: teeSmartAccountAbi,
-                functionName: 'getSigners',
-                args: [0n, maxUint64],
-            }),
-            publicClient.readContract({
-                address: account,
-                abi: teeSmartAccountAbi,
-                functionName: 'threshold',
-            }),
-        ]);
+        const signersRaw = await publicClient.readContract({
+            address: account,
+            abi: teeSmartAccountAbi,
+            functionName: 'getSigners',
+            args: [0n, maxUint64],
+        });
         if (!Array.isArray(signersRaw) ||
             !signersRaw.every((s) => isAddress(s))) {
             throw new InvalidContractReturnType({
@@ -249,29 +219,22 @@ export async function userOpFromIntentForGasEstimation(intentOp, signer, shieldC
                 expectedType: 'readonly Address[]',
             });
         }
-        if (typeof thresholdRaw !== 'bigint') {
-            throw new InvalidContractReturnType({
-                message: `TeeSmartAccount.threshold returned non-bigint: ${typeof thresholdRaw}`,
-                functionName: 'TeeSmartAccount.threshold',
-                expectedType: 'bigint',
-            });
-        }
-        return signersRaw.slice(0, Number(thresholdRaw));
+        return signersRaw;
     }
-    async function getCurrentHandle(publicClient, shieldAddress) {
-        const handle = await publicClient.readContract({
+    async function getTeeSmartAccount(publicClient, shieldAddress) {
+        const account = await publicClient.readContract({
             address: shieldAddress,
             abi: incoShieldAbi,
-            functionName: 'getHandle',
+            functionName: 'teeSmartAccount',
         });
-        if (!isHex(handle) || handle.length !== 66) {
+        if (!isAddress(account)) {
             throw new InvalidContractReturnType({
-                message: `IncoShield.getHandle returned non-bytes32: ${String(handle)}`,
-                functionName: 'IncoShield.getHandle',
-                expectedType: 'Hex (bytes32)',
+                message: `IncoShield.teeSmartAccount returned a non-address: ${String(account)}`,
+                functionName: 'IncoShield.teeSmartAccount',
+                expectedType: 'Address',
             });
         }
-        return handle;
+        return account;
     }
     async function getPaymasterGasLimits() {
         const defaultPMVerificationGasLimit = 100000n;

package/dist/shield/userop/paymaster.d.ts

@@ -0,0 +1,15 @@
+import { type Address, type Hex } from 'viem';
+import type { Gas, Withdrawal } from '../shield.eip712.gen.js';
+export type BuildPaymasterDataParams = {
+    paymaster: Address;
+    gas: Gas;
+    withdrawal: Withdrawal;
+    teeSignature?: Hex;
+};
+export type PaymasterFields = {
+    paymaster: Address;
+    paymasterVerificationGasLimit: bigint;
+    paymasterPostOpGasLimit: bigint;
+    paymasterData: Hex;
+};
+export declare function buildPaymasterData(params: BuildPaymasterDataParams): PaymasterFields;

package/dist/shield/userop/paymaster.js

@@ -0,0 +1,17 @@
+import { encodeAbiParameters } from 'viem';
+import { encodeStruct } from '../abi.js';
+const paymasterDataAbiParams = [{ type: 'bytes' }, { type: 'bytes' }];
+export function buildPaymasterData(params) {
+    return {
+        paymaster: params.paymaster,
+        paymasterVerificationGasLimit: params.gas.paymasterVerificationGasLimit,
+        paymasterPostOpGasLimit: params.gas.paymasterPostOpGasLimit,
+        paymasterData: encodeAbiParameters(paymasterDataAbiParams, [
+            encodeWithdrawal(params.withdrawal),
+            params.teeSignature ?? '0x',
+        ]),
+    };
+}
+function encodeWithdrawal(withdrawal) {
+    return encodeStruct('Withdrawal', withdrawal);
+}

package/dist/shield/userop/token-exchange.d.ts

@@ -1,54 +1,7 @@
-import { type Address, type Hex, type PublicClient } from 'viem';
-export type AggregatorRate = {
-    readonly answer: bigint;
-    readonly decimals: number;
-    readonly updatedAt: bigint;
-    readonly description: string;
-};
-/**
- * Fetch the latest price from a single Chainlink aggregator contract.
- *
- * The aggregator's `description` (e.g. "ETH / USD") encodes the pair —
- * there is no on-chain way to enforce that callers passed the right address.
- */
-export declare function getAggregatorRate(publicClient: PublicClient, aggregator: Address): Promise<AggregatorRate>;
-declare const UnknownAssetFeed_base: new <Fields extends Record<string, unknown>>(fields: Fields) => Error & {
-    readonly _tag: "UnknownAssetFeed";
-} & Readonly<Fields>;
-export declare class UnknownAssetFeed extends UnknownAssetFeed_base<{
-    readonly assetId: Hex;
-}> {
-}
-/**
- * Resolve the Chainlink aggregator for a Shield `assetId` (= ERC-20 token
- * address padded to bytes32) and return its latest rate.
- */
-export declare function getAssetRate(publicClient: PublicClient, assetId: Hex): Promise<AggregatorRate>;
-/** RAY = 1e27, the fixed-point scale used by the Shield paymaster. */
+import { type Address, type PublicClient } from 'viem';
+export declare function getPaymasterAssetAdapter(publicClient: PublicClient, paymaster: Address): Promise<Address>;
+export declare function assertFeeTokenSupported(publicClient: PublicClient, paymaster: Address, token: Address): Promise<void>;
 export declare const RAY: bigint;
-/**
- * Compute the RAY-precision exchange rate (ETH priced in token units)
- * that the Shield paymaster consumes. Mirrors the on-chain convention
- * from SHIELD_PAYMASTER.md:
- *
- *     tokenAmount = ceil(gasCostWei * exchangeRate / 1e27)
- *
- * Worked example: if 1 ETH = 2000 USDC and USDC has 6 decimals,
- *     exchangeRate = 2000 * 1e6 * 1e27 / 1e18 = 2e18
- *
- * Derivation here uses two Chainlink USD feeds:
- *     ethInToken (real) = ethUsd / tokenUsd
- *     rate (RAY)        = ethInToken * 10^tokenDec * 1e27 / 1e18
- *                       = ethUsd * 10^tokenDec * 10^tokenFeedDec * RAY
- *                         / (tokenUsd * 10^ethFeedDec * 1e18)
- */
-export declare function getEthExchangeRateRay(publicClient: PublicClient, assetId: Hex): Promise<bigint>;
-/** `ceil(ethWei * exchangeRate / RAY)` — matches the paymaster's rounding. */
+export declare function getEthExchangeRateRay(publicClient: PublicClient, paymaster: Address, token: Address): Promise<bigint>;
 export declare function applyExchangeRateRayCeil(ethWei: bigint, exchangeRateRay: bigint): bigint;
-/**
- * Convenience: fetch the RAY rate for `assetId` and apply it to `ethWei`.
- * Use `getEthExchangeRateRay` directly when the caller also needs to
- * forward the rate to the paymaster signer.
- */
-export declare function convertEthWeiToTokenUnits(publicClient: PublicClient, assetId: Hex, ethWei: bigint): Promise<bigint>;
-export {};
+export declare function convertEthWeiToTokenUnits(publicClient: PublicClient, paymaster: Address, token: Address, ethWei: bigint): Promise<bigint>;