@inco/shield-js 0.0.0-bootstrap.0

package/dist/shield/intent.js

@@ -0,0 +1,188 @@
+import { createPublicClient, encodeAbiParameters, getAbiItem, http, } from 'viem';
+import { createBundlerClient, entryPoint07Address, } from 'viem/account-abstraction';
+import { shieldAbiStubAbi } from '../contracts/abi.js';
+import { BundlerGasEstimateIncomplete } from '../errors.js';
+import { IntentKind } from '../generated/inco/shield/v2/drafting_pb.js';
+import { userOpFromIntentForGasEstimation } from './userop/gas-estimation.js';
+import { convertEthWeiToTokenUnits } from './userop/token-exchange.js';
+import { getChainFromId } from './utils/chain.js';
+// Main function of this file: createIntent and createDelegatedIntent
+/**
+ * Create an intent with gas estimation. Generic over the intent kind: the returned
+ * `Intent` variant matches the kind of the supplied `IntentOp`.
+ */
+async function createIntent(intentOp, salt, signer, shieldConfig, publicClient, gas, bundlerUrl) {
+    const chain = getChainFromId(Number(shieldConfig.chainId));
+    const bundlerPublicClient = createPublicClient({
+        chain,
+        transport: http(chain.rpcUrls.default.http[0]),
+    });
+    const bundlerClient = createBundlerClient({
+        client: bundlerPublicClient,
+        transport: http(bundlerUrl),
+    });
+    // Step1: build a placeholder UserOp for the bundler to estimate against
+    const placeholderUserOp = await userOpFromIntentForGasEstimation(intentOp, signer, shieldConfig, publicClient, gas);
+    // Step2: ask the bundler to fill in the gas limits
+    const gasEstimate = await bundlerClient.estimateUserOperationGas({
+        entryPointAddress: entryPoint07Address,
+        sender: placeholderUserOp.sender,
+        nonce: placeholderUserOp.nonce,
+        callData: placeholderUserOp.callData,
+        signature: placeholderUserOp.signature,
+        preVerificationGas: placeholderUserOp.preVerificationGas,
+        verificationGasLimit: placeholderUserOp.verificationGasLimit,
+        callGasLimit: placeholderUserOp.callGasLimit,
+        maxFeePerGas: placeholderUserOp.maxFeePerGas,
+        maxPriorityFeePerGas: placeholderUserOp.maxPriorityFeePerGas,
+        paymasterVerificationGasLimit: placeholderUserOp.paymasterVerificationGasLimit,
+        paymasterPostOpGasLimit: placeholderUserOp.paymasterPostOpGasLimit,
+    });
+    const preVerificationGas = gasEstimate.preVerificationGas;
+    const verificationGasLimit = gasEstimate.verificationGasLimit;
+    const callGasLimit = gasEstimate.callGasLimit;
+    const paymasterVerificationGasLimit = gasEstimate.paymasterVerificationGasLimit;
+    const paymasterPostOpGasLimit = gasEstimate.paymasterPostOpGasLimit;
+    const missingFields = [];
+    if (preVerificationGas === undefined)
+        missingFields.push('preVerificationGas');
+    if (verificationGasLimit === undefined)
+        missingFields.push('verificationGasLimit');
+    if (callGasLimit === undefined)
+        missingFields.push('callGasLimit');
+    if (paymasterVerificationGasLimit === undefined)
+        missingFields.push('paymasterVerificationGasLimit');
+    if (paymasterPostOpGasLimit === undefined)
+        missingFields.push('paymasterPostOpGasLimit');
+    if (preVerificationGas === undefined ||
+        verificationGasLimit === undefined ||
+        callGasLimit === undefined ||
+        paymasterVerificationGasLimit === undefined ||
+        paymasterPostOpGasLimit === undefined) {
+        throw new BundlerGasEstimateIncomplete({
+            message: 'Bundler did not return all required gas sub-limits',
+            missingFields,
+        });
+    }
+    // Step3: derive `maxAmount` — the cap the user signs over, denominated
+    // in `gas.assetId` smallest-units (e.g. 1_000_000 = 1 USDC).
+    //
+    // We compute that ETH-wei cost, then convert to token units via a Chainlink RAY-precision exchange rate, ceiling-
+    // rounded to match the paymaster's on-chain rounding so the signed cap can never come in below what `_postOp` actually charges.
+    const totalGasUnits = preVerificationGas +
+        verificationGasLimit +
+        callGasLimit +
+        paymasterVerificationGasLimit +
+        paymasterPostOpGasLimit;
+    const maxGasCostWei = totalGasUnits * gas.maxFeePerGas;
+    const maxAmount = await convertEthWeiToTokenUnits(publicClient, gas.assetId, maxGasCostWei);
+    // Bake in every bundler-estimated limit — the same five summed into
+    // `totalGasUnits` above — so the signed `Gas` matches the cap derived
+    // from it. Writing back only `callGasLimit` would leave the intent's
+    // other limits at the caller's placeholders, inconsistent with `maxAmount`.
+    const estimatedGas = {
+        ...gas,
+        callGasLimit,
+        verificationGasLimit,
+        preVerificationGas,
+        paymasterVerificationGasLimit,
+        paymasterPostOpGasLimit,
+        maxAmount,
+    };
+    return assembleIntent(intentOp.op, signer, estimatedGas, salt);
+}
+async function createDelegatedIntent(intentOp, salt, spender, attestation, signer, shieldConfig, publicClient, gas, bundlerUrl) {
+    const intent = await createIntent(intentOp, salt, signer, shieldConfig, publicClient, gas, bundlerUrl);
+    return { intent, spender, attestation };
+}
+function assembleIntent(op, signer, gas, salt) {
+    return { op, signer: signer.address, gas, salt };
+}
+// Exported functions
+export async function createTransferIntent(transferIntentOp, salt, signer, shieldConfig, publicClient, gas, bundlerUrl) {
+    return createIntent({ kind: IntentKind.TRANSFER, op: transferIntentOp }, salt, signer, shieldConfig, publicClient, gas, bundlerUrl);
+}
+export async function createWithdrawIntent(withdrawalIntentOp, salt, signer, shieldConfig, publicClient, gas, bundlerUrl) {
+    return createIntent({ kind: IntentKind.WITHDRAW, op: withdrawalIntentOp }, salt, signer, shieldConfig, publicClient, gas, bundlerUrl);
+}
+export async function createDefiInteractionIntent(defiInteractionIntentOp, salt, signer, shieldConfig, publicClient, gas, bundlerUrl) {
+    return createIntent({ kind: IntentKind.DEFI_INTERACTION, op: defiInteractionIntentOp }, salt, signer, shieldConfig, publicClient, gas, bundlerUrl);
+}
+export async function createIndividualRevocationIntent(individualRevocationIntentOp, salt, signer, shieldConfig, publicClient, gas, bundlerUrl) {
+    return createIntent({
+        kind: IntentKind.INDIVIDUAL_REVOCATION,
+        op: individualRevocationIntentOp,
+    }, salt, signer, shieldConfig, publicClient, gas, bundlerUrl);
+}
+export async function createUserWideRevocationIntent(userWideRevocationIntentOp, salt, signer, shieldConfig, publicClient, gas, bundlerUrl) {
+    return createIntent({ kind: IntentKind.USER_WIDE_REVOCATION, op: userWideRevocationIntentOp }, salt, signer, shieldConfig, publicClient, gas, bundlerUrl);
+}
+export async function createDelegatedTransferIntent(transferIntentOp, salt, spender, attestation, signer, shieldConfig, publicClient, gas, bundlerUrl) {
+    return createDelegatedIntent({ kind: IntentKind.DELEGATED_TRANSFER, op: transferIntentOp }, salt, spender, attestation, signer, shieldConfig, publicClient, gas, bundlerUrl);
+}
+export async function createDelegatedWithdrawIntent(withdrawalIntentOp, salt, spender, attestation, signer, shieldConfig, publicClient, gas, bundlerUrl) {
+    return createDelegatedIntent({ kind: IntentKind.DELEGATED_WITHDRAW, op: withdrawalIntentOp }, salt, spender, attestation, signer, shieldConfig, publicClient, gas, bundlerUrl);
+}
+export async function createDelegatedDefiInteractionIntent(defiInteractionIntentOp, salt, spender, attestation, signer, shieldConfig, publicClient, gas, bundlerUrl) {
+    return createDelegatedIntent({
+        kind: IntentKind.DELEGATED_DEFI_INTERACTION,
+        op: defiInteractionIntentOp,
+    }, salt, spender, attestation, signer, shieldConfig, publicClient, gas, bundlerUrl);
+}
+// ABI Encoding
+const transferIntentAbi = getAbiItem({
+    abi: shieldAbiStubAbi,
+    name: 'transferIntent',
+}).inputs[0];
+const withdrawalIntentAbi = getAbiItem({
+    abi: shieldAbiStubAbi,
+    name: 'withdrawalIntent',
+}).inputs[0];
+const defiInteractionIntentAbi = getAbiItem({
+    abi: shieldAbiStubAbi,
+    name: 'defiInteractionIntent',
+}).inputs[0];
+const individualRevocationIntentAbi = getAbiItem({
+    abi: shieldAbiStubAbi,
+    name: 'individualRevocationIntent',
+}).inputs[0];
+const userWideRevocationIntentAbi = getAbiItem({
+    abi: shieldAbiStubAbi,
+    name: 'userWideRevocationIntent',
+}).inputs[0];
+const delegatedTransferIntentAbi = getAbiItem({
+    abi: shieldAbiStubAbi,
+    name: 'delegatedTransferIntent',
+}).inputs[0];
+const delegatedWithdrawalIntentAbi = getAbiItem({
+    abi: shieldAbiStubAbi,
+    name: 'delegatedWithdrawalIntent',
+}).inputs[0];
+const delegatedDefiInteractionIntentAbi = getAbiItem({
+    abi: shieldAbiStubAbi,
+    name: 'delegatedDefiInteractionIntent',
+}).inputs[0];
+/**
+ * Mapping from the intent kind to the abi item.
+ */
+export const intentAbi = {
+    [IntentKind.TRANSFER]: transferIntentAbi,
+    [IntentKind.WITHDRAW]: withdrawalIntentAbi,
+    [IntentKind.DEFI_INTERACTION]: defiInteractionIntentAbi,
+    [IntentKind.INDIVIDUAL_REVOCATION]: individualRevocationIntentAbi,
+    [IntentKind.USER_WIDE_REVOCATION]: userWideRevocationIntentAbi,
+    [IntentKind.DELEGATED_TRANSFER]: delegatedTransferIntentAbi,
+    [IntentKind.DELEGATED_WITHDRAW]: delegatedWithdrawalIntentAbi,
+    [IntentKind.DELEGATED_DEFI_INTERACTION]: delegatedDefiInteractionIntentAbi,
+};
+/**
+ * ABI-encode an intent.
+ */
+export function encodeIntent(kind, intent) {
+    // viem's `encodeAbiParameters` over-constrains the value tuple when the
+    // parameter list is a union. `intentAbi[kind]` and `IntentMapping[K]['intent']`
+    // are paired by construction, so we erase the union to a single `AbiParameter`
+    // before encoding.
+    const params = [intentAbi[kind]];
+    return encodeAbiParameters(params, [intent]);
+}

