@cashie/core-lib 1.0.0

package/dist/abi/index.d.ts

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

package/dist/backend/auth/index.d.ts

@@ -0,0 +1,4 @@
+export * from './siwe.types.js';
+export * from './jwt.types.js';
+export * from './ocap/ocap-types.js';
+export * from './ocap/ocap-build.js';

package/dist/backend/auth/jwt.types.d.ts

@@ -0,0 +1,3 @@
+import { Address } from 'viem';
+export type SubJwtPayloadEntry = `${'did:ethereum:'}${string}:${Address}`;
+export type SubJwtPayload = `${'did:ethereum:owner:'}${Address},${'did:ethereum:smart-account:'}${Address}`;

package/dist/backend/auth/ocap/ocap-build.d.ts

@@ -0,0 +1,35 @@
+import type { Capability } from './ocap-types.js';
+export type BuildOcapParams = {
+    resources: Capability['resources'];
+    allowedAudiences: string[];
+};
+export type BuildOcapResult = {
+    ocap: Capability;
+    ocapId: string;
+};
+/**
+ * Produce a deterministic JSON string for a capability (sorted keys, sorted arrays).
+ *
+ * @param capability - The capability to canonicalize
+ * @returns The canonicalized capability
+ */
+export declare function canonicalOcapPayload(capability: Capability): string;
+/**
+ * Compute ocapId as keccak256(canonical_ocap_payload) per spec.
+ * OCAPs MUST be deterministic and hashable.
+ *
+ * @param capability - The capability to build the ocap id for
+ * @returns The ocap id
+ */
+export declare function buildOcapId(capability: Capability): string;
+export declare class OcapValidationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Validate requested resources against allowed audiences and build the granted OCAP in a canonical form (sorted keys, sorted arrays).
+ * Rejects unsupported resource types or disallowed audiences.
+ *
+ * @param params - The parameters to validate and build the ocap
+ * @returns The validated and built ocap
+ */
+export declare function validateAndBuildOcap(params: BuildOcapParams): BuildOcapResult;

package/dist/backend/auth/ocap/ocap-types.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Types for Identity OCAP (Off-Chain Capabilities) per docs/user-identity-ocap.md
+ */
+import { SubJwtPayload } from '../jwt.types.js';
+export type ApiMethods = 'POST' | 'GET' | 'PUT' | 'PATCH' | 'DELETE';
+/**
+ * A resource that can be accessed via API
+ */
+export type ApiResource = {
+    type: 'api';
+    audience: string;
+    data: {
+        endpoint: string;
+        methods: ApiMethods[];
+    };
+};
+export type SupportedResource = ApiResource;
+export type Capability = {
+    /**
+     * The requested off-chain capabilities resources
+     */
+    resources: {
+        api: ApiResource[];
+    };
+};
+/** JWT claims for OCAP identity tokens (RFC 7519 + custom ocap claim) */
+export type OcapJwtPayload = {
+    /**
+     * The issuer of the JWT
+     */
+    iss: string;
+    /**
+     * The subject of the JWT that is the user's public ethereum address
+     */
+    sub: SubJwtPayload;
+    /**
+     * The audience of the JWT
+     */
+    aud: string[];
+    /**
+     * The expiration time of the JWT(unix timestamp)
+     */
+    exp: number;
+    /**
+     * The not before time of the JWT
+     */
+    nbf: number;
+    /**
+     * The issued at time of the JWT
+     */
+    iat: number;
+    /**
+     * The JWT ID of the JWT
+     */
+    jti: string;
+    /**
+     * The granted off-chain capabilities of the JWT
+     */
+    ocap: Capability;
+};
+/** Request body for POST v1/ocaps/auth */
+export type OcapAuthRequestBody = {
+    /**
+     * The SIWE message
+     */
+    message: string;
+    /**
+     * The signature of the SIWE message
+     */
+    signature: string;
+    /**
+     * The request off-chain capabilities resources
+     */
+    resources: Capability['resources'];
+};
+/** Response from GET v1/ocaps/auth/discovery */
+export type OcapDiscoveryResponse = {
+    allowedResources: ApiResource[];
+};
+/**
+ * Audiences for OCAP
+ */
+export declare enum OcapAudiences {
+    ACCOUNT_SERVICE = "account-service",
+    PAYMENT_SERVICE = "payment-service",
+    IDV_SERVICE = "idv-service"
+}

package/dist/backend/auth/siwe.types.d.ts

