@inco/shield-js 0.0.0-bootstrap.0 → 0.2.0

package/dist/shield/rpc.js

@@ -1,39 +1,37 @@
-import { decodeAbiParameters, encodeAbiParameters, keccak256, toHex, } from 'viem';
+import { create, fromBinary, toBinary } from '@bufbuild/protobuf';
+import { encodeAbiParameters, keccak256, zeroHash, } from 'viem';
 import { bytesToHex, hexToBytes } from '../binary.js';
-import { shieldAbiStubAbi as incoShieldAbi } from '../contracts/abi.js';
-import { computeErc20AssetId, getAbiFromUnitFunction, } from '../contracts/utils.js';
-import { CovalidatorError, ShieldError } from '../errors.js';
-import { RequestDepositAttestationRequest, RequestDepositAttestationResponse, } from '../generated/inco/shield/v2/deposit_pb.js';
-import { DraftRequest, DraftResponse, IntentKind, } from '../generated/inco/shield/v2/drafting_pb.js';
-import { GetOwnerGenerationRequest, GetOwnerGenerationResponse, GetPermissionDetailsRequest, GetPermissionDetailsResponse, GetPermissionsByOwnerRequest, GetPermissionsBySpenderRequest, GetPermissionsResponse, RequestPermissionAttestationRequest, RequestPermissionAttestationResponse, } from '../generated/inco/shield/v2/permission_pb.js';
-import { GetBalanceRequest, GetBalanceResponse, } from '../generated/inco/shield/v2/query_pb.js';
-import { Address as ProtoAddress, AssetId as ProtoAssetId, } from '../generated/inco/shield/v2/types_pb.js';
-import { parseBalance, parseOwnerGeneration, parsePermissionDetails, parsePermissions, parseUserOp07, } from './convert.js';
-import { decryptResponse, generateRandomSalt, generateResponseKey, makeEnvelope, } from './envelope.js';
-import { encodeIntent } from './intent.js';
-import { balanceQueryDigest, delegatedTransferIntentDigest, delegatedWithdrawalIntentDigest, depositAttestationRequestDigest, getOwnerGenerationDigest, getPermissionDetailsDigest, getPermissionsByOwnerDigest, getPermissionsBySpenderDigest, individualRevocationIntentDigest, permissionAttestationRequestDigest, transferIntentDigest, userWideRevocationIntentDigest, withdrawalIntentDigest, } from './shield.eip712.gen.js';
-/**
- * `permissionId = keccak256(abi.encode(...))` over the 9 identity fields. Must
- * match the umbo helper bit-for-bit; cross-checked in `sdk/test/permission-id.test.ts`.
- *
- * Off-chain only — no on-chain code recomputes this.
- */
+import { InvalidWithdrawalIntentOp, ShieldError } from '../errors.js';
+import { GetLatestHandleRequestSchema, } from '../generated/inco/shield/v2/conductor_pb.js';
+import { DepositAttestationRequestSchema } from '../generated/inco/shield/v2/deposit_pb.js';
+import { DraftRequestSchema, DraftResponseSchema, IntentKind, } from '../generated/inco/shield/v2/drafting_pb.js';
+import { AddressSchema, } from '../generated/inco/shield/v2/types_pb.js';
+import { decodeStruct, encodeStruct } from './abi.js';
+import { parseUserOp07 } from './convert.js';
+import { openAead } from './encryption.js';
+import { generateRandomSalt, generateResponseKey, makeEnvelope, openSignedResponse, } from './envelope.js';
+import { withProtocolFeeLeg } from './fee.js';
+import { createDelegatedTransferIntent, createDelegatedWithdrawIntent, createIndividualRevocationIntent, createTransferIntent, createUserWideRevocationIntent, createWithdrawIntent, encodeIntent, } from './intent.js';
+import { EIP712_TYPES, } from './shield.eip712.gen.js';
+import { assertWithdrawalSplitMatchesIntent } from './validate-withdrawal-split.js';
 export function computePermissionId(input) {
     return keccak256(encodeAbiParameters([
-        { type: 'address' }, // owner
-        { type: 'address' }, // spender
-        { type: 'bytes32' }, // assetId
-        { type: 'uint256' }, // allowance
-        { type: 'uint256' }, // start
-        { type: 'uint256' }, // end
-        { type: 'uint256' }, // period
-        { type: 'bytes32' }, // agreementHash
-        { type: 'bytes32' }, // salt
+        { type: 'address' },
+        { type: 'address' },
+        { type: 'bytes32' },
+        { type: 'uint256' },
+        { type: 'address[]' },
+        { type: 'uint256' },
+        { type: 'uint256' },
+        { type: 'uint256' },
+        { type: 'bytes32' },
+        { type: 'bytes32' },
     ], [
         input.owner,
         input.spender,
         input.assetId,
         input.allowance,
+        input.to,
         input.start,
         input.end,
         input.period,
@@ -41,383 +39,238 @@ export function computePermissionId(input) {
         input.salt,
     ]));
 }
-// ---------------------------------------------------------------------------
-// Issue (transfer)
-// ---------------------------------------------------------------------------
-// TODO: replace with real gas estimation
-// https://github.com/Inco-fhevm/shield/issues/669
-const TODO_GAS = {
-    assetId: '0x0000000000000000000000000000000000000000000000000000000000000000',
-    maxAmount: 0n,
-    callGasLimit: 2000000n,
-    verificationGasLimit: 1000000n,
-    preVerificationGas: 100000n,
-    paymasterVerificationGasLimit: 0n,
-    paymasterPostOpGasLimit: 0n,
-    maxFeePerGas: 30000000000n, // 30 gwei
-    maxPriorityFeePerGas: 1000000000n, // 1 gwei
-};
-export async function issueTransfer(ctx, intentOp) {
-    const intent = {
-        kind: IntentKind.TRANSFER,
-        op: intentOp,
-        signer: ctx.signer.address,
-        gas: TODO_GAS,
-        salt: generateRandomSalt(),
-    };
-    const digest = transferIntentDigest(intent, ctx.domainSeparator);
-    const signature = await ctx.signer.sign({ hash: digest });
-    const responseKey = generateResponseKey();
-    const draftRequest = new DraftRequest({
-        intent: new Uint8Array(hexToBytes(encodeIntent(IntentKind.TRANSFER, intent))),
-        intentKind: IntentKind.TRANSFER,
-        eip712Signature: new Uint8Array(hexToBytes(signature)),
-        responseKey,
+function signTypedIntent(ctx, primaryType, message) {
+    return ctx.signer.signTypedData({
+        domain: ctx.domain,
+        types: EIP712_TYPES,
+        primaryType,
+        message,
     });
-    const envelope = await makeEnvelope(ctx.teePublicKey, draftRequest);
-    const encResponse = await ctx.rpc.draft(envelope);
-    const response = await decryptResponse(encResponse, responseKey, DraftResponse);
-    return { userOp: parseUserOp07(response.userOp) };
 }
-// ---------------------------------------------------------------------------
-// IssueWithdraw
-// ---------------------------------------------------------------------------
-export async function issueWithdraw(ctx, intentOp) {
-    const intent = {
-        kind: IntentKind.WITHDRAW,
-        op: intentOp,
-        signer: ctx.signer.address,
-        gas: TODO_GAS,
-        salt: generateRandomSalt(),
-    };
-    const digest = withdrawalIntentDigest(intent, ctx.domainSeparator);
-    const signature = await ctx.signer.sign({ hash: digest });
+async function draft(ctx, intentKind, intent, signature) {
     const responseKey = generateResponseKey();
-    const draftRequest = new DraftRequest({
-        intent: new Uint8Array(hexToBytes(encodeIntent(IntentKind.WITHDRAW, intent))),
-        intentKind: IntentKind.WITHDRAW,
-        eip712Signature: new Uint8Array(hexToBytes(signature)),
-        responseKey,
-    });
-    const envelope = await makeEnvelope(ctx.teePublicKey, draftRequest);
-    const encResponse = await ctx.rpc.draft(envelope);
-    const response = await decryptResponse(encResponse, responseKey, DraftResponse);
-    return { userOp: parseUserOp07(response.userOp) };
+    const body = toBinary(DraftRequestSchema, create(DraftRequestSchema, {
+        intent: hexToBytes(encodeIntent(intentKind, intent)),
+        intentKind,
+    }));
+    const envelope = await makeEnvelope(ctx.teePublicKey, { eip712Signature: hexToBytes(signature), responseKey }, body);
+    const resp = await ctx.rpc.draft(envelope);
+    const plaintext = await openAead(responseKey, resp.nonce, resp.ciphertext);
+    return parseUserOp07(fromBinary(DraftResponseSchema, plaintext).userOp);
+}
+const DEFAULT_USER_GAS = {
+    maxFeePerGas: 30000000000n,
+    maxPriorityFeePerGas: 1000000000n,
+};
+function feeContextOf(config) {
+    return {
+        adapter: config.feeAccrualAdapter,
+        treasury: config.protocolFeeTreasury,
+    };
+}
+export async function issueTransfer(ctx, intentOp, gas = DEFAULT_USER_GAS) {
+    const intent = await createTransferIntent(intentOp, generateRandomSalt(), ctx.signer, ctx.shieldConfig, ctx.publicClient, gas, ctx.paymasterContext);
+    const signature = await signTypedIntent(ctx, 'TransferIntent', intent);
+    return { userOp: await draft(ctx, IntentKind.TRANSFER, intent, signature) };
+}
+export async function issueWithdraw(ctx, intentOp, gas = DEFAULT_USER_GAS) {
+    const intent = await createWithdrawIntent(withProtocolFeeLeg(intentOp, feeContextOf(ctx.shieldConfig)), generateRandomSalt(), ctx.signer, ctx.shieldConfig, ctx.publicClient, gas, ctx.paymasterContext);
+    const signature = await signTypedIntent(ctx, 'WithdrawalIntent', intent);
+    const userOp = await draft(ctx, IntentKind.WITHDRAW, intent, signature);
+    assertWithdrawalSplitMatchesIntent(userOp, intent, ctx.shieldConfig.shieldAddress);
+    return { userOp };
 }
-// ---------------------------------------------------------------------------
-// RequestPermissionAttestation
-// ---------------------------------------------------------------------------
-/**
- * Owner-side issuance flow: sign the intent, hand it to the TEE, receive a
- * long-lived `PermissionAttestation` for the spender. The spender presents
- * the attestation on every subsequent draft.
- *
- * Doc-mandated client cross-check: recompute `permissionId` locally from
- * intent terms and verify the TEE's returned attestation matches. A mismatch
- * means the TEE substituted a different identity — fail closed.
- */
 export async function requestPermissionAttestation(ctx, req) {
     const { permission } = req;
     if (ctx.signer.address.toLowerCase() !== permission.owner.toLowerCase()) {
         throw new ShieldError({
-            message: 'requestPermissionAttestation: signer.address must match intent.owner',
+            message: 'requestPermissionAttestation: signer.address must match permission.owner',
         });
     }
     const expectedPid = computePermissionId(permission);
-    const digest = permissionAttestationRequestDigest(req, ctx.domainSeparator);
-    const ownerSignature = await ctx.signer.sign({ hash: digest });
+    const ownerSignature = await signTypedIntent(ctx, 'PermissionRequest', req);
     const responseKey = generateResponseKey();
-    const permissionAttestationRequestBytes = encodeAbiParameters([getAbiFromUnitFunction(incoShieldAbi, 'permissionAttestationRequest')], [req]);
-    const request = new RequestPermissionAttestationRequest({
-        permissionAttestationRequestBytes: new Uint8Array(hexToBytes(permissionAttestationRequestBytes)),
-        eip712Signature: hexToBytes(ownerSignature),
-        responseKey,
-    });
-    const envelope = await makeEnvelope(ctx.teePublicKey, request);
-    const encResponse = await ctx.rpc.requestPermissionAttestation(envelope);
-    const response = await decryptResponse(encResponse, responseKey, RequestPermissionAttestationResponse);
-    const [attestation] = decodeAbiParameters([getAbiFromUnitFunction(incoShieldAbi, 'permissionAttestation')], toHex(response.permissionAttestationBytes));
-    if (attestation.payload.permissionId !== expectedPid) {
+    const envelope = await makeEnvelope(ctx.teePublicKey, { eip712Signature: hexToBytes(ownerSignature), responseKey }, hexToBytes(encodeStruct('PermissionRequest', req)));
+    const { body, teeSignature } = await openSignedResponse(await ctx.rpc.permit(envelope), responseKey);
+    const payload = decodeStruct('PermissionAttestationPayload', bytesToHex(body));
+    if (payload.permissionId !== expectedPid) {
         throw new ShieldError({
-            message: `requestPermissionAttestation: TEE returned mismatched permissionId (expected ${expectedPid}, got ${attestation.payload.permissionId})`,
+            message: `requestPermissionAttestation: TEE returned mismatched permissionId (expected ${expectedPid}, got ${payload.permissionId})`,
         });
     }
-    return attestation;
+    return { payload, signature: bytesToHex(teeSignature) };
 }
-// ---------------------------------------------------------------------------
-// IssueDelegatedTransfer
-// ---------------------------------------------------------------------------
-/**
- * Spender-side delegated transfer draft: sign the transfer intent, present the
- * owner's `PermissionAttestation` to the TEE, receive a spending note. The TEE
- * verifies the attestation signature and runs all 7 validation steps before
- * drafting the spend.
- */
-export async function issueDelegatedTransfer(ctx, intentOp, attestation) {
-    const intent = {
-        kind: IntentKind.DELEGATED_TRANSFER,
-        intent: {
-            op: intentOp,
-            signer: ctx.signer.address,
-            gas: TODO_GAS,
-            salt: generateRandomSalt(),
-        },
-        spender: ctx.signer.address,
-        attestation,
+export async function issueDelegatedTransfer(ctx, intentOp, permissionId, gas = DEFAULT_USER_GAS) {
+    const intent = await createDelegatedTransferIntent(intentOp, generateRandomSalt(), ctx.signer.address, permissionId, ctx.signer, ctx.shieldConfig, ctx.publicClient, gas, ctx.paymasterContext);
+    const spenderSignature = await signTypedIntent(ctx, 'DelegatedTransferIntent', intent);
+    return {
+        userOp: await draft(ctx, IntentKind.DELEGATED_TRANSFER, intent, spenderSignature),
     };
-    const digest = delegatedTransferIntentDigest(intent, ctx.domainSeparator);
-    const spenderSignature = await ctx.signer.sign({ hash: digest });
-    const responseKey = generateResponseKey();
-    const draftRequest = new DraftRequest({
-        intent: new Uint8Array(hexToBytes(encodeIntent(IntentKind.DELEGATED_TRANSFER, intent))),
-        intentKind: IntentKind.DELEGATED_TRANSFER,
-        eip712Signature: new Uint8Array(hexToBytes(spenderSignature)),
-        responseKey,
-    });
-    const envelope = await makeEnvelope(ctx.teePublicKey, draftRequest);
-    const encResponse = await ctx.rpc.draft(envelope);
-    const response = await decryptResponse(encResponse, responseKey, DraftResponse);
-    return { userOp: parseUserOp07(response.userOp) };
 }
-// ---------------------------------------------------------------------------
-// IssueDelegatedWithdraw
-// ---------------------------------------------------------------------------
-/**
- * The resulting cheque settles byte-identically to a direct withdraw —
- * observers cannot distinguish delegated from direct.
- */
-export async function issueDelegatedWithdraw(ctx, intentOp, attestation) {
-    const intent = {
-        kind: IntentKind.DELEGATED_WITHDRAW,
-        intent: {
-            op: intentOp,
-            signer: ctx.signer.address,
-            gas: TODO_GAS,
-            salt: generateRandomSalt(),
-        },
-        spender: ctx.signer.address,
-        attestation,
+export async function issueDelegatedWithdraw(ctx, intentOp, permissionId, gas = DEFAULT_USER_GAS) {
+    if (intentOp.core.assetMovements.length !== 1) {
+        throw new InvalidWithdrawalIntentOp({
+            message: `delegated withdrawal must carry exactly one recipient movement, got ${intentOp.core.assetMovements.length}`,
+        });
+    }
+    const intent = await createDelegatedWithdrawIntent(withProtocolFeeLeg(intentOp, feeContextOf(ctx.shieldConfig)), generateRandomSalt(), ctx.signer.address, permissionId, ctx.signer, ctx.shieldConfig, ctx.publicClient, gas, ctx.paymasterContext);
+    const spenderSignature = await signTypedIntent(ctx, 'DelegatedWithdrawalIntent', intent);
+    const userOp = await draft(ctx, IntentKind.DELEGATED_WITHDRAW, intent, spenderSignature);
+    assertWithdrawalSplitMatchesIntent(userOp, intent.intent, ctx.shieldConfig.shieldAddress);
+    return { userOp };
+}
+export async function revokeOne(ctx, params, gas = DEFAULT_USER_GAS) {
+    const intent = await createIndividualRevocationIntent({ permissionId: params.permissionId }, generateRandomSalt(), ctx.signer, ctx.shieldConfig, ctx.publicClient, gas, ctx.paymasterContext);
+    const signature = await signTypedIntent(ctx, 'IndividualRevocationIntent', intent);
+    return {
+        userOp: await draft(ctx, IntentKind.INDIVIDUAL_REVOCATION, intent, signature),
     };
-    const digest = delegatedWithdrawalIntentDigest(intent, ctx.domainSeparator);
-    const spenderSignature = await ctx.signer.sign({ hash: digest });
-    const responseKey = generateResponseKey();
-    const draftRequest = new DraftRequest({
-        intent: new Uint8Array(hexToBytes(encodeIntent(IntentKind.DELEGATED_WITHDRAW, intent))),
-        intentKind: IntentKind.DELEGATED_WITHDRAW,
-        eip712Signature: new Uint8Array(hexToBytes(spenderSignature)),
-        responseKey,
-    });
-    const envelope = await makeEnvelope(ctx.teePublicKey, draftRequest);
-    const encResponse = await ctx.rpc.draft(envelope);
-    const response = await decryptResponse(encResponse, responseKey, DraftResponse);
-    return { userOp: parseUserOp07(response.userOp) };
 }
-export async function revokeOne(ctx, params) {
-    const intent = {
-        kind: IntentKind.INDIVIDUAL_REVOCATION,
-        op: { permissionId: params.permissionId },
-        signer: ctx.signer.address,
-        gas: TODO_GAS,
-        salt: generateRandomSalt(),
+export async function revokeAll(ctx, gas = DEFAULT_USER_GAS) {
+    const intent = await createUserWideRevocationIntent({ empty: '0x' }, generateRandomSalt(), ctx.signer, ctx.shieldConfig, ctx.publicClient, gas, ctx.paymasterContext);
+    const signature = await signTypedIntent(ctx, 'UserWideRevocationIntent', intent);
+    return {
+        userOp: await draft(ctx, IntentKind.USER_WIDE_REVOCATION, intent, signature),
     };
-    const digest = individualRevocationIntentDigest(intent, ctx.domainSeparator);
-    const signature = await ctx.signer.sign({ hash: digest });
+}
+const ZERO_BYTES32 = zeroHash;
+const FIRST_PAGE_CURSOR = {
+    anchorHandle: ZERO_BYTES32,
+    afterTimestamp: 0n,
+    afterOpIndex: 0n,
+};
+export async function createViewingSession(ctx, params) {
     const responseKey = generateResponseKey();
-    const draftRequest = new DraftRequest({
-        intent: new Uint8Array(hexToBytes(encodeIntent(IntentKind.INDIVIDUAL_REVOCATION, intent))),
-        intentKind: IntentKind.INDIVIDUAL_REVOCATION,
-        eip712Signature: new Uint8Array(hexToBytes(signature)),
-        responseKey,
+    const session = {
+        owner: params.owner ?? ctx.signer.address,
+        issuedAt: BigInt(Math.floor(Date.now() / 1000)),
+        expiresAt: params.expiresAt,
+        periodStart: params.periodStart ?? 0n,
+        periodEnd: params.periodEnd ?? 0n,
+        responseKey: bytesToHex(responseKey),
+        salt: generateRandomSalt(),
+    };
+    const signature = await signTypedIntent(ctx, 'ViewingSession', session);
+    return { session, signature };
+}
+async function sessionQuery(ctx, rpcMethod, viewing, name, query) {
+    const responseKey = hexToBytes(viewing.session.responseKey);
+    const envelope = await makeEnvelope(ctx.teePublicKey, { eip712Signature: hexToBytes(viewing.signature), responseKey }, hexToBytes(encodeStruct(name, query)));
+    const { body } = await openSignedResponse(await rpcMethod(envelope), responseKey);
+    return body;
+}
+export async function getBalance(ctx, viewing, params) {
+    const body = await sessionQuery(ctx, (e) => ctx.rpc.getBalance(e), viewing, 'BalanceQuery', {
+        session: viewing.session,
+        assetId: params.assetId,
     });
-    const envelope = await makeEnvelope(ctx.teePublicKey, draftRequest);
-    const encResponse = await ctx.rpc.draft(envelope);
-    const response = await decryptResponse(encResponse, responseKey, DraftResponse);
-    return { userOp: parseUserOp07(response.userOp) };
+    return decodeStruct('BalanceResponse', bytesToHex(body));
 }
-export async function revokeAll(ctx) {
-    const intent = {
-        kind: IntentKind.USER_WIDE_REVOCATION,
-        op: { empty: '0x' },
-        signer: ctx.signer.address,
-        gas: TODO_GAS,
-        salt: generateRandomSalt(),
+export async function getPortfolio(ctx, viewing) {
+    const body = await sessionQuery(ctx, (e) => ctx.rpc.getPortfolio(e), viewing, 'PortfolioQuery', { session: viewing.session });
+    return decodeStruct('PortfolioResponse', bytesToHex(body));
+}
+export function nextHistoryCursor(response) {
+    if (!response.hasMore)
+        return undefined;
+    return {
+        anchorHandle: response.anchorHandle,
+        afterTimestamp: response.nextTimestamp,
+        afterOpIndex: response.nextOpIndex,
     };
-    const digest = userWideRevocationIntentDigest(intent, ctx.domainSeparator);
-    const signature = await ctx.signer.sign({ hash: digest });
-    const responseKey = generateResponseKey();
-    const draftRequest = new DraftRequest({
-        intent: new Uint8Array(hexToBytes(encodeIntent(IntentKind.USER_WIDE_REVOCATION, intent))),
-        intentKind: IntentKind.USER_WIDE_REVOCATION,
-        eip712Signature: new Uint8Array(hexToBytes(signature)),
-        responseKey,
+}
+function historyPagination(options) {
+    return {
+        cursor: options?.cursor ?? FIRST_PAGE_CURSOR,
+        limit: options?.limit ?? 0,
+    };
+}
+export async function getBalanceHistory(ctx, viewing, assetId, options) {
+    if (assetId === ZERO_BYTES32) {
+        throw new ShieldError({
+            message: 'getBalanceHistory requires a nonzero assetId; use getPortfolioHistory',
+        });
+    }
+    const body = await sessionQuery(ctx, (e) => ctx.rpc.getBalanceHistory(e), viewing, 'BalanceHistoryQuery', {
+        session: viewing.session,
+        assetId,
+        pagination: historyPagination(options),
     });
-    const envelope = await makeEnvelope(ctx.teePublicKey, draftRequest);
-    const encResponse = await ctx.rpc.draft(envelope);
-    const response = await decryptResponse(encResponse, responseKey, DraftResponse);
-    return { userOp: parseUserOp07(response.userOp) };
+    return decodeStruct('BalanceHistoryResponse', bytesToHex(body));
 }
-// ---------------------------------------------------------------------------
-// GetBalance
-// ---------------------------------------------------------------------------
-export async function getBalance(ctx, params) {
-    const queryTimestamp = BigInt(Math.floor(Date.now() / 1000));
-    const digest = balanceQueryDigest({
-        owner: params.address,
-        assetId: params.assetId,
-        requester: ctx.signer.address,
-        queryTimestamp,
-    }, ctx.domainSeparator);
-    const signature = await ctx.signer.sign({ hash: digest });
-    const responseKey = generateResponseKey();
-    const envelope = await makeEnvelope(ctx.teePublicKey, new GetBalanceRequest({
-        address: new ProtoAddress({ value: hexToBytes(params.address) }),
-        assetId: new ProtoAssetId({ value: hexToBytes(params.assetId) }),
-        atBlock: params.atBlock ?? 0n,
-        eip712Signature: hexToBytes(signature),
-        responseKey,
-        queryTimestamp,
-    }));
-    const response = await ctx.rpc.getBalance(envelope);
-    return parseBalance(await decryptResponse(response, responseKey, GetBalanceResponse));
+export async function getPortfolioHistory(ctx, viewing, options) {
+    const body = await sessionQuery(ctx, (e) => ctx.rpc.getPortfolioHistory(e), viewing, 'PortfolioHistoryQuery', {
+        session: viewing.session,
+        pagination: historyPagination(options),
+    });
+    return decodeStruct('PortfolioHistoryResponse', bytesToHex(body));
 }
-// ---------------------------------------------------------------------------
-// RequestDepositAttestation
-// ---------------------------------------------------------------------------
 export async function requestDepositAttestation(ctx, params) {
-    const depositor = ctx.signer.address;
-    const [tokenAddress] = decodeAbiParameters([{ type: 'address' }], params.assetIdentificationArgs);
-    const assetId = computeErc20AssetId(tokenAddress);
-    const digest = depositAttestationRequestDigest({
-        recipient: params.recipient,
-        assetId,
-    }, ctx.domainSeparator);
-    const signature = await ctx.signer.sign({ hash: digest });
-    const responseKey = generateResponseKey();
-    const envelope = await makeEnvelope(ctx.teePublicKey, new RequestDepositAttestationRequest({
-        recipient: new ProtoAddress({
+    const body = toBinary(DepositAttestationRequestSchema, create(DepositAttestationRequestSchema, {
+        recipient: create(AddressSchema, {
             value: hexToBytes(params.recipient),
         }),
-        assetAdapter: new ProtoAddress({
+        assetAdapter: create(AddressSchema, {
             value: hexToBytes(params.assetAdapter),
         }),
         assetIdentificationArgs: hexToBytes(params.assetIdentificationArgs),
         memo: hexToBytes(params.memo),
         escapeHatch: hexToBytes(params.escapeHatch),
-        eip712Signature: hexToBytes(signature),
-        responseKey,
-        depositor: new ProtoAddress({ value: hexToBytes(depositor) }),
     }));
-    const response = await ctx.rpc.requestDepositAttestation(envelope);
-    const decrypted = await decryptResponse(response, responseKey, RequestDepositAttestationResponse);
-    if (decrypted.errorMessage) {
-        throw new CovalidatorError({ message: decrypted.errorMessage });
-    }
-    return {
-        toCiphertext: bytesToHex(decrypted.toCiphertext),
-        teeSignature: bytesToHex(decrypted.teeSignature),
-    };
-}
-// ---------------------------------------------------------------------------
-// Permission query helpers
-// ---------------------------------------------------------------------------
-// Each query signs its own Solidity struct so every field is authenticated.
-// Self-query: `requester` is always the signer.
-async function signGetPermissionsByOwner(ctx, includeExpired) {
-    const query = {
-        requester: ctx.signer.address,
-        includeExpired,
-        timestamp: BigInt(Math.floor(Date.now() / 1000)),
-    };
-    const digest = getPermissionsByOwnerDigest(query, ctx.domainSeparator);
-    const sig = await ctx.signer.sign({ hash: digest });
-    const encodedQuery = encodeAbiParameters([getAbiFromUnitFunction(incoShieldAbi, 'getPermissionsByOwner')], [query]);
-    return { encodedQuery: hexToBytes(encodedQuery), signature: hexToBytes(sig) };
+    const responseKey = generateResponseKey();
+    const envelope = await makeEnvelope(ctx.teePublicKey, { responseKey }, body);
+    const { body: responseBody, teeSignature } = await openSignedResponse(await ctx.rpc.requestDepositAttestation(envelope), responseKey);
+    const payload = decodeStruct('DepositAttestationPayload', bytesToHex(responseBody));
+    return { payload, signature: bytesToHex(teeSignature) };
 }
-async function signGetPermissionsBySpender(ctx, includeExpired) {
+export async function getPermissionsByOwner(ctx, params = {}) {
     const query = {
         requester: ctx.signer.address,
-        includeExpired,
-        timestamp: BigInt(Math.floor(Date.now() / 1000)),
+        includeExpired: params.includeExpired ?? false,
     };
-    const digest = getPermissionsBySpenderDigest(query, ctx.domainSeparator);
-    const sig = await ctx.signer.sign({ hash: digest });
-    const encodedQuery = encodeAbiParameters([getAbiFromUnitFunction(incoShieldAbi, 'getPermissionsBySpender')], [query]);
-    return { encodedQuery: hexToBytes(encodedQuery), signature: hexToBytes(sig) };
+    const signature = await signTypedIntent(ctx, 'GetPermissionsByOwner', query);
+    const responseKey = generateResponseKey();
+    const envelope = await makeEnvelope(ctx.teePublicKey, { eip712Signature: hexToBytes(signature), responseKey }, hexToBytes(encodeStruct('GetPermissionsByOwner', query)));
+    const { body } = await openSignedResponse(await ctx.rpc.getPermissionsByOwner(envelope), responseKey);
+    return decodeStruct('PermissionListResponse', bytesToHex(body));
 }
-async function signGetPermissionDetails(ctx, permissionId) {
+export async function getPermissionsBySpender(ctx, params = {}) {
     const query = {
         requester: ctx.signer.address,
-        permissionId,
-        timestamp: BigInt(Math.floor(Date.now() / 1000)),
+        includeExpired: params.includeExpired ?? false,
     };
-    const digest = getPermissionDetailsDigest(query, ctx.domainSeparator);
-    const sig = await ctx.signer.sign({ hash: digest });
-    const encodedQuery = encodeAbiParameters([getAbiFromUnitFunction(incoShieldAbi, 'getPermissionDetails')], [query]);
-    return { encodedQuery: hexToBytes(encodedQuery), signature: hexToBytes(sig) };
+    const signature = await signTypedIntent(ctx, 'GetPermissionsBySpender', query);
+    const responseKey = generateResponseKey();
+    const envelope = await makeEnvelope(ctx.teePublicKey, { eip712Signature: hexToBytes(signature), responseKey }, hexToBytes(encodeStruct('GetPermissionsBySpender', query)));
+    const { body } = await openSignedResponse(await ctx.rpc.getPermissionsBySpender(envelope), responseKey);
+    return decodeStruct('PermissionListResponse', bytesToHex(body));
 }
-async function signGetOwnerGeneration(ctx) {
+export async function getPermissionDetails(ctx, params) {
     const query = {
         requester: ctx.signer.address,
-        timestamp: BigInt(Math.floor(Date.now() / 1000)),
+        permissionId: params.permissionId,
     };
-    const digest = getOwnerGenerationDigest(query, ctx.domainSeparator);
-    const sig = await ctx.signer.sign({ hash: digest });
-    const encodedQuery = encodeAbiParameters([getAbiFromUnitFunction(incoShieldAbi, 'getOwnerGeneration')], [query]);
-    return { encodedQuery: hexToBytes(encodedQuery), signature: hexToBytes(sig) };
-}
-// ---------------------------------------------------------------------------
-// GetPermissionsByOwner
-// ---------------------------------------------------------------------------
-export async function getPermissionsByOwner(ctx, params) {
-    const { encodedQuery, signature } = await signGetPermissionsByOwner(ctx, params.includeExpired ?? false);
+    const signature = await signTypedIntent(ctx, 'GetPermissionDetails', query);
     const responseKey = generateResponseKey();
-    const envelope = await makeEnvelope(ctx.teePublicKey, new GetPermissionsByOwnerRequest({
-        getPermissionsByOwnerBytes: encodedQuery,
-        eip712Signature: signature,
-        responseKey,
-    }));
-    const response = await ctx.rpc.getPermissionsByOwner(envelope);
-    return parsePermissions(await decryptResponse(response, responseKey, GetPermissionsResponse));
-}
-// ---------------------------------------------------------------------------
-// GetPermissionsBySpender
-// ---------------------------------------------------------------------------
-export async function getPermissionsBySpender(ctx, params) {
-    const { encodedQuery, signature } = await signGetPermissionsBySpender(ctx, params.includeExpired ?? false);
-    const responseKey = generateResponseKey();
-    const envelope = await makeEnvelope(ctx.teePublicKey, new GetPermissionsBySpenderRequest({
-        getPermissionsBySpenderBytes: encodedQuery,
-        eip712Signature: signature,
-        responseKey,
-    }));
-    const response = await ctx.rpc.getPermissionsBySpender(envelope);
-    return parsePermissions(await decryptResponse(response, responseKey, GetPermissionsResponse));
+    const envelope = await makeEnvelope(ctx.teePublicKey, { eip712Signature: hexToBytes(signature), responseKey }, hexToBytes(encodeStruct('GetPermissionDetails', query)));
+    const { body } = await openSignedResponse(await ctx.rpc.getPermissionDetails(envelope), responseKey);
+    return decodeStruct('PermissionDetailsResponse', bytesToHex(body));
 }
-// ---------------------------------------------------------------------------
-// GetPermissionDetails
-// ---------------------------------------------------------------------------
-export async function getPermissionDetails(ctx, params) {
-    const { encodedQuery, signature } = await signGetPermissionDetails(ctx, params.permissionId);
-    const responseKey = generateResponseKey();
-    const envelope = await makeEnvelope(ctx.teePublicKey, new GetPermissionDetailsRequest({
-        getPermissionDetailsBytes: encodedQuery,
-        eip712Signature: signature,
-        responseKey,
-    }));
-    const response = await ctx.rpc.getPermissionDetails(envelope);
-    return parsePermissionDetails(await decryptResponse(response, responseKey, GetPermissionDetailsResponse));
-}
-// ---------------------------------------------------------------------------
-// GetOwnerGeneration
-// ---------------------------------------------------------------------------
 export async function getOwnerGeneration(ctx) {
-    const { encodedQuery, signature } = await signGetOwnerGeneration(ctx);
+    const query = { requester: ctx.signer.address };
+    const signature = await signTypedIntent(ctx, 'GetOwnerGeneration', query);
     const responseKey = generateResponseKey();
-    const envelope = await makeEnvelope(ctx.teePublicKey, new GetOwnerGenerationRequest({
-        getOwnerGenerationBytes: encodedQuery,
-        eip712Signature: signature,
-        responseKey,
-    }));
-    const response = await ctx.rpc.getOwnerGeneration(envelope);
-    return parseOwnerGeneration(await decryptResponse(response, responseKey, GetOwnerGenerationResponse));
+    const envelope = await makeEnvelope(ctx.teePublicKey, { eip712Signature: hexToBytes(signature), responseKey }, hexToBytes(encodeStruct('GetOwnerGeneration', query)));
+    const { body } = await openSignedResponse(await ctx.rpc.getOwnerGeneration(envelope), responseKey);
+    return decodeStruct('OwnerGenerationResponse', bytesToHex(body));
+}
+export async function getLatestHandle(ctx) {
+    const response = await ctx.rpc.getLatestHandle(create(GetLatestHandleRequestSchema));
+    const value = response.handle?.value;
+    if (value === undefined || value.length === 0) {
+        throw new ShieldError({
+            message: 'GetLatestHandle response is missing the handle',
+        });
+    }
+    return bytesToHex(value);
 }