@inco/shield-js 0.0.0-bootstrap.0

package/dist/shield/shield.eip712.gen.js

@@ -0,0 +1,318 @@
+// GENERATED FILE — DO NOT EDIT
+// Source: Shield.eip712.sol
+import { encodeAbiParameters, concat, keccak256, stringToBytes } from 'viem';
+export const ASSET_MOVEMENT_TYPEHASH = keccak256(stringToBytes("AssetMovement(address assetAdapter,bytes assetIdentificationArgs,bytes movementArgs)"));
+export function assetMovementStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "address" }, { type: "bytes32" }, { type: "bytes32" }], [ASSET_MOVEMENT_TYPEHASH, s.assetAdapter, keccak256(s.assetIdentificationArgs), keccak256(s.movementArgs)]));
+}
+export const CALL_TYPEHASH = keccak256(stringToBytes("Call(address target,uint256 value,bytes data)"));
+export function callStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "address" }, { type: "uint256" }, { type: "bytes32" }], [CALL_TYPEHASH, s.target, s.value, keccak256(s.data)]));
+}
+export const BALANCE_QUERY_TYPEHASH = keccak256(stringToBytes("BalanceQuery(address requester,address owner,bytes32 assetId,uint64 queryTimestamp)"));
+export function balanceQueryStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "address" }, { type: "address" }, { type: "bytes32" }, { type: "uint64" }], [BALANCE_QUERY_TYPEHASH, s.requester, s.owner, s.assetId, s.queryTimestamp]));
+}
+export const HANDLE_PREIMAGE_TYPEHASH = keccak256(stringToBytes("HandlePreimage(bytes32 previousHandle,bytes32 previousBlockHash,uint256 blockTimestamp,bytes32 operationHash)"));
+export function handlePreimageStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }, { type: "bytes32" }, { type: "uint256" }, { type: "bytes32" }], [HANDLE_PREIMAGE_TYPEHASH, s.previousHandle, s.previousBlockHash, s.blockTimestamp, s.operationHash]));
+}
+export const BLOCK_TYPEHASH = keccak256(stringToBytes("Block(uint256 blockNumber,bytes32 blockHash,bytes32 parentBlockHash,bytes32 parentHandle,bytes32 handle,uint256 blockTimestamp,bytes32 eventsHash)"));
+export function blockStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "uint256" }, { type: "bytes32" }, { type: "bytes32" }, { type: "bytes32" }, { type: "bytes32" }, { type: "uint256" }, { type: "bytes32" }], [BLOCK_TYPEHASH, s.blockNumber, s.blockHash, s.parentBlockHash, s.parentHandle, s.handle, s.blockTimestamp, s.eventsHash]));
+}
+export const DEPOSIT_ATTESTATION_TYPEHASH = keccak256(stringToBytes("DepositAttestation(bytes ciphertext,bytes32 assetId,bytes32 escapeCommitment,bytes receiverEscapeData)"));
+export function depositAttestationStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }, { type: "bytes32" }, { type: "bytes32" }, { type: "bytes32" }], [DEPOSIT_ATTESTATION_TYPEHASH, keccak256(s.ciphertext), s.assetId, s.escapeCommitment, keccak256(s.receiverEscapeData)]));
+}
+export const DEPOSIT_TYPEHASH = keccak256(stringToBytes("Deposit(DepositAttestation attestation,AssetMovement assetMovement,uint256 amount,address from,bytes teeAttestationSignature)AssetMovement(address assetAdapter,bytes assetIdentificationArgs,bytes movementArgs)DepositAttestation(bytes ciphertext,bytes32 assetId,bytes32 escapeCommitment,bytes receiverEscapeData)"));
+export function depositStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }, { type: "bytes32" }, { type: "uint256" }, { type: "address" }, { type: "bytes32" }], [DEPOSIT_TYPEHASH, depositAttestationStructHash(s.attestation), assetMovementStructHash(s.assetMovement), s.amount, s.from, keccak256(s.teeAttestationSignature)]));
+}
+export const DEPOSIT_ATTESTATION_REQUEST_TYPEHASH = keccak256(stringToBytes("DepositAttestationRequest(address recipient,bytes32 assetId)"));
+export function depositAttestationRequestStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "address" }, { type: "bytes32" }], [DEPOSIT_ATTESTATION_REQUEST_TYPEHASH, s.recipient, s.assetId]));
+}
+export const PERMISSION_TYPEHASH = keccak256(stringToBytes("Permission(address owner,address spender,bytes32 assetId,uint256 allowance,uint256 start,uint256 end,uint256 period,bytes32 agreementHash,bytes32 salt)"));
+export function permissionStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "address" }, { type: "address" }, { type: "bytes32" }, { type: "uint256" }, { type: "uint256" }, { type: "uint256" }, { type: "uint256" }, { type: "bytes32" }, { type: "bytes32" }], [PERMISSION_TYPEHASH, s.owner, s.spender, s.assetId, s.allowance, s.start, s.end, s.period, s.agreementHash, s.salt]));
+}
+export const PERMISSION_ATTESTATION_REQUEST_TYPEHASH = keccak256(stringToBytes("PermissionAttestationRequest(Permission permission,uint64 intentExpiry)Permission(address owner,address spender,bytes32 assetId,uint256 allowance,uint256 start,uint256 end,uint256 period,bytes32 agreementHash,bytes32 salt)"));
+export function permissionAttestationRequestStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }, { type: "uint64" }], [PERMISSION_ATTESTATION_REQUEST_TYPEHASH, permissionStructHash(s.permission), s.intentExpiry]));
+}
+export const PERMISSION_ATTESTATION_PAYLOAD_TYPEHASH = keccak256(stringToBytes("PermissionAttestationPayload(bytes32 permissionId,Permission permission,bytes32 draftingHandle)Permission(address owner,address spender,bytes32 assetId,uint256 allowance,uint256 start,uint256 end,uint256 period,bytes32 agreementHash,bytes32 salt)"));
+export function permissionAttestationPayloadStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }, { type: "bytes32" }, { type: "bytes32" }], [PERMISSION_ATTESTATION_PAYLOAD_TYPEHASH, s.permissionId, permissionStructHash(s.permission), s.draftingHandle]));
+}
+export const PERMISSION_ATTESTATION_TYPEHASH = keccak256(stringToBytes("PermissionAttestation(PermissionAttestationPayload payload,bytes signature)Permission(address owner,address spender,bytes32 assetId,uint256 allowance,uint256 start,uint256 end,uint256 period,bytes32 agreementHash,bytes32 salt)PermissionAttestationPayload(bytes32 permissionId,Permission permission,bytes32 draftingHandle)"));
+export function permissionAttestationStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }, { type: "bytes32" }], [PERMISSION_ATTESTATION_TYPEHASH, permissionAttestationPayloadStructHash(s.payload), keccak256(s.signature)]));
+}
+export const TRANSFER_INTENT_OP_TYPEHASH = keccak256(stringToBytes("TransferIntentOp(address receiver,bytes32 assetId,uint256 amount,bytes memo)"));
+export function transferIntentOpStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "address" }, { type: "bytes32" }, { type: "uint256" }, { type: "bytes32" }], [TRANSFER_INTENT_OP_TYPEHASH, s.receiver, s.assetId, s.amount, keccak256(s.memo)]));
+}
+export const WITHDRAWAL_CORE_INTENT_OP_TYPEHASH = keccak256(stringToBytes("WithdrawalCoreIntentOp(address to,bytes32 assetId,uint256 amount,AssetMovement assetMovement)AssetMovement(address assetAdapter,bytes assetIdentificationArgs,bytes movementArgs)"));
+export function withdrawalCoreIntentOpStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "address" }, { type: "bytes32" }, { type: "uint256" }, { type: "bytes32" }], [WITHDRAWAL_CORE_INTENT_OP_TYPEHASH, s.to, s.assetId, s.amount, assetMovementStructHash(s.assetMovement)]));
+}
+export const WITHDRAWAL_INTENT_OP_TYPEHASH = keccak256(stringToBytes("WithdrawalIntentOp(WithdrawalCoreIntentOp core,bytes memo)AssetMovement(address assetAdapter,bytes assetIdentificationArgs,bytes movementArgs)WithdrawalCoreIntentOp(address to,bytes32 assetId,uint256 amount,AssetMovement assetMovement)"));
+export function withdrawalIntentOpStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }, { type: "bytes32" }], [WITHDRAWAL_INTENT_OP_TYPEHASH, withdrawalCoreIntentOpStructHash(s.core), keccak256(s.memo)]));
+}
+export const DEFI_INTERACTION_INTENT_OP_TYPEHASH = keccak256(stringToBytes("DefiInteractionIntentOp(WithdrawalCoreIntentOp withdrawal,address defiAdapter,bytes adapterArgs,bytes memo)AssetMovement(address assetAdapter,bytes assetIdentificationArgs,bytes movementArgs)WithdrawalCoreIntentOp(address to,bytes32 assetId,uint256 amount,AssetMovement assetMovement)"));
+export function defiInteractionIntentOpStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }, { type: "address" }, { type: "bytes32" }, { type: "bytes32" }], [DEFI_INTERACTION_INTENT_OP_TYPEHASH, withdrawalCoreIntentOpStructHash(s.withdrawal), s.defiAdapter, keccak256(s.adapterArgs), keccak256(s.memo)]));
+}
+export const INDIVIDUAL_REVOCATION_INTENT_OP_TYPEHASH = keccak256(stringToBytes("IndividualRevocationIntentOp(bytes32 permissionId)"));
+export function individualRevocationIntentOpStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }], [INDIVIDUAL_REVOCATION_INTENT_OP_TYPEHASH, s.permissionId]));
+}
+export const USER_WIDE_REVOCATION_INTENT_OP_TYPEHASH = keccak256(stringToBytes("UserWideRevocationIntentOp(bytes empty)"));
+export function userWideRevocationIntentOpStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }], [USER_WIDE_REVOCATION_INTENT_OP_TYPEHASH, keccak256(s.empty)]));
+}
+export const GAS_TYPEHASH = keccak256(stringToBytes("Gas(bytes32 assetId,uint256 maxAmount,uint256 callGasLimit,uint256 verificationGasLimit,uint256 preVerificationGas,uint256 paymasterVerificationGasLimit,uint256 paymasterPostOpGasLimit,uint256 maxFeePerGas,uint256 maxPriorityFeePerGas)"));
+export function gasStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }, { type: "uint256" }, { type: "uint256" }, { type: "uint256" }, { type: "uint256" }, { type: "uint256" }, { type: "uint256" }, { type: "uint256" }, { type: "uint256" }], [GAS_TYPEHASH, s.assetId, s.maxAmount, s.callGasLimit, s.verificationGasLimit, s.preVerificationGas, s.paymasterVerificationGasLimit, s.paymasterPostOpGasLimit, s.maxFeePerGas, s.maxPriorityFeePerGas]));
+}
+export const TRANSFER_INTENT_TYPEHASH = keccak256(stringToBytes("TransferIntent(TransferIntentOp op,address signer,Gas gas,bytes32 salt)Gas(bytes32 assetId,uint256 maxAmount,uint256 callGasLimit,uint256 verificationGasLimit,uint256 preVerificationGas,uint256 paymasterVerificationGasLimit,uint256 paymasterPostOpGasLimit,uint256 maxFeePerGas,uint256 maxPriorityFeePerGas)TransferIntentOp(address receiver,bytes32 assetId,uint256 amount,bytes memo)"));
+export function transferIntentStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }, { type: "address" }, { type: "bytes32" }, { type: "bytes32" }], [TRANSFER_INTENT_TYPEHASH, transferIntentOpStructHash(s.op), s.signer, gasStructHash(s.gas), s.salt]));
+}
+export const WITHDRAWAL_INTENT_TYPEHASH = keccak256(stringToBytes("WithdrawalIntent(WithdrawalIntentOp op,address signer,Gas gas,bytes32 salt)AssetMovement(address assetAdapter,bytes assetIdentificationArgs,bytes movementArgs)Gas(bytes32 assetId,uint256 maxAmount,uint256 callGasLimit,uint256 verificationGasLimit,uint256 preVerificationGas,uint256 paymasterVerificationGasLimit,uint256 paymasterPostOpGasLimit,uint256 maxFeePerGas,uint256 maxPriorityFeePerGas)WithdrawalCoreIntentOp(address to,bytes32 assetId,uint256 amount,AssetMovement assetMovement)WithdrawalIntentOp(WithdrawalCoreIntentOp core,bytes memo)"));
+export function withdrawalIntentStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }, { type: "address" }, { type: "bytes32" }, { type: "bytes32" }], [WITHDRAWAL_INTENT_TYPEHASH, withdrawalIntentOpStructHash(s.op), s.signer, gasStructHash(s.gas), s.salt]));
+}
+export const DEFI_INTERACTION_INTENT_TYPEHASH = keccak256(stringToBytes("DefiInteractionIntent(DefiInteractionIntentOp op,address signer,Gas gas,bytes32 salt)AssetMovement(address assetAdapter,bytes assetIdentificationArgs,bytes movementArgs)DefiInteractionIntentOp(WithdrawalCoreIntentOp withdrawal,address defiAdapter,bytes adapterArgs,bytes memo)Gas(bytes32 assetId,uint256 maxAmount,uint256 callGasLimit,uint256 verificationGasLimit,uint256 preVerificationGas,uint256 paymasterVerificationGasLimit,uint256 paymasterPostOpGasLimit,uint256 maxFeePerGas,uint256 maxPriorityFeePerGas)WithdrawalCoreIntentOp(address to,bytes32 assetId,uint256 amount,AssetMovement assetMovement)"));
+export function defiInteractionIntentStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }, { type: "address" }, { type: "bytes32" }, { type: "bytes32" }], [DEFI_INTERACTION_INTENT_TYPEHASH, defiInteractionIntentOpStructHash(s.op), s.signer, gasStructHash(s.gas), s.salt]));
+}
+export const INDIVIDUAL_REVOCATION_INTENT_TYPEHASH = keccak256(stringToBytes("IndividualRevocationIntent(IndividualRevocationIntentOp op,address signer,Gas gas,bytes32 salt)Gas(bytes32 assetId,uint256 maxAmount,uint256 callGasLimit,uint256 verificationGasLimit,uint256 preVerificationGas,uint256 paymasterVerificationGasLimit,uint256 paymasterPostOpGasLimit,uint256 maxFeePerGas,uint256 maxPriorityFeePerGas)IndividualRevocationIntentOp(bytes32 permissionId)"));
+export function individualRevocationIntentStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }, { type: "address" }, { type: "bytes32" }, { type: "bytes32" }], [INDIVIDUAL_REVOCATION_INTENT_TYPEHASH, individualRevocationIntentOpStructHash(s.op), s.signer, gasStructHash(s.gas), s.salt]));
+}
+export const USER_WIDE_REVOCATION_INTENT_TYPEHASH = keccak256(stringToBytes("UserWideRevocationIntent(UserWideRevocationIntentOp op,address signer,Gas gas,bytes32 salt)Gas(bytes32 assetId,uint256 maxAmount,uint256 callGasLimit,uint256 verificationGasLimit,uint256 preVerificationGas,uint256 paymasterVerificationGasLimit,uint256 paymasterPostOpGasLimit,uint256 maxFeePerGas,uint256 maxPriorityFeePerGas)UserWideRevocationIntentOp(bytes empty)"));
+export function userWideRevocationIntentStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }, { type: "address" }, { type: "bytes32" }, { type: "bytes32" }], [USER_WIDE_REVOCATION_INTENT_TYPEHASH, userWideRevocationIntentOpStructHash(s.op), s.signer, gasStructHash(s.gas), s.salt]));
+}
+export const DELEGATED_TRANSFER_INTENT_TYPEHASH = keccak256(stringToBytes("DelegatedTransferIntent(TransferIntent intent,address spender,PermissionAttestation attestation)Gas(bytes32 assetId,uint256 maxAmount,uint256 callGasLimit,uint256 verificationGasLimit,uint256 preVerificationGas,uint256 paymasterVerificationGasLimit,uint256 paymasterPostOpGasLimit,uint256 maxFeePerGas,uint256 maxPriorityFeePerGas)Permission(address owner,address spender,bytes32 assetId,uint256 allowance,uint256 start,uint256 end,uint256 period,bytes32 agreementHash,bytes32 salt)PermissionAttestation(PermissionAttestationPayload payload,bytes signature)PermissionAttestationPayload(bytes32 permissionId,Permission permission,bytes32 draftingHandle)TransferIntent(TransferIntentOp op,address signer,Gas gas,bytes32 salt)TransferIntentOp(address receiver,bytes32 assetId,uint256 amount,bytes memo)"));
+export function delegatedTransferIntentStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }, { type: "address" }, { type: "bytes32" }], [DELEGATED_TRANSFER_INTENT_TYPEHASH, transferIntentStructHash(s.intent), s.spender, permissionAttestationStructHash(s.attestation)]));
+}
+export const DELEGATED_WITHDRAWAL_INTENT_TYPEHASH = keccak256(stringToBytes("DelegatedWithdrawalIntent(WithdrawalIntent intent,address spender,PermissionAttestation attestation)AssetMovement(address assetAdapter,bytes assetIdentificationArgs,bytes movementArgs)Gas(bytes32 assetId,uint256 maxAmount,uint256 callGasLimit,uint256 verificationGasLimit,uint256 preVerificationGas,uint256 paymasterVerificationGasLimit,uint256 paymasterPostOpGasLimit,uint256 maxFeePerGas,uint256 maxPriorityFeePerGas)Permission(address owner,address spender,bytes32 assetId,uint256 allowance,uint256 start,uint256 end,uint256 period,bytes32 agreementHash,bytes32 salt)PermissionAttestation(PermissionAttestationPayload payload,bytes signature)PermissionAttestationPayload(bytes32 permissionId,Permission permission,bytes32 draftingHandle)WithdrawalCoreIntentOp(address to,bytes32 assetId,uint256 amount,AssetMovement assetMovement)WithdrawalIntent(WithdrawalIntentOp op,address signer,Gas gas,bytes32 salt)WithdrawalIntentOp(WithdrawalCoreIntentOp core,bytes memo)"));
+export function delegatedWithdrawalIntentStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }, { type: "address" }, { type: "bytes32" }], [DELEGATED_WITHDRAWAL_INTENT_TYPEHASH, withdrawalIntentStructHash(s.intent), s.spender, permissionAttestationStructHash(s.attestation)]));
+}
+export const DELEGATED_DEFI_INTERACTION_INTENT_TYPEHASH = keccak256(stringToBytes("DelegatedDefiInteractionIntent(DefiInteractionIntent intent,address spender,PermissionAttestation attestation)AssetMovement(address assetAdapter,bytes assetIdentificationArgs,bytes movementArgs)DefiInteractionIntent(DefiInteractionIntentOp op,address signer,Gas gas,bytes32 salt)DefiInteractionIntentOp(WithdrawalCoreIntentOp withdrawal,address defiAdapter,bytes adapterArgs,bytes memo)Gas(bytes32 assetId,uint256 maxAmount,uint256 callGasLimit,uint256 verificationGasLimit,uint256 preVerificationGas,uint256 paymasterVerificationGasLimit,uint256 paymasterPostOpGasLimit,uint256 maxFeePerGas,uint256 maxPriorityFeePerGas)Permission(address owner,address spender,bytes32 assetId,uint256 allowance,uint256 start,uint256 end,uint256 period,bytes32 agreementHash,bytes32 salt)PermissionAttestation(PermissionAttestationPayload payload,bytes signature)PermissionAttestationPayload(bytes32 permissionId,Permission permission,bytes32 draftingHandle)WithdrawalCoreIntentOp(address to,bytes32 assetId,uint256 amount,AssetMovement assetMovement)"));
+export function delegatedDefiInteractionIntentStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }, { type: "address" }, { type: "bytes32" }], [DELEGATED_DEFI_INTERACTION_INTENT_TYPEHASH, defiInteractionIntentStructHash(s.intent), s.spender, permissionAttestationStructHash(s.attestation)]));
+}
+export const TRANSFER_TYPEHASH = keccak256(stringToBytes("Transfer(bytes32 draftingHandle,uint64 draftingTimestamp,bytes32 nullifier,bytes32 senderEscapeCommitment,bytes32 receiverEscapeCommitment,bytes senderEscapeData,bytes receiverEscapeData,bytes ciphertext,bytes memo)"));
+export function transferStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }, { type: "uint64" }, { type: "bytes32" }, { type: "bytes32" }, { type: "bytes32" }, { type: "bytes32" }, { type: "bytes32" }, { type: "bytes32" }, { type: "bytes32" }], [TRANSFER_TYPEHASH, s.draftingHandle, s.draftingTimestamp, s.nullifier, s.senderEscapeCommitment, s.receiverEscapeCommitment, keccak256(s.senderEscapeData), keccak256(s.receiverEscapeData), keccak256(s.ciphertext), keccak256(s.memo)]));
+}
+export const WITHDRAWAL_CORE_TYPEHASH = keccak256(stringToBytes("WithdrawalCore(address to,uint256 amount,bytes32 nullifier,bytes32 draftingHandle,uint64 draftingTimestamp,AssetMovement assetMovement,bytes ciphertext,bytes32 senderEscapeCommitment,bytes senderEscapeData)AssetMovement(address assetAdapter,bytes assetIdentificationArgs,bytes movementArgs)"));
+export function withdrawalCoreStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "address" }, { type: "uint256" }, { type: "bytes32" }, { type: "bytes32" }, { type: "uint64" }, { type: "bytes32" }, { type: "bytes32" }, { type: "bytes32" }, { type: "bytes32" }], [WITHDRAWAL_CORE_TYPEHASH, s.to, s.amount, s.nullifier, s.draftingHandle, s.draftingTimestamp, assetMovementStructHash(s.assetMovement), keccak256(s.ciphertext), s.senderEscapeCommitment, keccak256(s.senderEscapeData)]));
+}
+export const WITHDRAWAL_TYPEHASH = keccak256(stringToBytes("Withdrawal(WithdrawalCore core,bytes memo)AssetMovement(address assetAdapter,bytes assetIdentificationArgs,bytes movementArgs)WithdrawalCore(address to,uint256 amount,bytes32 nullifier,bytes32 draftingHandle,uint64 draftingTimestamp,AssetMovement assetMovement,bytes ciphertext,bytes32 senderEscapeCommitment,bytes senderEscapeData)"));
+export function withdrawalStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }, { type: "bytes32" }], [WITHDRAWAL_TYPEHASH, withdrawalCoreStructHash(s.core), keccak256(s.memo)]));
+}
+export const DEFI_INTERACTION_TYPEHASH = keccak256(stringToBytes("DefiInteraction(WithdrawalCore withdrawal,address defiAdapter,bytes adapterArgs,bytes memo)AssetMovement(address assetAdapter,bytes assetIdentificationArgs,bytes movementArgs)WithdrawalCore(address to,uint256 amount,bytes32 nullifier,bytes32 draftingHandle,uint64 draftingTimestamp,AssetMovement assetMovement,bytes ciphertext,bytes32 senderEscapeCommitment,bytes senderEscapeData)"));
+export function defiInteractionStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }, { type: "address" }, { type: "bytes32" }, { type: "bytes32" }], [DEFI_INTERACTION_TYPEHASH, withdrawalCoreStructHash(s.withdrawal), s.defiAdapter, keccak256(s.adapterArgs), keccak256(s.memo)]));
+}
+export const INDIVIDUAL_REVOCATION_TYPEHASH = keccak256(stringToBytes("IndividualRevocation(bytes ciphertext,bytes32 draftingHandle,uint64 draftingTimestamp)"));
+export function individualRevocationStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }, { type: "bytes32" }, { type: "uint64" }], [INDIVIDUAL_REVOCATION_TYPEHASH, keccak256(s.ciphertext), s.draftingHandle, s.draftingTimestamp]));
+}
+export const USER_WIDE_REVOCATION_TYPEHASH = keccak256(stringToBytes("UserWideRevocation(bytes ciphertext,bytes32 draftingHandle,uint64 draftingTimestamp)"));
+export function userWideRevocationStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "bytes32" }, { type: "bytes32" }, { type: "uint64" }], [USER_WIDE_REVOCATION_TYPEHASH, keccak256(s.ciphertext), s.draftingHandle, s.draftingTimestamp]));
+}
+export const TRANSFER_PLAINTEXT_TYPEHASH = keccak256(stringToBytes("TransferPlaintext(address sender,address receiver,uint256 amount,bytes32 assetId)"));
+export function transferPlaintextStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "address" }, { type: "address" }, { type: "uint256" }, { type: "bytes32" }], [TRANSFER_PLAINTEXT_TYPEHASH, s.sender, s.receiver, s.amount, s.assetId]));
+}
+export const WITHDRAWAL_PLAINTEXT_TYPEHASH = keccak256(stringToBytes("WithdrawalPlaintext(address sender)"));
+export function withdrawalPlaintextStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "address" }], [WITHDRAWAL_PLAINTEXT_TYPEHASH, s.sender]));
+}
+export const DEPOSIT_PLAINTEXT_TYPEHASH = keccak256(stringToBytes("DepositPlaintext(address receiver)"));
+export function depositPlaintextStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "address" }], [DEPOSIT_PLAINTEXT_TYPEHASH, s.receiver]));
+}
+export const INDIVIDUAL_REVOCATION_PLAINTEXT_TYPEHASH = keccak256(stringToBytes("IndividualRevocationPlaintext(address owner,bytes32 permissionId)"));
+export function individualRevocationPlaintextStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "address" }, { type: "bytes32" }], [INDIVIDUAL_REVOCATION_PLAINTEXT_TYPEHASH, s.owner, s.permissionId]));
+}
+export const USER_WIDE_REVOCATION_PLAINTEXT_TYPEHASH = keccak256(stringToBytes("UserWideRevocationPlaintext(address owner)"));
+export function userWideRevocationPlaintextStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "address" }], [USER_WIDE_REVOCATION_PLAINTEXT_TYPEHASH, s.owner]));
+}
+export const SENDER_ESCAPE_PLAINTEXT_TYPEHASH = keccak256(stringToBytes("SenderEscapePlaintext(address sender,bytes32 assetId,bytes32 draftingHandle,uint256 spendAmount,uint256 balanceSnapshot,uint64 chequeNumber,uint64 oldestPossiblyOutstanding)"));
+export function senderEscapePlaintextStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "address" }, { type: "bytes32" }, { type: "bytes32" }, { type: "uint256" }, { type: "uint256" }, { type: "uint64" }, { type: "uint64" }], [SENDER_ESCAPE_PLAINTEXT_TYPEHASH, s.sender, s.assetId, s.draftingHandle, s.spendAmount, s.balanceSnapshot, s.chequeNumber, s.oldestPossiblyOutstanding]));
+}
+export const RECEIVER_ESCAPE_PLAINTEXT_TYPEHASH = keccak256(stringToBytes("ReceiverEscapePlaintext(address receiver,bytes32 assetId,bytes32 draftingHandle,uint256 receiveAmount,uint256 balanceSnapshot,bytes32 chequeNullifier,uint64 senderChequeNumber,uint64 oldestPossiblyOutstandingSend)"));
+export function receiverEscapePlaintextStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "address" }, { type: "bytes32" }, { type: "bytes32" }, { type: "uint256" }, { type: "uint256" }, { type: "bytes32" }, { type: "uint64" }, { type: "uint64" }], [RECEIVER_ESCAPE_PLAINTEXT_TYPEHASH, s.receiver, s.assetId, s.draftingHandle, s.receiveAmount, s.balanceSnapshot, s.chequeNullifier, s.senderChequeNumber, s.oldestPossiblyOutstandingSend]));
+}
+export const GET_PERMISSIONS_BY_OWNER_TYPEHASH = keccak256(stringToBytes("GetPermissionsByOwner(address requester,bool includeExpired,uint64 timestamp)"));
+export function getPermissionsByOwnerStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "address" }, { type: "bool" }, { type: "uint64" }], [GET_PERMISSIONS_BY_OWNER_TYPEHASH, s.requester, s.includeExpired, s.timestamp]));
+}
+export const GET_PERMISSIONS_BY_SPENDER_TYPEHASH = keccak256(stringToBytes("GetPermissionsBySpender(address requester,bool includeExpired,uint64 timestamp)"));
+export function getPermissionsBySpenderStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "address" }, { type: "bool" }, { type: "uint64" }], [GET_PERMISSIONS_BY_SPENDER_TYPEHASH, s.requester, s.includeExpired, s.timestamp]));
+}
+export const GET_PERMISSION_DETAILS_TYPEHASH = keccak256(stringToBytes("GetPermissionDetails(address requester,bytes32 permissionId,uint64 timestamp)"));
+export function getPermissionDetailsStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "address" }, { type: "bytes32" }, { type: "uint64" }], [GET_PERMISSION_DETAILS_TYPEHASH, s.requester, s.permissionId, s.timestamp]));
+}
+export const GET_SPENDABLE_TYPEHASH = keccak256(stringToBytes("GetSpendable(address requester,bytes32 permissionId,uint64 timestamp)"));
+export function getSpendableStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "address" }, { type: "bytes32" }, { type: "uint64" }], [GET_SPENDABLE_TYPEHASH, s.requester, s.permissionId, s.timestamp]));
+}
+export const GET_OWNER_GENERATION_TYPEHASH = keccak256(stringToBytes("GetOwnerGeneration(address requester,uint64 timestamp)"));
+export function getOwnerGenerationStructHash(s) {
+    return keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "address" }, { type: "uint64" }], [GET_OWNER_GENERATION_TYPEHASH, s.requester, s.timestamp]));
+}
+export function assetMovementDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, assetMovementStructHash(s)]));
+}
+export function callDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, callStructHash(s)]));
+}
+export function balanceQueryDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, balanceQueryStructHash(s)]));
+}
+export function handlePreimageDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, handlePreimageStructHash(s)]));
+}
+export function blockDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, blockStructHash(s)]));
+}
+export function depositAttestationDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, depositAttestationStructHash(s)]));
+}
+export function depositDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, depositStructHash(s)]));
+}
+export function depositAttestationRequestDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, depositAttestationRequestStructHash(s)]));
+}
+export function permissionDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, permissionStructHash(s)]));
+}
+export function permissionAttestationRequestDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, permissionAttestationRequestStructHash(s)]));
+}
+export function permissionAttestationPayloadDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, permissionAttestationPayloadStructHash(s)]));
+}
+export function permissionAttestationDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, permissionAttestationStructHash(s)]));
+}
+export function transferIntentOpDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, transferIntentOpStructHash(s)]));
+}
+export function withdrawalCoreIntentOpDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, withdrawalCoreIntentOpStructHash(s)]));
+}
+export function withdrawalIntentOpDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, withdrawalIntentOpStructHash(s)]));
+}
+export function defiInteractionIntentOpDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, defiInteractionIntentOpStructHash(s)]));
+}
+export function individualRevocationIntentOpDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, individualRevocationIntentOpStructHash(s)]));
+}
+export function userWideRevocationIntentOpDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, userWideRevocationIntentOpStructHash(s)]));
+}
+export function gasDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, gasStructHash(s)]));
+}
+export function transferIntentDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, transferIntentStructHash(s)]));
+}
+export function withdrawalIntentDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, withdrawalIntentStructHash(s)]));
+}
+export function defiInteractionIntentDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, defiInteractionIntentStructHash(s)]));
+}
+export function individualRevocationIntentDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, individualRevocationIntentStructHash(s)]));
+}
+export function userWideRevocationIntentDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, userWideRevocationIntentStructHash(s)]));
+}
+export function delegatedTransferIntentDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, delegatedTransferIntentStructHash(s)]));
+}
+export function delegatedWithdrawalIntentDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, delegatedWithdrawalIntentStructHash(s)]));
+}
+export function delegatedDefiInteractionIntentDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, delegatedDefiInteractionIntentStructHash(s)]));
+}
+export function transferDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, transferStructHash(s)]));
+}
+export function withdrawalCoreDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, withdrawalCoreStructHash(s)]));
+}
+export function withdrawalDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, withdrawalStructHash(s)]));
+}
+export function defiInteractionDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, defiInteractionStructHash(s)]));
+}
+export function individualRevocationDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, individualRevocationStructHash(s)]));
+}
+export function userWideRevocationDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, userWideRevocationStructHash(s)]));
+}
+export function transferPlaintextDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, transferPlaintextStructHash(s)]));
+}
+export function withdrawalPlaintextDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, withdrawalPlaintextStructHash(s)]));
+}
+export function depositPlaintextDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, depositPlaintextStructHash(s)]));
+}
+export function individualRevocationPlaintextDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, individualRevocationPlaintextStructHash(s)]));
+}
+export function userWideRevocationPlaintextDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, userWideRevocationPlaintextStructHash(s)]));
+}
+export function senderEscapePlaintextDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, senderEscapePlaintextStructHash(s)]));
+}
+export function receiverEscapePlaintextDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, receiverEscapePlaintextStructHash(s)]));
+}
+export function getPermissionsByOwnerDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, getPermissionsByOwnerStructHash(s)]));
+}
+export function getPermissionsBySpenderDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, getPermissionsBySpenderStructHash(s)]));
+}
+export function getPermissionDetailsDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, getPermissionDetailsStructHash(s)]));
+}
+export function getSpendableDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, getSpendableStructHash(s)]));
+}
+export function getOwnerGenerationDigest(s, domainSeparator) {
+    return keccak256(concat(["0x1901", domainSeparator, getOwnerGenerationStructHash(s)]));
+}

package/dist/shield/types.d.ts

@@ -0,0 +1,119 @@
+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. */
+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 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;
+}
+/** 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

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

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

@@ -0,0 +1,36 @@
+/**
+ * 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';
+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 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;
+    readonly senderEscapeData: number;
+    readonly receiverEscapeData: number;
+    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 {};