@@ -0,0 +1,18 @@
+import { Address } from 'viem';
+import { Capability } from './ocap/ocap-types.js';
+/**
+ * The default maximum age of a SIWE message in milliseconds of 5 minutes.
+ */
+export declare const DEFAULT_MAX_AGE_MS: number;
+/**
+ * The prefix of the statement of the SIWE message.
+ */
+export declare const OCAP_STATEMENT_PREFIX = "Request OCAP";
+/**
+ * Prepare the statement of the SIWE message.
+ *
+ * @param smartAccountAddress The smart account address
+ * @param resources The requested resources
+ * @returns The prepared statement
+ */
+export declare function prepareStatement(smartAccountAddress: Address, resources: Capability['resources']): string;

package/dist/backend/blockchain/index.d.ts

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

package/dist/backend/blockchain/types.d.ts

@@ -0,0 +1,11 @@
+import { Address, Hex } from 'viem';
+export type Account7702UpgradeDetailsArgs = {
+    address: Address;
+    chainId: Hex;
+};
+export type Account7702UpgradeDetails = {
+    chainId: Hex;
+    contractAddress: Address;
+    isAccountUpgraded: boolean;
+    is7702Supported: boolean;
+};

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

@@ -0,0 +1,25 @@
+import { Address, Hex } from 'viem';
+import { CashieReceiptBadgeMetadata, CashiePaymentRecordBadgeMetadata } from '../../data/types.js';
+export type BadgeOwner = {
+    nftAddress: Address;
+    nftTokenId: Hex;
+};
+export type BadgeKind = 'receipt' | 'paymentRecord';
+export type BadgeMetadata = CashieReceiptBadgeMetadata | CashiePaymentRecordBadgeMetadata;
+export type BadgeChainParams = {
+    chainHex: Hex;
+};
+export type GetBadgeOwnerOfParams = BadgeChainParams & {
+    badgeId: Hex;
+};
+export type GetBadgeMetadataFormatParams = BadgeChainParams;
+export type TotalBadgesOfIdentityParams = BadgeChainParams & {
+    account: Address;
+};
+export type BadgeOfIdentityByIndexParams = TotalBadgesOfIdentityParams & {
+    index: Hex;
+};
+export type BadgesOfIdentityParams = TotalBadgesOfIdentityParams & {
+    offset: Hex;
+    limit: Hex;
+};

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

@@ -0,0 +1,32 @@
+import { Address, Hex } from 'viem';
+export type StablecoinBalanceItem = {
+    balance: Hex;
+    decimals: number;
+    symbol: string;
+    contractAddress: Address;
+};
+/**
+ * The parameters for the get stablecoin balance method
+ *
+ * @param chainId - The chain id
+ * @param account - The account to get the balance of
+ */
+export type StablecoinBalanceResponses = Record<Hex, StablecoinBalanceItem[]>;
+export type StablecoinTokenDetailsByChainIdItem = {
+    decimals: number;
+    symbol: string;
+};
+/**
+ * The details of a stablecoin token by chain id
+ *
+ * @param decimals - The decimals of the token
+ * @param symbol - The symbol of the token
+ */
+export type StablecoinTokenDetailsByChainId = Record<Hex, Record<Address, StablecoinTokenDetailsByChainIdItem>>;
+export type Erc20TokenAccountDetails = {
+    chainId: Hex;
+    balance: Hex;
+    decimals: number;
+    symbol: string;
+    contractAddress: Address;
+};

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

@@ -0,0 +1,34 @@
+import { Hex, Address } from 'viem';
+export type CashieRouterV1PaymentEvent = {
+    type: 'incoming' | 'outgoing';
+    payer: Address;
+    receiver: Address;
+    feeBeneficiaryAddress: Address;
+    allowance: Hex;
+    recipientAmount: Hex;
+    protocolFee: Hex;
+    protocolFeeBps: Hex;
+    tokenAddress: Address;
+};
+export type CashieRouterV1DepositEvent = {
+    type: 'incoming';
+    sender: Address;
+    recipient: Address;
+    amount: Hex;
+    tokenAddress: Address;
+};
+export type CashieRouterV1WithdrawEvent = {
+    type: 'outgoing';
+    account: Address;
+    recipient: Address;
+    amount: Hex;
+    protocolFee: Hex;
+    protocolFeeBps: Hex;
+    tokenAddress: Address;
+};
+export type CashieRouterV1RewardEvent = {
+    type: 'incoming';
+    recipient: Address;
+    rewardAmount: Hex;
+    rewardToken: Address;
+};

package/dist/backend/contracts/index.d.ts

@@ -0,0 +1,4 @@
+export * from './balance.types.js';
+export * from './badge.types.js';
+export * from './event.types.js';
+export * from './receipt.types.js';

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

