@cashie/core-lib 1.1.0 → 1.3.0

package/dist/backend/contracts/badge.types.d.ts

@@ -1,17 +1,21 @@
 import { Address, Hex } from 'viem';
-import { CashieReceiptBadgeMetadata, CashiePaymentRecordBadgeMetadata } from '../../data/types.js';
+import { CashieReceiptBadgeMetadata, CashiePaymentRecordBadgeMetadata, CashieMembershipBadgeMetadata } from '../../data/types.js';
 export type BadgeOwner = {
     nftAddress: Address;
     nftTokenId: Hex;
 };
-export type BadgeKind = 'receipt' | 'paymentRecord';
-export type BadgeMetadata = CashieReceiptBadgeMetadata | CashiePaymentRecordBadgeMetadata;
+export type BadgeKind = 'receipt' | 'paymentRecord' | 'membership';
+export type BadgeMetadata = CashieReceiptBadgeMetadata | CashiePaymentRecordBadgeMetadata | CashieMembershipBadgeMetadata;
 export type BadgeChainParams = {
     chainHex: Hex;
+    badgeKind: BadgeKind;
 };
 export type GetBadgeOwnerOfParams = BadgeChainParams & {
     badgeId: Hex;
 };
+export type GetBadgeUriParams = BadgeChainParams & {
+    badgeId: Hex;
+};
 export type GetBadgeMetadataFormatParams = BadgeChainParams;
 export type TotalBadgesOfIdentityParams = BadgeChainParams & {
     account: Address;

package/dist/backend/tx-tracking/types.d.ts

@@ -1,9 +1,12 @@
 import { Hex, Hash, Address } from 'viem';
-import { BadgeKind, PaymentIntent } from '../../index.js';
-export type SendPaymentIntentTaskEntry = {
+import type { BadgeKind } from '../contracts/badge.types.js';
+import { PaymentIntentActions, type Intent, type IntentActions } from '../../intent/types.js';
+export type TaskEntry<TIntentAction extends IntentActions> = {
+    action: TIntentAction;
     id: string;
-    data: {
-        paymentIntent: PaymentIntent;
+    data: Intent<TIntentAction>;
+    droppedDetails?: {
+        reason: string;
     };
 };
 /**
@@ -12,30 +15,47 @@ export type SendPaymentIntentTaskEntry = {
 export type TransactionEntry = {
     txHash: Hash;
     chainId: Hex;
-    taskEntries: SendPaymentIntentTaskEntry[];
+    taskEntries: TaskEntry<IntentActions>[];
 };
 /**
  * A payment intent tracking entry.
  */
-export type PaymentIntentTrackingEntry = {
-    paymentIntent: PaymentIntent;
+export type IntentTrackingEntry<TIntentAction extends IntentActions> = {
+    intent: Intent<TIntentAction>;
     status: 'pending' | 'confirmed' | 'failed';
     txHash?: Hash | null;
     blockNumber?: Hex | null;
 };
+/**
+ * Returns true when `action` is a {@link PaymentIntentActions} value.
+ *
+ * @param action - The intent action to check
+ * @returns Whether the action is a payment intent action
+ */
+export declare function isPaymentIntentAction(action: IntentActions): action is PaymentIntentActions;
+/**
+ * Returns true when the tracking entry holds a payment intent.
+ *
+ * @param entry - The intent tracking entry to check
+ * @returns Whether the entry is a payment intent tracking entry
+ */
+export declare function isPaymentIntentTrackingEntry(entry: IntentTrackingEntry<IntentActions>): entry is IntentTrackingEntry<PaymentIntentActions>;
 /**
  * Find the transaction hash for a badge id.
  *
+ * Only confirmed {@link PaymentIntentActions}
+ * entries with a transaction hash and block number are considered.
+ *
  * @param props - The properties of the badge.
  * @param props.badgeId - The id of the badge.
  * @param props.badgeKind - The kind of the badge.
  * @param props.identityContract - The identity contract.
- * @param props.paymentIntentTrackingEntries - The payment intent tracking entries.
+ * @param props.paymentIntentTrackingEntries - Tracking entries for any intent type.
  * @returns The transaction hash for the badge id.
  */
 export declare function findTransactionHashForBadgeId(props: {
     badgeId: Hex;
     badgeKind: BadgeKind;
     identityContract: Address;
-    paymentIntentTrackingEntries: PaymentIntentTrackingEntry[];
+    paymentIntentTrackingEntries: IntentTrackingEntry<PaymentIntentActions>[];
 }): Hex | null;

package/dist/client/payment-client.d.ts

@@ -1,25 +1,26 @@
-import { PaymentRpcParams, PaymentRpcReturn } from './types.js';
+import { RpcParams, PaymentRpcReturn } from './types.js';
 export type PaymentRpcClientArgs = {
     url: string;
     chainId: number;
 };
 export interface PaymentRpcClient {
-    getIdentitySoulDiscovery(params: PaymentRpcParams<'discovery_supportedSouls'>): Promise<PaymentRpcReturn<'discovery_supportedSouls'>>;
-    getProtocolFeeBps(params: PaymentRpcParams<'payment_getProtocolFeeBps'>): Promise<PaymentRpcReturn<'payment_getProtocolFeeBps'>>;
-    calculateRewardAmount(params: PaymentRpcParams<'payment_calculateRewardAmount'>): Promise<PaymentRpcReturn<'payment_calculateRewardAmount'>>;
-    sendIntent(params: PaymentRpcParams<'payment_sendIntent'>): Promise<PaymentRpcReturn<'payment_sendIntent'>>;
-    getIntentStatuses(params: PaymentRpcParams<'payment_getIntentStatuses'>): Promise<PaymentRpcReturn<'payment_getIntentStatuses'>>;
-    prepareRouterCallsFromAction(params: PaymentRpcParams<'payment_prepareRouterCallsFromAction'>): Promise<PaymentRpcReturn<'payment_prepareRouterCallsFromAction'>>;
-    getBurnAuth(params: PaymentRpcParams<'identity_getBurnAuth'>): Promise<PaymentRpcReturn<'identity_getBurnAuth'>>;
-    getTokenURI(params: PaymentRpcParams<'identity_getTokenURI'>): Promise<PaymentRpcReturn<'identity_getTokenURI'>>;
-    sendPrePaymentSetup(params: PaymentRpcParams<'payment_sendPrePaymentSetup'>): Promise<PaymentRpcReturn<'payment_sendPrePaymentSetup'>>;
-    getPrePaymentSetup(params: PaymentRpcParams<'payment_getPrePaymentSetup'>): Promise<PaymentRpcReturn<'payment_getPrePaymentSetup'>>;
-    getBadgeOwnerOf(params: PaymentRpcParams<'badge_getOwnerOf'>): Promise<PaymentRpcReturn<'badge_getOwnerOf'>>;
-    getBadgeUri(params: PaymentRpcParams<'badge_getBadgeUri'>): Promise<PaymentRpcReturn<'badge_getBadgeUri'>>;
-    getBadgeMetadataFormat(params: PaymentRpcParams<'badge_getMetadataFormat'>): Promise<PaymentRpcReturn<'badge_getMetadataFormat'>>;
-    getTotalBadgesOfIdentity(params: PaymentRpcParams<'badge_totalBadgesOfIdentity'>): Promise<PaymentRpcReturn<'badge_totalBadgesOfIdentity'>>;
-    getBadgeOfIdentityByIndex(params: PaymentRpcParams<'badge_badgeOfIdentityByIndex'>): Promise<PaymentRpcReturn<'badge_badgeOfIdentityByIndex'>>;
-    getBadgesOfIdentity(params: PaymentRpcParams<'badge_badgesOfIdentity'>): Promise<PaymentRpcReturn<'badge_badgesOfIdentity'>>;
+    getIdentitySoulDiscovery(params: RpcParams<'discovery_supportedSouls'>): Promise<PaymentRpcReturn<'discovery_supportedSouls'>>;
+    getProtocolFeeBps(params: RpcParams<'payment_getProtocolFeeBps'>): Promise<PaymentRpcReturn<'payment_getProtocolFeeBps'>>;
+    calculateRewardAmount(params: RpcParams<'payment_calculateRewardAmount'>): Promise<PaymentRpcReturn<'payment_calculateRewardAmount'>>;
+    sendIntent(params: RpcParams<'cashie_sendIntent'>): Promise<PaymentRpcReturn<'cashie_sendIntent'>>;
+    getIntentStatus(params: RpcParams<'cashie_getIntentStatus'>): Promise<PaymentRpcReturn<'cashie_getIntentStatus'>>;
+    getIntentStatuses(params: RpcParams<'cashie_getIntentStatuses'>): Promise<PaymentRpcReturn<'cashie_getIntentStatuses'>>;
+    prepareRouterCallsFromAction(params: RpcParams<'payment_prepareRouterCallsFromAction'>): Promise<PaymentRpcReturn<'payment_prepareRouterCallsFromAction'>>;
+    getBurnAuth(params: RpcParams<'identity_getBurnAuth'>): Promise<PaymentRpcReturn<'identity_getBurnAuth'>>;
+    getTokenURI(params: RpcParams<'identity_getTokenURI'>): Promise<PaymentRpcReturn<'identity_getTokenURI'>>;
+    sendPrePaymentSetup(params: RpcParams<'payment_sendPrePaymentSetup'>): Promise<PaymentRpcReturn<'payment_sendPrePaymentSetup'>>;
+    getPrePaymentSetup(params: RpcParams<'payment_getPrePaymentSetup'>): Promise<PaymentRpcReturn<'payment_getPrePaymentSetup'>>;
+    getBadgeOwnerOf(params: RpcParams<'badge_getOwnerOf'>): Promise<PaymentRpcReturn<'badge_getOwnerOf'>>;
+    getBadgeUri(params: RpcParams<'badge_getBadgeUri'>): Promise<PaymentRpcReturn<'badge_getBadgeUri'>>;
+    getBadgeMetadataFormat(params: RpcParams<'badge_getMetadataFormat'>): Promise<PaymentRpcReturn<'badge_getMetadataFormat'>>;
+    getTotalBadgesOfIdentity(params: RpcParams<'badge_totalBadgesOfIdentity'>): Promise<PaymentRpcReturn<'badge_totalBadgesOfIdentity'>>;
+    getBadgeOfIdentityByIndex(params: RpcParams<'badge_badgeOfIdentityByIndex'>): Promise<PaymentRpcReturn<'badge_badgeOfIdentityByIndex'>>;
+    getBadgesOfIdentity(params: RpcParams<'badge_badgesOfIdentity'>): Promise<PaymentRpcReturn<'badge_badgesOfIdentity'>>;
 }
 /**
  * Creates a new Payment RPC client.

package/dist/client/schemas.d.ts

@@ -1,27 +1,15 @@
 import { z } from 'zod';
 import { BurnAuth } from '../identity/types.js';
-import type { PaymentIntentTrackingEntry } from '../backend/tx-tracking/types.js';
-import type { PaymentRpcMethodNames, PaymentRpcReturn } from './types.js';
+import { type IntentActions } from '../intent/types.js';
+import type { IntentTrackingEntry } from '../backend/tx-tracking/types.js';
+import type { RpcMethodNames, RpcParams, PaymentRpcReturn } from './types.js';
 export declare const paymentRpcReturnSchemas: {
-    discovery_supportedSouls: z.ZodObject<{
-        identitySoulContract: z.ZodObject<{
-            address: z.ZodCustom<`0x${string}`, `0x${string}`>;
-            badgeContracts: z.ZodObject<{
-                paymentRecordBadgeContract: z.ZodCustom<`0x${string}`, `0x${string}`>;
-                receiptBadgeContract: z.ZodCustom<`0x${string}`, `0x${string}`>;
-            }, z.core.$strip>;
-        }, z.core.$strip>;
-    }, z.core.$strip>;
     payment_getProtocolFeeBps: z.ZodCustom<`0x${string}`, `0x${string}`>;
     payment_calculateRewardAmount: z.ZodCustom<`0x${string}`, `0x${string}`>;
-    payment_sendIntent: z.ZodCustom<`0x${string}`, `0x${string}`>;
-    payment_getIntentStatuses: z.ZodArray<z.ZodType<PaymentIntentTrackingEntry, unknown, z.core.$ZodTypeInternals<PaymentIntentTrackingEntry, unknown>>>;
     payment_prepareRouterCallsFromAction: z.ZodArray<z.ZodObject<{
         to: z.ZodCustom<`0x${string}`, `0x${string}`>;
         data: z.ZodCustom<`0x${string}`, `0x${string}`>;
     }, z.core.$strip>>;
-    identity_getBurnAuth: z.ZodCustom<BurnAuth, BurnAuth>;
-    identity_getTokenURI: z.ZodNullable<z.ZodString>;
     payment_sendPrePaymentSetup: z.ZodCustom<`0x${string}`, `0x${string}`>;
     payment_getPrePaymentSetup: z.ZodNullable<z.ZodObject<{
         signedIdentityMintPayload: z.ZodType<import("../identity/types.js").IdentityMintSignPayloadWithSignature, unknown, z.core.$ZodTypeInternals<import("../identity/types.js").IdentityMintSignPayloadWithSignature, unknown>>;
@@ -30,6 +18,21 @@ export declare const paymentRpcReturnSchemas: {
             factoryData: z.ZodCustom<`0x${string}`, `0x${string}`>;
         }, z.core.$strict>;
     }, z.core.$strict>>;
+    cashie_sendIntent: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    cashie_getIntentStatus: z.ZodNullable<z.ZodType<IntentTrackingEntry<IntentActions>, unknown, z.core.$ZodTypeInternals<IntentTrackingEntry<IntentActions>, unknown>>>;
+    cashie_getIntentStatuses: z.ZodArray<z.ZodType<IntentTrackingEntry<IntentActions>, unknown, z.core.$ZodTypeInternals<IntentTrackingEntry<IntentActions>, unknown>>>;
+    discovery_supportedSouls: z.ZodObject<{
+        identitySoulContract: z.ZodObject<{
+            address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+            badgeContracts: z.ZodObject<{
+                paymentRecordBadgeContract: z.ZodCustom<`0x${string}`, `0x${string}`>;
+                receiptBadgeContract: z.ZodCustom<`0x${string}`, `0x${string}`>;
+                membershipBadgeContract: z.ZodCustom<`0x${string}`, `0x${string}`>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    identity_getBurnAuth: z.ZodCustom<BurnAuth, BurnAuth>;
+    identity_getTokenURI: z.ZodNullable<z.ZodString>;
     badge_getOwnerOf: z.ZodObject<{
         nftAddress: z.ZodCustom<`0x${string}`, `0x${string}`>;
         nftTokenId: z.ZodCustom<`0x${string}`, `0x${string}`>;
@@ -40,10 +43,74 @@ export declare const paymentRpcReturnSchemas: {
     badge_badgeOfIdentityByIndex: z.ZodCustom<`0x${string}`, `0x${string}`>;
     badge_badgesOfIdentity: z.ZodArray<z.ZodCustom<`0x${string}`, `0x${string}`>>;
 };
+export type BadgeRpcMethodNames = Extract<RpcMethodNames, `badge_${string}`>;
+export declare const badgeRpcParamSchemas: {
+    badge_getOwnerOf: z.ZodTuple<[z.ZodObject<{
+        chainHex: z.ZodCustom<`0x${string}`, `0x${string}`>;
+        badgeId: z.ZodCustom<`0x${string}`, `0x${string}`>;
+        badgeKind: z.ZodEnum<{
+            receipt: "receipt";
+            paymentRecord: "paymentRecord";
+            membership: "membership";
+        }>;
+    }, z.core.$strip>], null>;
+    badge_getBadgeUri: z.ZodTuple<[z.ZodObject<{
+        chainHex: z.ZodCustom<`0x${string}`, `0x${string}`>;
+        badgeId: z.ZodCustom<`0x${string}`, `0x${string}`>;
+        badgeKind: z.ZodEnum<{
+            receipt: "receipt";
+            paymentRecord: "paymentRecord";
+            membership: "membership";
+        }>;
+    }, z.core.$strip>], null>;
+    badge_getMetadataFormat: z.ZodTuple<[z.ZodObject<{
+        chainHex: z.ZodCustom<`0x${string}`, `0x${string}`>;
+        badgeKind: z.ZodEnum<{
+            receipt: "receipt";
+            paymentRecord: "paymentRecord";
+            membership: "membership";
+        }>;
+    }, z.core.$strip>], null>;
+    badge_totalBadgesOfIdentity: z.ZodTuple<[z.ZodObject<{
+        chainHex: z.ZodCustom<`0x${string}`, `0x${string}`>;
+        account: z.ZodCustom<`0x${string}`, `0x${string}`>;
+        badgeKind: z.ZodEnum<{
+            receipt: "receipt";
+            paymentRecord: "paymentRecord";
+            membership: "membership";
+        }>;
+    }, z.core.$strip>], null>;
+    badge_badgeOfIdentityByIndex: z.ZodTuple<[z.ZodObject<{
+        chainHex: z.ZodCustom<`0x${string}`, `0x${string}`>;
+        account: z.ZodCustom<`0x${string}`, `0x${string}`>;
+        badgeKind: z.ZodEnum<{
+            receipt: "receipt";
+            paymentRecord: "paymentRecord";
+            membership: "membership";
+        }>;
+        index: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    }, z.core.$strip>], null>;
+    badge_badgesOfIdentity: z.ZodTuple<[z.ZodObject<{
+        chainHex: z.ZodCustom<`0x${string}`, `0x${string}`>;
+        account: z.ZodCustom<`0x${string}`, `0x${string}`>;
+        badgeKind: z.ZodEnum<{
+            receipt: "receipt";
+            paymentRecord: "paymentRecord";
+            membership: "membership";
+        }>;
+        offset: z.ZodCustom<`0x${string}`, `0x${string}`>;
+        limit: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    }, z.core.$strip>], null>;
+};
+export declare class PaymentRpcParamsValidationError extends Error {
+    readonly method: BadgeRpcMethodNames;
+    readonly zodError: z.ZodError;
+    constructor(method: BadgeRpcMethodNames, zodError: z.ZodError);
+}
 export declare class PaymentRpcResponseValidationError extends Error {
-    readonly method: PaymentRpcMethodNames;
+    readonly method: RpcMethodNames;
     readonly zodError: z.ZodError;
-    constructor(method: PaymentRpcMethodNames, zodError: z.ZodError);
+    constructor(method: RpcMethodNames, zodError: z.ZodError);
 }
 /**
  * Parses the result from the RPC call to the corresponding Zod schema.
@@ -52,4 +119,12 @@ export declare class PaymentRpcResponseValidationError extends Error {
  * @param result - The result from the RPC call
  * @returns The parsed result according to the Zod schema
  */
-export declare function parsePaymentRpcReturn<T extends PaymentRpcMethodNames>(method: T, result: unknown): PaymentRpcReturn<T>;
+export declare function parsePaymentRpcReturn<T extends RpcMethodNames>(method: T, result: unknown): PaymentRpcReturn<T>;
+/**
+ * Parses badge RPC params against the corresponding Zod schema.
+ *
+ * @param method - The badge RPC method name
+ * @param params - The params from the RPC call
+ * @returns The parsed params according to the Zod schema
+ */
+export declare function parsePaymentRpcParams<T extends BadgeRpcMethodNames>(method: T, params: unknown): RpcParams<T>;

package/dist/client/types.d.ts

@@ -1,22 +1,22 @@
 import { Address, Hex } from 'viem';
-import { CashieRouterActions, PaymentIntent, RewardIntentDetails } from '../intent/types.js';
+import { Intent, IntentActions, PaymentIntentActions, RewardData } from '../intent/types.js';
 import { BurnAuth, IdentityMintSignPayloadWithSignature, IdentitySoulDiscovery } from '../identity/index.js';
 import type { InitCodeData } from '../erc-7715/request/types.js';
-import type { PaymentIntentTrackingEntry } from '../backend/tx-tracking/types.js';
+import type { IntentTrackingEntry } from '../backend/tx-tracking/types.js';
+import type { BadgeKind } from '../backend/contracts/badge.types.js';
 type PrepareRouterCallsParams = {
     recipient: Address;
     allowance: Hex;
     tokenAddress: Address;
     chainId: Hex;
-    action: CashieRouterActions;
-    rewardIntentDetails?: RewardIntentDetails;
+    action: PaymentIntentActions;
+    rewardData?: RewardData;
     salt: Hex;
 };
 type BadgeOwner = {
     nftAddress: Address;
     nftTokenId: Hex;
 };
-type BadgeKind = 'receipt' | 'paymentRecord';
 type PrePaymentSetup = {
     signedIdentityMintPayload: IdentityMintSignPayloadWithSignature;
     initCodeData: InitCodeData;
@@ -24,13 +24,7 @@ type PrePaymentSetup = {
 /**
  * The mapping of payment RPC methods to their corresponding parameters and return types.
  */
-interface PaymentRpcMethodMapping {
-    discovery_supportedSouls: {
-        params: [{
-            chainHex: Hex;
-        }];
-        return: IdentitySoulDiscovery;
-    };
+interface RpcMethodMapping {
     payment_getProtocolFeeBps: {
         params: [{
             chainHex: Hex;
@@ -47,16 +41,6 @@ interface PaymentRpcMethodMapping {
         ];
         return: Hex;
     };
-    payment_sendIntent: {
-        params: [PaymentIntent];
-        return: Hex;
-    };
-    payment_getIntentStatuses: {
-        params: [{
-            address: Address;
-        }];
-        return: PaymentIntentTrackingEntry[];
-    };
     payment_prepareRouterCallsFromAction: {
         params: [PrepareRouterCallsParams];
         return: {
@@ -64,20 +48,6 @@ interface PaymentRpcMethodMapping {
             data: Hex;
         }[];
     };
-    identity_getBurnAuth: {
-        params: [{
-            chainHex: Hex;
-            tokenId: Hex;
-        }];
-        return: BurnAuth;
-    };
-    identity_getTokenURI: {
-        params: [{
-            chainHex: Hex;
-            tokenId: Hex;
-        }];
-        return: string | null;
-    };
     /**
      * Submit data required before a payment can run: smart-account init code and
      * a signed identity mint consent payload.
@@ -102,10 +72,48 @@ interface PaymentRpcMethodMapping {
         }];
         return: PrePaymentSetup | null;
     };
+    cashie_sendIntent: {
+        params: [Intent<IntentActions>];
+        return: Hex;
+    };
+    /**
+     * Get intent status given an intent hash.
+     */
+    cashie_getIntentStatus: {
+        params: [Hex];
+        return: IntentTrackingEntry<IntentActions> | null;
+    };
+    cashie_getIntentStatuses: {
+        params: [{
+            address: Address;
+        }];
+        return: IntentTrackingEntry<IntentActions>[];
+    };
+    discovery_supportedSouls: {
+        params: [{
+            chainHex: Hex;
+        }];
+        return: IdentitySoulDiscovery;
+    };
+    identity_getBurnAuth: {
+        params: [{
+            chainHex: Hex;
+            tokenId: Hex;
+        }];
+        return: BurnAuth;
+    };
+    identity_getTokenURI: {
+        params: [{
+            chainHex: Hex;
+            tokenId: Hex;
+        }];
+        return: string | null;
+    };
     badge_getOwnerOf: {
         params: [{
             chainHex: Hex;
             badgeId: Hex;
+            badgeKind: BadgeKind;
         }];
         return: BadgeOwner;
     };
@@ -113,12 +121,14 @@ interface PaymentRpcMethodMapping {
         params: [{
             chainHex: Hex;
             badgeId: Hex;
+            badgeKind: BadgeKind;
         }];
         return: string | null;
     };
     badge_getMetadataFormat: {
         params: [{
             chainHex: Hex;
+            badgeKind: BadgeKind;
         }];
         return: string;
     };
@@ -157,7 +167,7 @@ interface PaymentRpcMethodMapping {
 /**
  * The method names for the payment API.
  */
-export type PaymentRpcMethodNames = keyof PaymentRpcMethodMapping;
-export type PaymentRpcParams<T extends PaymentRpcMethodNames> = PaymentRpcMethodMapping[T]['params'];
-export type PaymentRpcReturn<T extends PaymentRpcMethodNames> = PaymentRpcMethodMapping[T]['return'];
+export type RpcMethodNames = keyof RpcMethodMapping;
+export type RpcParams<T extends RpcMethodNames> = RpcMethodMapping[T]['params'];
+export type PaymentRpcReturn<T extends RpcMethodNames> = RpcMethodMapping[T]['return'];
 export {};

package/dist/data/cashieDataUrl.d.ts

@@ -5,10 +5,12 @@
  * Validation uses Zod schemas in `./types.js`. Parsed identity fields align with
  * **`IdentityType`** / **`BurnAuth`** from `identity/types.ts`.
  *
- * Pair **`parseCashieReceiptBadgeMetadataFromBadgeUri`** / **`parseCashiePaymentRecordBadgeMetadataFromBadgeUri`**
+ * Pair **`parseCashieReceiptBadgeMetadataFromBadgeUri`**,
+ * **`parseCashiePaymentRecordBadgeMetadataFromBadgeUri`**, and
+ * **`parseCashieMembershipBadgeMetadataFromBadgeUri`**
  * with **`IERC5114.metadataFormat()`** once the badge is minted on-chain.
  */
-import { type CashieIdentitySoulTokenMetadata, type CashiePaymentRecordBadgeMetadata, type CashieReceiptBadgeMetadata, type ParsedCashieMetadata } from './types.js';
+import { type CashieIdentitySoulTokenMetadata, type CashieMembershipBadgeMetadata, type CashiePaymentRecordBadgeMetadata, type CashieReceiptBadgeMetadata, type ParsedCashieMetadata } from './types.js';
 /**
  * Strips {@link CASHIE_JSON_DATA_URI_BASE64_PREFIX} and returns the UTF-8 JSON string inside.
  *
@@ -69,9 +71,26 @@ export declare function parseCashiePaymentRecordBadgeMetadata(dataUri: string):
  * @returns The parsed payment record badge metadata
  */
 export declare function parseCashiePaymentRecordBadgeMetadataFromBadgeUri(badgeUri: string, metadataFormatFromContract: string): CashiePaymentRecordBadgeMetadata;
+/**
+ * Parses `CashieMembershipBadge.badgeUri` metadata (`MembershipBadgeMetadataEncoderLib`).
+ *
+ * @param dataUri The data URI to parse
+ * @returns The parsed membership badge metadata
+ */
+export declare function parseCashieMembershipBadgeMetadata(dataUri: string): CashieMembershipBadgeMetadata;
+/**
+ * Same as {@link parseCashieMembershipBadgeMetadata}, but enforces that
+ * `IERC5114.metadataFormat()` matches {@link CASHIE_MEMBERSHIP_BADGE_METADATA_FORMAT}.
+ *
+ * @param badgeUri The badge URI to parse
+ * @param metadataFormatFromContract The metadata format from the contract
+ * @returns The parsed membership badge metadata
+ */
+export declare function parseCashieMembershipBadgeMetadataFromBadgeUri(badgeUri: string, metadataFormatFromContract: string): CashieMembershipBadgeMetadata;
 /**
  * Dispatches on JSON shape: **`identityType`** ⇒ identity soul; **`receiptType`** ⇒ receipt badge;
- * **`receiptBadgeId`** (without **`receiptType`**) ⇒ payment record badge.
+ * **`receiptBadgeId`** (without **`receiptType`**) ⇒ payment record badge;
+ * **`isMembershipActive`** ⇒ membership badge.
  *
  * @param dataUri The data URI to parse
  * @returns The parsed metadata

package/dist/data/encoder.d.ts

@@ -1,5 +1,5 @@
 import type { Address, Hex } from 'viem';
-import type { PaymentIntent } from '../intent/types.js';
+import type { Intent, PaymentIntentActions } from '../intent/types.js';
 /**
  * Mirrors on-chain `ReceiptType`
  */
@@ -57,7 +57,7 @@ export declare function receiptBadgeIdFromMintPayload(payload: ReceiptBadgeMintP
  * @param receiptType Receipt badge type from `ReceiptBadgeRouterMintPayload`
  * @returns Receipt badge mint tuple in router/storage shape
  */
-export declare function receiptBadgeMintPayloadFromPaymentIntent(identityContract: Address, paymentIntent: PaymentIntent, blockNumber: bigint, receiptType: ReceiptType): ReceiptBadgeMintPayload;
+export declare function receiptBadgeMintPayloadFromPaymentIntent(identityContract: Address, paymentIntent: Intent<PaymentIntentActions>, blockNumber: bigint, receiptType: ReceiptType): ReceiptBadgeMintPayload;
 /**
  * Deterministic receipt badge id for a payment intent (matches on-chain `CashieReceiptBadge.mint`).
  *
@@ -67,7 +67,7 @@ export declare function receiptBadgeMintPayloadFromPaymentIntent(identityContrac
  * @param receiptType Receipt badge type from `ReceiptBadgeRouterMintPayload`
  * @returns Deterministic receipt badge id
  */
-export declare function receiptBadgeIdFromPaymentIntent(identityContract: Address, paymentIntent: PaymentIntent, blockNumber: bigint, receiptType: ReceiptType): bigint;
+export declare function receiptBadgeIdFromPaymentIntent(identityContract: Address, paymentIntent: Intent<PaymentIntentActions>, blockNumber: bigint, receiptType: ReceiptType): bigint;
 /**
  * Fields ABI-encoded in the same order as `PaymentRecordBadgeEncoderLib.encodeMintPayload`
  * (`packages/contracts/src/identity/libraries/PaymentRecordBadgeEncoderLib.sol`).
@@ -117,7 +117,7 @@ export declare function paymentRecordBadgeIdFromMintPayload(payload: PaymentReco
  * @param receiptBadgeId Linked receipt badge id from the same payment
  * @returns Payment record badge mint tuple in router/storage shape
  */
-export declare function paymentRecordBadgeMintPayloadFromPaymentIntent(identityContract: Address, paymentIntent: PaymentIntent, blockNumber: bigint, receiptBadgeId: bigint): PaymentRecordBadgeMintPayload;
+export declare function paymentRecordBadgeMintPayloadFromPaymentIntent(identityContract: Address, paymentIntent: Intent<PaymentIntentActions>, blockNumber: bigint, receiptBadgeId: bigint): PaymentRecordBadgeMintPayload;
 /**
  * Deterministic payment record badge id for a payment intent (matches on-chain `CashiePaymentRecordBadge.mint`).
  *
@@ -127,4 +127,41 @@ export declare function paymentRecordBadgeMintPayloadFromPaymentIntent(identityC
  * @param receiptType Receipt badge type from `ReceiptBadgeRouterMintPayload`
  * @returns Deterministic payment record badge id
  */
-export declare function paymentRecordBadgeIdFromPaymentIntent(identityContract: Address, paymentIntent: PaymentIntent, blockNumber: bigint, receiptType: ReceiptType): bigint;
+export declare function paymentRecordBadgeIdFromPaymentIntent(identityContract: Address, paymentIntent: Intent<PaymentIntentActions>, blockNumber: bigint, receiptType: ReceiptType): bigint;
+/**
+ * Fields ABI-encoded in the same order as `MembershipBadgeEncoderLib.encodeMintPayload`
+ * (`packages/contracts/src/identity/libraries/MembershipBadgeEncoderLib.sol`).
+ * `isMembershipActive` is stored on-chain and omitted from this type because it does not affect the digest.
+ */
+export type MembershipBadgeMintPayload = {
+    soulBoundTo: {
+        identityContract: Address;
+        tokenId: bigint;
+    };
+    blockNumber: bigint;
+    chainId: bigint;
+    recipient: Address;
+    salt: Hex;
+};
+/**
+ * Canonical `abi.encode` of the stable membership mint fields (matches Solidity `MembershipBadgeEncoderLib.encodeMintPayload`).
+ *
+ * @param payload Mint tuple fields in router/storage shape
+ * @returns ABI-encoded bytes as hex
+ */
+export declare function encodeMembershipBadgeMintPayload(payload: MembershipBadgeMintPayload): Hex;
+/**
+ * `keccak256(encodeMembershipBadgeMintPayload(payload))` — matches `MembershipBadgeEncoderLib.getMintPayloadHash`.
+ * On-chain `badgeId == uint256(bytes32 digest)`.
+ *
+ * @param payload Mint tuple fields in router/storage shape
+ * @returns 32-byte digest (`0x…`)
+ */
+export declare function getMembershipBadgeMintPayloadHash(payload: MembershipBadgeMintPayload): Hex;
+/**
+ * Deterministic ERC-5114 badge id: `uint256(getMembershipBadgeMintPayloadHash(payload))`.
+ *
+ * @param payload Mint tuple fields in router/storage shape
+ * @returns Badge id as bigint
+ */
+export declare function membershipBadgeIdFromMintPayload(payload: MembershipBadgeMintPayload): bigint;

package/dist/data/types.d.ts

@@ -13,6 +13,11 @@ export declare const CASHIE_RECEIPT_BADGE_METADATA_FORMAT: "Cashie-ReceiptBadge-
  * ERC-5114 JSON does not embed this string; compare against the contract when resolving badges.
  */
 export declare const CASHIE_PAYMENT_RECORD_BADGE_METADATA_FORMAT: "Cashie-PaymentRecordBadge-v1";
+/**
+ * Matches `CashieMembershipBadge.metadataFormat()` (`_METADATA_FORMAT`).
+ * ERC-5114 JSON does not embed this string; compare against the contract when resolving badges.
+ */
+export declare const CASHIE_MEMBERSHIP_BADGE_METADATA_FORMAT: "Cashie-MembershipBadge-v1";
 /**
  * `identityType` strings emitted by `IdentitySoulMetadataEncoderLib` — parallel to {@link IdentityType} ordinals.
  */
@@ -70,6 +75,24 @@ export declare const cashiePaymentRecordBadgeMetadataSchema: z.ZodObject<{
     receiptBadgeId: z.ZodString;
     salt: z.ZodString;
 }, z.core.$strict>;
+/** EIP-721 JSON from `MembershipBadgeMetadataEncoderLib`. */
+export declare const cashieMembershipBadgeMetadataSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    image: z.ZodString;
+    soulBoundTo: z.ZodObject<{
+        identityContract: z.ZodString;
+        tokenId: z.ZodString;
+    }, z.core.$strict>;
+    blockNumber: z.ZodString;
+    chainId: z.ZodString;
+    recipient: z.ZodString;
+    isMembershipActive: z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>;
+    salt: z.ZodString;
+}, z.core.$strict>;
 /**
  * EIP-721 JSON from `IdentitySoulMetadataEncoderLib` (on-chain wire format).
  * Use `.parse()` on decoded token URI JSON.
@@ -101,6 +124,7 @@ export declare const cashieIdentitySoulTokenMetadataSchema: z.ZodObject<{
 export type CashieReceiptBadgeSoulBoundTo = z.infer<typeof cashieReceiptBadgeSoulBoundToSchema>;
 export type CashieReceiptBadgeMetadata = z.infer<typeof cashieReceiptBadgeMetadataSchema>;
 export type CashiePaymentRecordBadgeMetadata = z.infer<typeof cashiePaymentRecordBadgeMetadataSchema>;
+export type CashieMembershipBadgeMetadata = z.infer<typeof cashieMembershipBadgeMetadataSchema>;
 export type CashieIdentitySoulTokenMetadata = z.infer<typeof cashieIdentitySoulTokenMetadataSchema>;
 export type ParsedCashieMetadata = {
     kind: 'identitySoul';
@@ -113,4 +137,8 @@ export type ParsedCashieMetadata = {
     kind: 'paymentRecordBadge';
     format: typeof CASHIE_PAYMENT_RECORD_BADGE_METADATA_FORMAT;
     data: CashiePaymentRecordBadgeMetadata;
+} | {
+    kind: 'membershipBadge';
+    format: typeof CASHIE_MEMBERSHIP_BADGE_METADATA_FORMAT;
+    data: CashieMembershipBadgeMetadata;
 };

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

@@ -1,6 +1,6 @@
 import { type Address, type Hex } from 'viem';
 import { IdentityIssuer, IssueIdentityProofRequest } from '../issuer/index.js';
-import { CashieIdentitySoulTokenMetadata, CashieReceiptBadgeMetadata, CashiePaymentRecordBadgeMetadata } from '../../data/index.js';
+import { CashieIdentitySoulTokenMetadata, CashieReceiptBadgeMetadata, CashiePaymentRecordBadgeMetadata, CashieMembershipBadgeMetadata } from '../../data/index.js';
 import { IdentityMintConsentArgs } from '../../identity/cashieIdentitySoulTypedData.js';
 interface ISoulManagerConstructorArgs {
     identityIssuer: IdentityIssuer;
@@ -46,9 +46,16 @@ export interface ISoulManager {
      * @returns The payment record badge metadata
      */
     getCashiePaymentRecordBadgeMetadata(badgeId: Hex): Promise<CashiePaymentRecordBadgeMetadata | undefined>;
+    /**
+     * Get the membership badge metadata for an account.
+     *
+     * @param account - The account address
+     * @returns The membership badge metadata, or undefined when none is minted
+     */
+    getCashieMembershipBadgeMetadata(account: Address): Promise<CashieMembershipBadgeMetadata | undefined>;
 }
 /**
- * Soul manager class is responsible for managing the (ERC-5484) identity soul tokens and (ERC-5114) receipt and payment record badges
+ * Soul manager class is responsible for managing the (ERC-5484) identity soul tokens and (ERC-5114) receipt, payment record, and membership badges
  */
 export declare class SoulManager implements ISoulManager {
     #private;
@@ -59,5 +66,6 @@ export declare class SoulManager implements ISoulManager {
     getCashieIdentitySoulTokenMetadata(account: Address): Promise<CashieIdentitySoulTokenMetadata | undefined>;
     getCashieReceiptBadgeMetadata(badgeId: Hex): Promise<CashieReceiptBadgeMetadata | undefined>;
     getCashiePaymentRecordBadgeMetadata(badgeId: Hex): Promise<CashiePaymentRecordBadgeMetadata | undefined>;
+    getCashieMembershipBadgeMetadata(account: Address): Promise<CashieMembershipBadgeMetadata | undefined>;
 }
 export {};