package/dist/shield/rpc.d.ts

@@ -0,0 +1,72 @@
+import type { Client } from '@connectrpc/connect';
+import { type Hex } from 'viem';
+import type { UserOperation } from 'viem/account-abstraction';
+import type { ConductorService as ConductorServiceType } from '../generated/inco/shield/v2/conductor_connect.js';
+import { type PermissionAttestation, type PermissionAttestationRequest, type TransferIntentOp, type WithdrawalIntentOp } from './shield.eip712.gen.js';
+import type { Balance, DepositAttestation, GetBalanceParams, GetPermissionDetailsParams, GetPermissionsByOwnerParams, GetPermissionsBySpenderParams, PermissionDetails, PermissionInfo, PermissionIntent, RequestDepositAttestationParams, ShieldSigner } from './types.js';
+import type { ENTRYPOINT_VERSION } from './userop/types.js';
+export type Rpc = Client<typeof ConductorServiceType>;
+export type RpcContext = {
+    rpc: Rpc;
+    domainSeparator: Hex;
+    signer: ShieldSigner;
+    teePublicKey: CryptoKey;
+};
+/**
+ * Inputs to the salted `permissionId` formula. Mirrors `PermissionIntent` minus
+ * `intentExpiry` (which gates issuance, not identity).
+ */
+export type PermissionIdInput = Omit<PermissionIntent, 'intentExpiry'>;
+/**
+ * `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 declare function computePermissionId(input: PermissionIdInput): Hex;
+export declare function issueTransfer(ctx: RpcContext, intentOp: TransferIntentOp): Promise<{
+    userOp: UserOperation<typeof ENTRYPOINT_VERSION>;
+}>;
+export declare function issueWithdraw(ctx: RpcContext, intentOp: WithdrawalIntentOp): Promise<{
+    userOp: UserOperation<typeof ENTRYPOINT_VERSION>;
+}>;
+/**
+ * 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 declare function requestPermissionAttestation(ctx: RpcContext, req: PermissionAttestationRequest): Promise<PermissionAttestation>;
+/**
+ * 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 declare function issueDelegatedTransfer(ctx: RpcContext, intentOp: TransferIntentOp, attestation: PermissionAttestation): Promise<{
+    userOp: UserOperation<typeof ENTRYPOINT_VERSION>;
+}>;
+/**
+ * The resulting cheque settles byte-identically to a direct withdraw —
+ * observers cannot distinguish delegated from direct.
+ */
+export declare function issueDelegatedWithdraw(ctx: RpcContext, intentOp: WithdrawalIntentOp, attestation: PermissionAttestation): Promise<{
+    userOp: UserOperation<typeof ENTRYPOINT_VERSION>;
+}>;
+export declare function revokeOne(ctx: RpcContext, params: {
+    permissionId: Hex;
+}): Promise<{
+    userOp: UserOperation<typeof ENTRYPOINT_VERSION>;
+}>;
+export declare function revokeAll(ctx: RpcContext): Promise<{
+    userOp: UserOperation<typeof ENTRYPOINT_VERSION>;
+}>;
+export declare function getBalance(ctx: RpcContext, params: GetBalanceParams): Promise<Balance>;
+export declare function requestDepositAttestation(ctx: RpcContext, params: RequestDepositAttestationParams): Promise<DepositAttestation>;
+export declare function getPermissionsByOwner(ctx: RpcContext, params: GetPermissionsByOwnerParams): Promise<PermissionInfo[]>;
+export declare function getPermissionsBySpender(ctx: RpcContext, params: GetPermissionsBySpenderParams): Promise<PermissionInfo[]>;
+export declare function getPermissionDetails(ctx: RpcContext, params: GetPermissionDetailsParams): Promise<PermissionDetails>;
+export declare function getOwnerGeneration(ctx: RpcContext): Promise<bigint>;