@@ -0,0 +1,55 @@
+import { Hash, Hex } from 'viem';
+import { CashieRouterV1PaymentEvent, CashieRouterV1DepositEvent, CashieRouterV1WithdrawEvent, CashieRouterV1RewardEvent } from './event.types.js';
+/**
+ * @deprecated This type is deprecated and will be removed in the future. Use badge pagination methods instead to generate the account statement.
+ */
+export type CashieReceiptBase = {
+    transactionHash: Hash;
+    blockNumber: Hex;
+    chainId: Hex;
+};
+/**
+ * @deprecated This type is deprecated and will be removed in the future. Use badge pagination methods instead to generate the account statement.
+ */
+export type CashieTransactionReceipt = CashieReceiptBase & {
+    args: CashieRouterV1PaymentEvent;
+    stablecoinTokenDetail: {
+        decimals: number;
+        symbol: string;
+    };
+};
+/**
+ * @deprecated This type is deprecated and will be removed in the future. Use badge pagination methods instead to generate the account statement.
+ */
+export type CashieRouterV1DepositReceipt = CashieReceiptBase & {
+    args: CashieRouterV1DepositEvent;
+    stablecoinTokenDetail: {
+        decimals: number;
+        symbol: string;
+    };
+};
+/**
+ * @deprecated This type is deprecated and will be removed in the future. Use badge pagination methods instead to generate the account statement.
+ */
+export type CashieRouterV1WithdrawReceipt = CashieReceiptBase & {
+    args: CashieRouterV1WithdrawEvent;
+    stablecoinTokenDetail: {
+        decimals: number;
+        symbol: string;
+    };
+};
+/**
+ * @deprecated This type is deprecated and will be removed in the future. Use badge pagination methods instead to generate the account statement.
+ */
+export type CashieRouterV1RewardReceipt = CashieReceiptBase & {
+    args: CashieRouterV1RewardEvent;
+};
+/**
+ * @deprecated This type is deprecated and will be removed in the future. Use badge pagination methods instead to generate the account statement.
+ */
+export type CashieAccountStatement = {
+    paymentReceipts: CashieTransactionReceipt[];
+    depositReceipts: CashieRouterV1DepositReceipt[];
+    withdrawReceipts: CashieRouterV1WithdrawReceipt[];
+    rewardReceipts: CashieRouterV1RewardReceipt[];
+};

package/dist/backend/index.d.ts

@@ -0,0 +1,4 @@
+export * from './contracts/index.js';
+export * from './tx-tracking/index.js';
+export * from './auth/index.js';
+export * from './blockchain/index.js';

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

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

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

@@ -0,0 +1,41 @@
+import { Hex, Hash, Address } from 'viem';
+import { BadgeKind, PaymentIntent } from '../../index.js';
+export type SendPaymentIntentTaskEntry = {
+    id: string;
+    data: {
+        paymentIntent: PaymentIntent;
+    };
+};
+/**
+ * A task transaction entry.
+ */
+export type TransactionEntry = {
+    txHash: Hash;
+    chainId: Hex;
+    taskEntries: SendPaymentIntentTaskEntry[];
+};
+/**
+ * A payment intent tracking entry.
+ */
+export type PaymentIntentTrackingEntry = {
+    paymentIntent: PaymentIntent;
+    status: 'pending' | 'confirmed' | 'failed';
+    txHash?: Hash | null;
+    blockNumber?: Hex | null;
+};
+/**
+ * Find the transaction hash for a badge id.
+ *
+ * @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.
+ * @returns The transaction hash for the badge id.
+ */
+export declare function findTransactionHashForBadgeId(props: {
+    badgeId: Hex;
+    badgeKind: BadgeKind;
+    identityContract: Address;
+    paymentIntentTrackingEntries: PaymentIntentTrackingEntry[];
+}): Hex | null;

package/dist/client/index.d.ts

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

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

@@ -0,0 +1,30 @@
+import { PaymentRpcParams, 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'>>;
+}
+/**
+ * Creates a new Payment RPC client.
+ *
+ * @param args - The arguments for the Payment RPC client
+ * @returns The Payment RPC client
+ */
+export declare const createPaymentRpcClient: (args: PaymentRpcClientArgs) => PaymentRpcClient;

package/dist/client/schemas.d.ts

