@inco/shield-js 0.0.0-bootstrap.0

package/dist/shield/rpc.js

@@ -0,0 +1,423 @@
+import { decodeAbiParameters, encodeAbiParameters, keccak256, toHex, } 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.
+ */
+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
+    ], [
+        input.owner,
+        input.spender,
+        input.assetId,
+        input.allowance,
+        input.start,
+        input.end,
+        input.period,
+        input.agreementHash,
+        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,
+    });
+    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 });
+    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) };
+}
+// ---------------------------------------------------------------------------
+// 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',
+        });
+    }
+    const expectedPid = computePermissionId(permission);
+    const digest = permissionAttestationRequestDigest(req, ctx.domainSeparator);
+    const ownerSignature = await ctx.signer.sign({ hash: digest });
+    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) {
+        throw new ShieldError({
+            message: `requestPermissionAttestation: TEE returned mismatched permissionId (expected ${expectedPid}, got ${attestation.payload.permissionId})`,
+        });
+    }
+    return attestation;
+}
+// ---------------------------------------------------------------------------
+// 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,
+    };
+    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,
+    };
+    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(),
+    };
+    const digest = individualRevocationIntentDigest(intent, ctx.domainSeparator);
+    const signature = await ctx.signer.sign({ hash: digest });
+    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 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 revokeAll(ctx) {
+    const intent = {
+        kind: IntentKind.USER_WIDE_REVOCATION,
+        op: { empty: '0x' },
+        signer: ctx.signer.address,
+        gas: TODO_GAS,
+        salt: generateRandomSalt(),
+    };
+    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,
+    });
+    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) };
+}
+// ---------------------------------------------------------------------------
+// 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));
+}
+// ---------------------------------------------------------------------------
+// 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({
+            value: hexToBytes(params.recipient),
+        }),
+        assetAdapter: new ProtoAddress({
+            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) };
+}
+async function signGetPermissionsBySpender(ctx, includeExpired) {
+    const query = {
+        requester: ctx.signer.address,
+        includeExpired,
+        timestamp: BigInt(Math.floor(Date.now() / 1000)),
+    };
+    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) };
+}
+async function signGetPermissionDetails(ctx, permissionId) {
+    const query = {
+        requester: ctx.signer.address,
+        permissionId,
+        timestamp: BigInt(Math.floor(Date.now() / 1000)),
+    };
+    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) };
+}
+async function signGetOwnerGeneration(ctx) {
+    const query = {
+        requester: ctx.signer.address,
+        timestamp: BigInt(Math.floor(Date.now() / 1000)),
+    };
+    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 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));
+}
+// ---------------------------------------------------------------------------
+// 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 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));
+}