@cashie/core-lib 1.0.0

package/dist/erc-7715/request/schemas.d.ts

@@ -0,0 +1,260 @@
+import { z } from 'zod';
+import type { GetPermissionsInfoResultParams, GetSupportedExecutionPermissionsResult, InitCodeData, PermissionRequest, PermissionResponse, PermissionsRequest, PermissionsResponse } from './types.js';
+export declare const initCodeDataSchema: z.ZodObject<{
+    factory: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    factoryData: z.ZodCustom<`0x${string}`, `0x${string}`>;
+}, z.core.$strict>;
+export declare const permissionRequestSchema: z.ZodObject<{
+    chainId: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    from: z.ZodOptional<z.ZodCustom<`0x${string}`, `0x${string}`>>;
+    to: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    permission: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        isAdjustmentAllowed: z.ZodBoolean;
+        justification: z.ZodString;
+        type: z.ZodLiteral<"erc20-token-payment">;
+        data: z.ZodObject<{
+            recipient: z.ZodCustom<`0x${string}`, `0x${string}`>;
+            paymentDetails: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                allowance: z.ZodCustom<`0x${string}`, `0x${string}`>;
+                tokenAddress: z.ZodCustom<`0x${string}`, `0x${string}`>;
+                rewardItems: z.ZodOptional<z.ZodArray<z.ZodType<import("../../index.js").RewardItem, unknown, z.core.$ZodTypeInternals<import("../../index.js").RewardItem, unknown>>>>;
+                type: z.ZodLiteral<"single">;
+            }, z.core.$strict>, z.ZodObject<{
+                allowance: z.ZodCustom<`0x${string}`, `0x${string}`>;
+                tokenAddress: z.ZodCustom<`0x${string}`, `0x${string}`>;
+                rewardItems: z.ZodOptional<z.ZodArray<z.ZodType<import("../../index.js").RewardItem, unknown, z.core.$ZodTypeInternals<import("../../index.js").RewardItem, unknown>>>>;
+                type: z.ZodLiteral<"recurring">;
+                startDate: z.ZodOptional<z.ZodNumber>;
+                billingPeriod: z.ZodEnum<{
+                    weekly: "weekly";
+                    monthly: "monthly";
+                    annually: "annually";
+                }>;
+            }, z.core.$strict>], "type">;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "type">;
+    rules: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        isAdjustmentAllowed: z.ZodBoolean;
+        justification: z.ZodString;
+        type: z.ZodLiteral<"expiry">;
+        data: z.ZodObject<{
+            timestamp: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        isAdjustmentAllowed: z.ZodBoolean;
+        justification: z.ZodString;
+        type: z.ZodLiteral<"identity-mint">;
+        data: z.ZodObject<{
+            identityMintPayload: z.ZodType<import("../../index.js").IdentityMintSignPayloadWithSignature, unknown, z.core.$ZodTypeInternals<import("../../index.js").IdentityMintSignPayloadWithSignature, unknown>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "type">>>;
+}, z.core.$strict>;
+export declare const permissionsRequestSchema: z.ZodArray<z.ZodObject<{
+    chainId: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    from: z.ZodOptional<z.ZodCustom<`0x${string}`, `0x${string}`>>;
+    to: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    permission: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        isAdjustmentAllowed: z.ZodBoolean;
+        justification: z.ZodString;
+        type: z.ZodLiteral<"erc20-token-payment">;
+        data: z.ZodObject<{
+            recipient: z.ZodCustom<`0x${string}`, `0x${string}`>;
+            paymentDetails: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                allowance: z.ZodCustom<`0x${string}`, `0x${string}`>;
+                tokenAddress: z.ZodCustom<`0x${string}`, `0x${string}`>;
+                rewardItems: z.ZodOptional<z.ZodArray<z.ZodType<import("../../index.js").RewardItem, unknown, z.core.$ZodTypeInternals<import("../../index.js").RewardItem, unknown>>>>;
+                type: z.ZodLiteral<"single">;
+            }, z.core.$strict>, z.ZodObject<{
+                allowance: z.ZodCustom<`0x${string}`, `0x${string}`>;
+                tokenAddress: z.ZodCustom<`0x${string}`, `0x${string}`>;
+                rewardItems: z.ZodOptional<z.ZodArray<z.ZodType<import("../../index.js").RewardItem, unknown, z.core.$ZodTypeInternals<import("../../index.js").RewardItem, unknown>>>>;
+                type: z.ZodLiteral<"recurring">;
+                startDate: z.ZodOptional<z.ZodNumber>;
+                billingPeriod: z.ZodEnum<{
+                    weekly: "weekly";
+                    monthly: "monthly";
+                    annually: "annually";
+                }>;
+            }, z.core.$strict>], "type">;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "type">;
+    rules: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        isAdjustmentAllowed: z.ZodBoolean;
+        justification: z.ZodString;
+        type: z.ZodLiteral<"expiry">;
+        data: z.ZodObject<{
+            timestamp: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        isAdjustmentAllowed: z.ZodBoolean;
+        justification: z.ZodString;
+        type: z.ZodLiteral<"identity-mint">;
+        data: z.ZodObject<{
+            identityMintPayload: z.ZodType<import("../../index.js").IdentityMintSignPayloadWithSignature, unknown, z.core.$ZodTypeInternals<import("../../index.js").IdentityMintSignPayloadWithSignature, unknown>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "type">>>;
+}, z.core.$strict>>;
+export declare const permissionResponseSchema: z.ZodObject<{
+    chainId: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    to: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    permission: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        isAdjustmentAllowed: z.ZodBoolean;
+        justification: z.ZodString;
+        type: z.ZodLiteral<"erc20-token-payment">;
+        data: z.ZodObject<{
+            recipient: z.ZodCustom<`0x${string}`, `0x${string}`>;
+            paymentDetails: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                allowance: z.ZodCustom<`0x${string}`, `0x${string}`>;
+                tokenAddress: z.ZodCustom<`0x${string}`, `0x${string}`>;
+                rewardItems: z.ZodOptional<z.ZodArray<z.ZodType<import("../../index.js").RewardItem, unknown, z.core.$ZodTypeInternals<import("../../index.js").RewardItem, unknown>>>>;
+                type: z.ZodLiteral<"single">;
+            }, z.core.$strict>, z.ZodObject<{
+                allowance: z.ZodCustom<`0x${string}`, `0x${string}`>;
+                tokenAddress: z.ZodCustom<`0x${string}`, `0x${string}`>;
+                rewardItems: z.ZodOptional<z.ZodArray<z.ZodType<import("../../index.js").RewardItem, unknown, z.core.$ZodTypeInternals<import("../../index.js").RewardItem, unknown>>>>;
+                type: z.ZodLiteral<"recurring">;
+                startDate: z.ZodOptional<z.ZodNumber>;
+                billingPeriod: z.ZodEnum<{
+                    weekly: "weekly";
+                    monthly: "monthly";
+                    annually: "annually";
+                }>;
+            }, z.core.$strict>], "type">;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "type">;
+    rules: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        isAdjustmentAllowed: z.ZodBoolean;
+        justification: z.ZodString;
+        type: z.ZodLiteral<"expiry">;
+        data: z.ZodObject<{
+            timestamp: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        isAdjustmentAllowed: z.ZodBoolean;
+        justification: z.ZodString;
+        type: z.ZodLiteral<"identity-mint">;
+        data: z.ZodObject<{
+            identityMintPayload: z.ZodType<import("../../index.js").IdentityMintSignPayloadWithSignature, unknown, z.core.$ZodTypeInternals<import("../../index.js").IdentityMintSignPayloadWithSignature, unknown>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "type">>>;
+    from: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    context: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    dependencies: z.ZodArray<z.ZodObject<{
+        factory: z.ZodCustom<`0x${string}`, `0x${string}`>;
+        factoryData: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    }, z.core.$strict>>;
+    delegationManager: z.ZodCustom<`0x${string}`, `0x${string}`>;
+}, z.core.$strict>;
+export declare const permissionsResponseSchema: z.ZodArray<z.ZodObject<{
+    chainId: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    to: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    permission: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        isAdjustmentAllowed: z.ZodBoolean;
+        justification: z.ZodString;
+        type: z.ZodLiteral<"erc20-token-payment">;
+        data: z.ZodObject<{
+            recipient: z.ZodCustom<`0x${string}`, `0x${string}`>;
+            paymentDetails: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                allowance: z.ZodCustom<`0x${string}`, `0x${string}`>;
+                tokenAddress: z.ZodCustom<`0x${string}`, `0x${string}`>;
+                rewardItems: z.ZodOptional<z.ZodArray<z.ZodType<import("../../index.js").RewardItem, unknown, z.core.$ZodTypeInternals<import("../../index.js").RewardItem, unknown>>>>;
+                type: z.ZodLiteral<"single">;
+            }, z.core.$strict>, z.ZodObject<{
+                allowance: z.ZodCustom<`0x${string}`, `0x${string}`>;
+                tokenAddress: z.ZodCustom<`0x${string}`, `0x${string}`>;
+                rewardItems: z.ZodOptional<z.ZodArray<z.ZodType<import("../../index.js").RewardItem, unknown, z.core.$ZodTypeInternals<import("../../index.js").RewardItem, unknown>>>>;
+                type: z.ZodLiteral<"recurring">;
+                startDate: z.ZodOptional<z.ZodNumber>;
+                billingPeriod: z.ZodEnum<{
+                    weekly: "weekly";
+                    monthly: "monthly";
+                    annually: "annually";
+                }>;
+            }, z.core.$strict>], "type">;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "type">;
+    rules: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        isAdjustmentAllowed: z.ZodBoolean;
+        justification: z.ZodString;
+        type: z.ZodLiteral<"expiry">;
+        data: z.ZodObject<{
+            timestamp: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        isAdjustmentAllowed: z.ZodBoolean;
+        justification: z.ZodString;
+        type: z.ZodLiteral<"identity-mint">;
+        data: z.ZodObject<{
+            identityMintPayload: z.ZodType<import("../../index.js").IdentityMintSignPayloadWithSignature, unknown, z.core.$ZodTypeInternals<import("../../index.js").IdentityMintSignPayloadWithSignature, unknown>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "type">>>;
+    from: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    context: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    dependencies: z.ZodArray<z.ZodObject<{
+        factory: z.ZodCustom<`0x${string}`, `0x${string}`>;
+        factoryData: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    }, z.core.$strict>>;
+    delegationManager: z.ZodCustom<`0x${string}`, `0x${string}`>;
+}, z.core.$strict>>;
+export declare const getPermissionsInfoResultParamsSchema: z.ZodObject<{
+    chainIds: z.ZodArray<z.ZodCustom<`0x${string}`, `0x${string}`>>;
+}, z.core.$strict>;
+export declare const supportedExecutionPermissionInfoSchema: z.ZodObject<{
+    chainIds: z.ZodArray<z.ZodCustom<`0x${string}`, `0x${string}`>>;
+    ruleTypes: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const getSupportedExecutionPermissionsResultSchema: z.ZodObject<{
+    'erc20-token-payment': z.ZodObject<{
+        chainIds: z.ZodArray<z.ZodCustom<`0x${string}`, `0x${string}`>>;
+        ruleTypes: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/**
+ * Parses init code dependency data.
+ *
+ * @param value - The value to validate.
+ * @returns The parsed init code dependency data.
+ */
+export declare function parseInitCodeData(value: unknown): InitCodeData;
+/**
+ * Parses a permission request.
+ *
+ * @param value - The value to validate.
+ * @returns The parsed permission request.
+ */
+export declare function parsePermissionRequest(value: unknown): PermissionRequest;
+/**
+ * Parses a list of permission requests.
+ *
+ * @param value - The value to validate.
+ * @returns The parsed permission request list.
+ */
+export declare function parsePermissionsRequest(value: unknown): PermissionsRequest;
+/**
+ * Parses a permission response.
+ *
+ * @param value - The value to validate.
+ * @returns The parsed permission response.
+ */
+export declare function parsePermissionResponse(value: unknown): PermissionResponse;
+/**
+ * Parses a list of permission responses.
+ *
+ * @param value - The value to validate.
+ * @returns The parsed permission response list.
+ */
+export declare function parsePermissionsResponse(value: unknown): PermissionsResponse;
+/**
+ * Parses get-permissions-info result params.
+ *
+ * @param value - The value to validate.
+ * @returns The parsed get-permissions-info result params.
+ */
+export declare function parseGetPermissionsInfoResultParams(value: unknown): GetPermissionsInfoResultParams;
+/**
+ * Parses supported execution permission metadata.
+ *
+ * @param value - The value to validate.
+ * @returns The parsed supported execution permissions result.
+ */
+export declare function parseGetSupportedExecutionPermissionsResult(value: unknown): GetSupportedExecutionPermissionsResult;

package/dist/erc-7715/request/types.d.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { SupportedPermissionTypes, Permission } from '../permission/types.js';
+import { Rule, SupportedRuleTypes } from '../rules/types.js';
+import { getPermissionsInfoResultParamsSchema, getSupportedExecutionPermissionsResultSchema, initCodeDataSchema, permissionRequestSchema, permissionResponseSchema, permissionsRequestSchema, permissionsResponseSchema } from './schemas.js';
+/**
+ * A request to grant erc-7715 permissions to a signer.
+ */
+export type PermissionRequest<TPermission extends SupportedPermissionTypes = SupportedPermissionTypes, TRule extends SupportedRuleTypes = SupportedRuleTypes> = z.infer<typeof permissionRequestSchema> & {
+    chainId: z.infer<typeof permissionRequestSchema>['chainId'];
+    from?: z.infer<typeof permissionRequestSchema>['from'];
+    to: z.infer<typeof permissionRequestSchema>['to'];
+    permission: Permission<TPermission>;
+    rules?: Rule<TRule>[] | undefined;
+};
+/**
+ * A request to grant erc-7715 permissions to a signer.
+ */
+export type PermissionsRequest = PermissionRequest<SupportedPermissionTypes, SupportedRuleTypes>[] & z.infer<typeof permissionsRequestSchema>;
+export type InitCodeData = z.infer<typeof initCodeDataSchema>;
+/**
+ * A response to a request to grant erc-7715 permissions to a signer.
+ */
+export type PermissionResponse<TPermission extends SupportedPermissionTypes = SupportedPermissionTypes, TRule extends SupportedRuleTypes = SupportedRuleTypes> = z.infer<typeof permissionResponseSchema> & PermissionRequest<TPermission, TRule> & {
+    from: z.infer<typeof permissionResponseSchema>['from'];
+    /**
+     * The context is a catch-all to identify a permission for revoking permissions or redeeming permissions,
+     * and can contain non-identifying data as well. The context is required as defined in ERC-7710.
+     */
+    context: z.infer<typeof permissionResponseSchema>['context'];
+    dependencies: InitCodeData[];
+    delegationManager: z.infer<typeof permissionResponseSchema>['delegationManager'];
+};
+/**
+ * A response to a request to grant erc-7715 permissions to a signer.
+ */
+export type PermissionsResponse = PermissionResponse<SupportedPermissionTypes, SupportedRuleTypes>[] & z.infer<typeof permissionsResponseSchema>;
+/**
+ * A response to allow a Wallet to specify the 7715 permission types and rules types it supports.
+ */
+export type GetPermissionsInfoResultParams = z.infer<typeof getPermissionsInfoResultParamsSchema>;
+/**
+ * A response that include an object keyed on supported permission types including ruleTypes (string[]) that can be applied to the permission.
+ */
+export type GetSupportedExecutionPermissionsResult = Record<SupportedPermissionTypes, {
+    chainIds: z.infer<typeof getSupportedExecutionPermissionsResultSchema>['erc20-token-payment']['chainIds'];
+    ruleTypes: string[];
+}>;

package/dist/erc-7715/rules/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './schemas.js';

package/dist/erc-7715/rules/schemas.d.ts

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import type { IdentityMintSignPayloadWithSignature } from '../../identity/types.js';
+import type { ExpiryRule, IdentityMintRule, Rule } from './types.js';
+export declare const identityTypeSchema: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+export declare const burnAuthSchema: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+export declare const identityMintSignPayloadWithSignatureSchema: z.ZodType<IdentityMintSignPayloadWithSignature>;
+export declare const expiryRuleSchema: z.ZodObject<{
+    isAdjustmentAllowed: z.ZodBoolean;
+    justification: z.ZodString;
+    type: z.ZodLiteral<"expiry">;
+    data: z.ZodObject<{
+        timestamp: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const identityMintRuleSchema: z.ZodObject<{
+    isAdjustmentAllowed: z.ZodBoolean;
+    justification: z.ZodString;
+    type: z.ZodLiteral<"identity-mint">;
+    data: z.ZodObject<{
+        identityMintPayload: z.ZodType<IdentityMintSignPayloadWithSignature, unknown, z.core.$ZodTypeInternals<IdentityMintSignPayloadWithSignature, unknown>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ruleSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    isAdjustmentAllowed: z.ZodBoolean;
+    justification: z.ZodString;
+    type: z.ZodLiteral<"expiry">;
+    data: z.ZodObject<{
+        timestamp: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    isAdjustmentAllowed: z.ZodBoolean;
+    justification: z.ZodString;
+    type: z.ZodLiteral<"identity-mint">;
+    data: z.ZodObject<{
+        identityMintPayload: z.ZodType<IdentityMintSignPayloadWithSignature, unknown, z.core.$ZodTypeInternals<IdentityMintSignPayloadWithSignature, unknown>>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "type">;
+export declare const ruleSchemas: {
+    expiry: z.ZodObject<{
+        isAdjustmentAllowed: z.ZodBoolean;
+        justification: z.ZodString;
+        type: z.ZodLiteral<"expiry">;
+        data: z.ZodObject<{
+            timestamp: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    identityMint: z.ZodObject<{
+        isAdjustmentAllowed: z.ZodBoolean;
+        justification: z.ZodString;
+        type: z.ZodLiteral<"identity-mint">;
+        data: z.ZodObject<{
+            identityMintPayload: z.ZodType<IdentityMintSignPayloadWithSignature, unknown, z.core.$ZodTypeInternals<IdentityMintSignPayloadWithSignature, unknown>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+};
+/**
+ * Parses an expiry rule.
+ *
+ * @param value - The value to validate.
+ * @returns The parsed expiry rule.
+ */
+export declare function parseExpiryRule(value: unknown): ExpiryRule;
+/**
+ * Parses an identity-mint rule.
+ *
+ * @param value - The value to validate.
+ * @returns The parsed identity-mint rule.
+ */
+export declare function parseIdentityMintRule(value: unknown): IdentityMintRule;
+/**
+ * Parses any supported ERC-7715 rule.
+ *
+ * @param value - The value to validate.
+ * @returns The parsed rule.
+ */
+export declare function parseRule(value: unknown): Rule;

package/dist/erc-7715/rules/types.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { expiryRuleSchema, identityMintRuleSchema, ruleSchema } from './schemas.js';
+/**
+ * A rule that sets an expiry timestamp for a permission.
+ */
+export type ExpiryRule = z.infer<typeof expiryRuleSchema>;
+/**
+ * A rule that sets an identity mint payload.
+ * It requires an identity to be minted before the permission can be used.
+ */
+export type IdentityMintRule = z.infer<typeof identityMintRuleSchema>;
+/**
+ * A mapping of rule types to their corresponding rule schemas.
+ */
+export type RuleTypeMapping = {
+    expiry: ExpiryRule;
+    identityMint: IdentityMintRule;
+};
+/**
+ * A type that represents the different types of rules.
+ */
+export type SupportedRuleTypes = keyof RuleTypeMapping;
+/**
+ * A type that represents a rule.
+ */
+export type Rule<TRule extends SupportedRuleTypes = SupportedRuleTypes> = RuleTypeMapping[TRule] & z.infer<typeof ruleSchema>;

package/dist/identity/cashieIdentitySoulTypedData.d.ts

@@ -0,0 +1,65 @@
+import type { Address, Hex } from 'viem';
+import { type CashieIdentitySoulEip712Domain, type IdentityMintProofSignPayload, type IdentityMintProofTypedData, type IdentityMintSignPayload, type IdentityMintConsentTypedData } from './types.js';
+/**
+ * Args for recipient identity mint consent (`IdentityMintConsent`, includes issuer `proof`).
+ */
+export type IdentityMintConsentArgs = {
+    /** Hex encoding of uint256 (e.g. `0x1`); same shape as payment intent / provider RPC `chainId`. */
+    chainId: Hex;
+    verifyingContract: Address;
+    message: IdentityMintSignPayload;
+};
+/**
+ * Args for Identity Verification Prover signing (`IdentityMintPayload`, excludes `proof` / `signature`).
+ */
+export type IdentityMintProofArgs = {
+    /** Hex encoding of uint256 (e.g. `0x1`); same shape as payment intent / provider RPC `chainId`. */
+    chainId: Hex;
+    verifyingContract: Address;
+    message: IdentityMintProofSignPayload;
+};
+/**
+ * Builds the EIP-712 domain used by `CashieIdentitySoul`
+ * (`EIP712(CashieIdentitySoul.NAME, CashieIdentitySoul.DOMAIN_VERSION)` in onchain `CashieIdentitySoul` contract).
+ *
+ * @param chainId Hex-encoded chain id (uint256)
+ * @param verifyingContract The address of the verifying contract
+ * @returns The EIP-712 domain
+ */
+export declare function buildCashieIdentitySoulDomain(chainId: Hex, verifyingContract: Address): CashieIdentitySoulEip712Domain;
+/**
+ * Constructs typed-data for the recipient consent signer (`IdentityMintConsent`).
+ * Pass the result to `walletClient.signTypedData` or any EIP-1193 `eth_signTypedData_v4` flow.
+ *
+ * The `message` must include issuer `proof` and must **not** include `signature`.
+ *
+ * @param args Consent typed-data args
+ * @returns Recipient consent typed data
+ */
+export declare function buildIdentityMintConsentTypedData(args: IdentityMintConsentArgs): IdentityMintConsentTypedData;
+/**
+ * Constructs typed-data for the Identity Verification Prover (`IdentityMintPayload`).
+ * Pass the result to `walletClient.signTypedData` or any EIP-1193 `eth_signTypedData_v4` flow.
+ *
+ * The `message` must **not** include `proof` or `signature`.
+ *
+ * @param args Prover typed-data args
+ * @returns Prover proof typed data
+ */
+export declare function buildIdentityMintProofTypedData(args: IdentityMintProofArgs): IdentityMintProofTypedData;
+/**
+ * EIP-712 digest for recipient consent EIP-1271 verification
+ * (`IdentitySoulEncoderLib.hashIdentityMintConsent`).
+ *
+ * @param args Consent typed-data args
+ * @returns The EIP-712 digest
+ */
+export declare function hashIdentityMintConsentTypedData(args: IdentityMintConsentArgs): Hex;
+/**
+ * EIP-712 digest for issuer / prover EIP-1271 verification
+ * (`IdentitySoulEncoderLib.hashIdentityMintPayload`).
+ *
+ * @param args Prover typed-data args
+ * @returns The EIP-712 digest
+ */
+export declare function hashIdentityMintProofTypedData(args: IdentityMintProofArgs): Hex;

package/dist/identity/encoder.d.ts

@@ -0,0 +1,24 @@
+import type { Address, Hex } from 'viem';
+/**
+ * Same as `IdentityTokenIdLib.tokenIdFor` — `uint256(uint160(account))`.
+ *
+ * @param account Holder address (checksum-normalized)
+ * @returns ERC-721 token id for `CashieIdentitySoul`
+ */
+export declare function identityTokenIdFor(account: Address): bigint;
+/**
+ * Same as `IdentityTokenIdLib.accountFor` — `address(uint160(tokenId))` (high bits ignored).
+ *
+ * @param tokenId On-chain token id (may include junk above bit 159)
+ * @returns Address from the low 160 bits
+ */
+export declare function identityAccountFor(tokenId: bigint): Address;
+/**
+ * Off-chain **`keccak256`** over the canonical commitment preimage string.
+ * Kept here (vs `cashieIdentitySoulTypedData.ts`) so EIP-712 wiring stays focused on typed-data signing.
+ *
+ * @param providerId Provider id segment
+ * @param account Account segment
+ * @returns Digest (`Hex`) of ``keccak256(`0x${providerId}-${account}`)``
+ */
+export declare function buildIdentityCommitmentHash(providerId: string, account: string): Hex;

package/dist/identity/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './encoder.js';
+export * from './cashieIdentitySoulTypedData.js';
+export * from './issuer/index.js';
+export * from './soul/index.js';

package/dist/identity/issuer/error/index.d.ts

@@ -0,0 +1 @@
+export * from './plaidIdvErrors.js';

package/dist/identity/issuer/error/plaidIdvErrors.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Stable error codes returned by Plaid Identity Verification handlers.
+ */
+export declare enum PlaidIdvErrorCode {
+    IDV_SESSION_SUCCESS = "IDV_SESSION_SUCCESS",
+    IDV_SESSION_PENDING_REVIEW = "IDV_SESSION_PENDING_REVIEW",
+    INVALID_IDV_SESSION = "INVALID_IDV_SESSION",
+    IDV_MAX_FAILED_VERIFICATION_THRESHOLD_REACHED = "IDV_MAX_FAILED_VERIFICATION_THRESHOLD_REACHED"
+}
+/**
+ * Human-readable messages keyed by {@link PlaidIdvErrorCode}.
+ */
+export declare const PLAID_IDV_ERROR_MESSAGE: Record<PlaidIdvErrorCode, string>;
+export type PlaidIdvErrorBody = {
+    error_code: PlaidIdvErrorCode;
+    error_message: string;
+};
+/**
+ * Build the `{ error_code, error_message }` body for a Plaid IDV error.
+ *
+ * @param code - Stable error code
+ * @returns JSON error body
+ */
+export declare const plaidIdvError: (code: PlaidIdvErrorCode) => PlaidIdvErrorBody;

package/dist/identity/issuer/identity-issuer.d.ts

@@ -0,0 +1,30 @@
+import { IssueIdentityProofRequest, IssuedIdentityProofResponse } from './types.js';
+interface IIdentityIssuer {
+    issueIdentityProof(request: IssueIdentityProofRequest): Promise<IssuedIdentityProofResponse>;
+    isSupportedIdentityIssuerId(identityIssuerId: string): boolean;
+}
+export type IdentityIssuerArgs = {
+    idvProverUrl: string;
+};
+export declare class IdentityIssuer implements IIdentityIssuer {
+    #private;
+    constructor(config: IdentityIssuerArgs);
+    private postIdvProver;
+    /**
+     * POST /api/idv/generate-identity-proof — Issue identity proof for Cashie Identity Soul
+     *
+     * @param params - The parameters for generating the identity proof.
+     * @returns Promise resolving to the issued identity proof.
+     */
+    private generatePlaidIdentityProof;
+    /**
+     * POST /api/idv/generate-identity-proof — Issue identity proof for Cashie Identity Soul
+     *
+     * @param params - The parameters for generating the identity proof.
+     * @returns Promise resolving to the issued identity proof.
+     */
+    private generateBusinessIdentityProof;
+    issueIdentityProof(request: IssueIdentityProofRequest): Promise<IssuedIdentityProofResponse>;
+    isSupportedIdentityIssuerId(identityIssuerId: string): boolean;
+}
+export {};

package/dist/identity/issuer/index.d.ts

@@ -0,0 +1,3 @@
+export * from './identity-issuer.js';
+export * from './types.js';
+export * from './error/index.js';

package/dist/identity/issuer/types.d.ts

@@ -0,0 +1,35 @@
+import { Address } from 'viem';
+import { IdentityMintSignPayload } from '../types.js';
+/**
+ * Issued identity proof from an Identity Verification Prover flow.
+ * Client supplies `to` and asks the recipient to sign `IdentityMintConsent` over these fields + `proof`.
+ */
+export type IssuedIdentityProofResponse = Omit<IdentityMintSignPayload, 'to'>;
+/**
+ * Supported identity issuer IDs for identity verification for Cashie Identity Soul.
+ */
+export declare enum IdentityIssuerId {
+    PLAID = "plaid-identity",
+    BUSINESS = "business-identity"
+}
+export type PlaidIssueIdentityProofParams = {
+    account: Address;
+};
+export type BusinessIssueIdentityProofParams = {
+    account: Address;
+    /**
+     * Site hostname without scheme (e.g. `merchant.example.com`).
+     */
+    domain: string;
+};
+export type IdentityProofParamsToType = {
+    [IdentityIssuerId.PLAID]: PlaidIssueIdentityProofParams;
+    [IdentityIssuerId.BUSINESS]: BusinessIssueIdentityProofParams;
+};
+export type SupportedIssueIdentityProofParams = keyof IdentityProofParamsToType;
+export type IssueIdentityProofRequest = {
+    [K in SupportedIssueIdentityProofParams]: {
+        identityIssuerId: K;
+        params: IdentityProofParamsToType[K];
+    };
+}[SupportedIssueIdentityProofParams];

package/dist/identity/soul/index.d.ts

@@ -0,0 +1 @@
+export * from './soulManager.js';