@@ -0,0 +1,55 @@
+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';
+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>>;
+        initCodeData: z.ZodObject<{
+            factory: z.ZodCustom<`0x${string}`, `0x${string}`>;
+            factoryData: z.ZodCustom<`0x${string}`, `0x${string}`>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    badge_getOwnerOf: z.ZodObject<{
+        nftAddress: z.ZodCustom<`0x${string}`, `0x${string}`>;
+        nftTokenId: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    }, z.core.$strip>;
+    badge_getBadgeUri: z.ZodNullable<z.ZodString>;
+    badge_getMetadataFormat: z.ZodString;
+    badge_totalBadgesOfIdentity: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    badge_badgeOfIdentityByIndex: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    badge_badgesOfIdentity: z.ZodArray<z.ZodCustom<`0x${string}`, `0x${string}`>>;
+};
+export declare class PaymentRpcResponseValidationError extends Error {
+    readonly method: PaymentRpcMethodNames;
+    readonly zodError: z.ZodError;
+    constructor(method: PaymentRpcMethodNames, zodError: z.ZodError);
+}
+/**
+ * Parses the result from the RPC call to the corresponding Zod schema.
+ *
+ * @param method - The method name
+ * @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>;

package/dist/client/types.d.ts

@@ -0,0 +1,163 @@
+import { Address, Hex } from 'viem';
+import { CashieRouterActions, PaymentIntent, RewardIntentDetails } 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';
+type PrepareRouterCallsParams = {
+    recipient: Address;
+    allowance: Hex;
+    tokenAddress: Address;
+    chainId: Hex;
+    action: CashieRouterActions;
+    rewardIntentDetails?: RewardIntentDetails;
+    salt: Hex;
+};
+type BadgeOwner = {
+    nftAddress: Address;
+    nftTokenId: Hex;
+};
+type BadgeKind = 'receipt' | 'paymentRecord';
+type PrePaymentSetup = {
+    signedIdentityMintPayload: IdentityMintSignPayloadWithSignature;
+    initCodeData: InitCodeData;
+};
+/**
+ * The mapping of payment RPC methods to their corresponding parameters and return types.
+ */
+interface PaymentRpcMethodMapping {
+    discovery_supportedSouls: {
+        params: [{
+            chainHex: Hex;
+        }];
+        return: IdentitySoulDiscovery;
+    };
+    payment_getProtocolFeeBps: {
+        params: [{
+            chainHex: Hex;
+        }];
+        return: Hex;
+    };
+    payment_calculateRewardAmount: {
+        params: [
+            {
+                chainHex: Hex;
+                paymentTokenAmount: Hex;
+                paymentTokenDecimals: number;
+            }
+        ];
+        return: Hex;
+    };
+    payment_sendIntent: {
+        params: [PaymentIntent];
+        return: Hex;
+    };
+    payment_getIntentStatuses: {
+        params: [{
+            address: Address;
+        }];
+        return: PaymentIntentTrackingEntry[];
+    };
+    payment_prepareRouterCallsFromAction: {
+        params: [PrepareRouterCallsParams];
+        return: {
+            to: Address;
+            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.
+     */
+    payment_sendPrePaymentSetup: {
+        params: [
+            {
+                chainHex: Hex;
+                signedIdentityMintPayload: IdentityMintSignPayloadWithSignature;
+                initCodeData: InitCodeData;
+            }
+        ];
+        return: Hex;
+    };
+    /**
+     * Fetch stored pre-payment setup for an account, or null if none exists.
+     */
+    payment_getPrePaymentSetup: {
+        params: [{
+            chainHex: Hex;
+            address: Address;
+        }];
+        return: PrePaymentSetup | null;
+    };
+    badge_getOwnerOf: {
+        params: [{
+            chainHex: Hex;
+            badgeId: Hex;
+        }];
+        return: BadgeOwner;
+    };
+    badge_getBadgeUri: {
+        params: [{
+            chainHex: Hex;
+            badgeId: Hex;
+        }];
+        return: string | null;
+    };
+    badge_getMetadataFormat: {
+        params: [{
+            chainHex: Hex;
+        }];
+        return: string;
+    };
+    badge_totalBadgesOfIdentity: {
+        params: [{
+            chainHex: Hex;
+            account: Address;
+            badgeKind: BadgeKind;
+        }];
+        return: Hex;
+    };
+    badge_badgeOfIdentityByIndex: {
+        params: [
+            {
+                chainHex: Hex;
+                account: Address;
+                badgeKind: BadgeKind;
+                index: Hex;
+            }
+        ];
+        return: Hex;
+    };
+    badge_badgesOfIdentity: {
+        params: [
+            {
+                chainHex: Hex;
+                account: Address;
+                badgeKind: BadgeKind;
+                offset: Hex;
+                limit: Hex;
+            }
+        ];
+        return: Hex[];
+    };
+}
+/**
+ * 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 {};