@4mica/sdk 0.5.5 → 1.0.0

package/dist/models.d.ts

@@ -1,12 +1,24 @@
 export { ADMIN_API_KEY_HEADER, ADMIN_API_KEY_PREFIX, ADMIN_SCOPE_MANAGE_KEYS, ADMIN_SCOPE_SUSPEND_USERS, } from './constants';
+/** Signing scheme used when producing a payment guarantee signature. */
 export declare enum SigningScheme {
+    /** EIP-712 typed-data signing (default, preferred). */
     EIP712 = "eip712",
+    /** EIP-191 personal_sign (for wallets that do not support typed data). */
     EIP191 = "eip191"
 }
+/** ECDSA signature and the scheme used to produce it. */
 export interface PaymentSignature {
+    /** 65-byte ECDSA signature as a `0x`-prefixed hex string. */
     signature: string;
     scheme: SigningScheme;
 }
+/**
+ * V1 payment guarantee request claims. Signed by the payer and submitted to the
+ * core RPC to obtain a BLS guarantee certificate.
+ *
+ * Build with the static {@link PaymentGuaranteeRequestClaims.new} factory which
+ * normalises addresses and parses `uint256` values.
+ */
 export declare class PaymentGuaranteeRequestClaims {
     userAddress: string;
     recipientAddress: string;
@@ -26,6 +38,57 @@ export declare class PaymentGuaranteeRequestClaims {
     });
     static new(userAddress: string, recipientAddress: string, tabId: number | bigint | string, amount: number | bigint | string, timestamp: number, erc20Token?: string | null, reqId?: number | bigint | string): PaymentGuaranteeRequestClaims;
 }
+/** On-chain validation policy fields carried in a V2 payment guarantee certificate. */
+export interface PaymentGuaranteeValidationPolicyV2 {
+    validationRegistryAddress: string;
+    validationRequestHash: string;
+    validationChainId: number;
+    validatorAddress: string;
+    validatorAgentId: bigint;
+    minValidationScore: number;
+    validationSubjectHash: string;
+    requiredValidationTag: string;
+}
+/**
+ * V2 payment guarantee request claims — extends V1 with a full on-chain validation policy.
+ *
+ * Compute `validationSubjectHash` via `computeValidationSubjectHash(baseClaims)` and
+ * `validationRequestHash` via `computeValidationRequestHash(partialV2)` before constructing.
+ *
+ * @throws {@link ValidationError} if `minValidationScore` is outside [1, 100].
+ */
+export declare class PaymentGuaranteeRequestClaimsV2 extends PaymentGuaranteeRequestClaims {
+    validationRegistryAddress: string;
+    validationRequestHash: string;
+    validationChainId: number;
+    validatorAddress: string;
+    validatorAgentId: bigint;
+    minValidationScore: number;
+    validationSubjectHash: string;
+    requiredValidationTag: string;
+    constructor(init: {
+        userAddress: string;
+        recipientAddress: string;
+        tabId: bigint;
+        reqId?: bigint;
+        amount: bigint;
+        timestamp: number;
+        assetAddress: string;
+        validationRegistryAddress: string;
+        validationRequestHash: string;
+        validationChainId: number;
+        validatorAddress: string;
+        validatorAgentId: bigint;
+        minValidationScore: number;
+        validationSubjectHash: string;
+        requiredValidationTag: string;
+    });
+}
+/**
+ * Decoded payment guarantee claims, as returned by `decodeGuaranteeClaims`.
+ * `version` is `1` for V1 certificates and `2` for V2 certificates.
+ * V2 certificates additionally carry a `validationPolicy`.
+ */
 export interface PaymentGuaranteeClaims {
     domain: Uint8Array;
     userAddress: string;
@@ -37,20 +100,36 @@ export interface PaymentGuaranteeClaims {
     assetAddress: string;
     timestamp: number;
     version: number;
+    validationPolicy?: PaymentGuaranteeValidationPolicyV2;
 }
+/**
+ * BLS guarantee certificate returned by `issuePaymentGuarantee`.
+ * Both fields are `0x`-prefixed hex strings.
+ */
 export interface BLSCert {
+    /** ABI-encoded `(uint64 version, bytes innerClaims)` envelope as a hex string. */
     claims: string;
+    /** BLS12-381 G2 signature as a hex string. */
     signature: string;
 }
+/** On-chain payment status of a tab, returned by `getTabPaymentStatus`. */
 export interface TabPaymentStatus {
+    /** Cumulative amount paid so far (in token base units). */
     paid: bigint;
+    /** Whether the recipient has already called `remunerate` on-chain. */
     remunerated: boolean;
+    /** Asset address (`0x000...` for ETH). */
     asset: string;
 }
+/** On-chain collateral position for a single asset, returned by `getUser`. */
 export interface UserInfo {
+    /** Asset address (`0x000...` for ETH). */
     asset: string;
+    /** Total deposited collateral available for payments (in token base units). */
     collateral: bigint;
+    /** Amount of a pending withdrawal request (0 if none). */
     withdrawalRequestAmount: bigint;
+    /** Unix timestamp when the withdrawal request was made (0 if none). */
     withdrawalRequestTimestamp: number;
 }
 export declare class UserSuspensionStatus {
@@ -145,3 +224,32 @@ export declare class RecipientPaymentInfo {
     constructor(userAddress: string, recipientAddress: string, txHash: string, amount: bigint, verified: boolean, finalized: boolean, failed: boolean, createdAt: number);
     static fromRpc(raw: Record<string, unknown>): RecipientPaymentInfo;
 }
+export interface SupportedTokenInfo {
+    symbol: string;
+    address: string;
+    decimals?: number;
+}
+export declare class SupportedTokensResponse {
+    chainId: number;
+    tokens: SupportedTokenInfo[];
+    constructor(chainId: number, tokens: SupportedTokenInfo[]);
+    static fromRpc(raw: Record<string, unknown>): SupportedTokensResponse;
+}
+export declare class CorePublicParameters {
+    publicKey: Uint8Array;
+    contractAddress: string;
+    ethereumHttpRpcUrl: string;
+    eip712Name: string;
+    eip712Version: string;
+    chainId: number;
+    maxAcceptedGuaranteeVersion: number;
+    acceptedGuaranteeVersions: number[];
+    activeGuaranteeDomainSeparator: string;
+    /** Allowlist of trusted validation registry addresses configured in core (may be empty). */
+    trustedValidationRegistries: string[];
+    validationHashCanonicalizationVersion: string;
+    constructor(publicKey: Uint8Array, contractAddress: string, ethereumHttpRpcUrl: string, eip712Name: string, eip712Version: string, chainId: number, maxAcceptedGuaranteeVersion?: number, acceptedGuaranteeVersions?: number[], activeGuaranteeDomainSeparator?: string, 
+    /** Allowlist of trusted validation registry addresses configured in core (may be empty). */
+    trustedValidationRegistries?: string[], validationHashCanonicalizationVersion?: string);
+    static fromRpc(payload: Record<string, unknown>): CorePublicParameters;
+}

package/dist/models.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RecipientPaymentInfo = exports.AssetBalanceInfo = exports.CollateralEventInfo = exports.PendingRemunerationInfo = exports.GuaranteeInfo = exports.TabInfo = exports.AdminApiKeySecret = exports.AdminApiKeyInfo = exports.UserSuspensionStatus = exports.PaymentGuaranteeRequestClaims = exports.SigningScheme = exports.ADMIN_SCOPE_SUSPEND_USERS = exports.ADMIN_SCOPE_MANAGE_KEYS = exports.ADMIN_API_KEY_PREFIX = exports.ADMIN_API_KEY_HEADER = void 0;
+exports.CorePublicParameters = exports.SupportedTokensResponse = exports.RecipientPaymentInfo = exports.AssetBalanceInfo = exports.CollateralEventInfo = exports.PendingRemunerationInfo = exports.GuaranteeInfo = exports.TabInfo = exports.AdminApiKeySecret = exports.AdminApiKeyInfo = exports.UserSuspensionStatus = exports.PaymentGuaranteeRequestClaimsV2 = exports.PaymentGuaranteeRequestClaims = exports.SigningScheme = exports.ADMIN_SCOPE_SUSPEND_USERS = exports.ADMIN_SCOPE_MANAGE_KEYS = exports.ADMIN_API_KEY_PREFIX = exports.ADMIN_API_KEY_HEADER = void 0;
+const viem_1 = require("viem");
 const serde_1 = require("./serde");
 const utils_1 = require("./utils");
 var constants_1 = require("./constants");
@@ -8,11 +9,21 @@ Object.defineProperty(exports, "ADMIN_API_KEY_HEADER", { enumerable: true, get:
 Object.defineProperty(exports, "ADMIN_API_KEY_PREFIX", { enumerable: true, get: function () { return constants_1.ADMIN_API_KEY_PREFIX; } });
 Object.defineProperty(exports, "ADMIN_SCOPE_MANAGE_KEYS", { enumerable: true, get: function () { return constants_1.ADMIN_SCOPE_MANAGE_KEYS; } });
 Object.defineProperty(exports, "ADMIN_SCOPE_SUSPEND_USERS", { enumerable: true, get: function () { return constants_1.ADMIN_SCOPE_SUSPEND_USERS; } });
+/** Signing scheme used when producing a payment guarantee signature. */
 var SigningScheme;
 (function (SigningScheme) {
+    /** EIP-712 typed-data signing (default, preferred). */
     SigningScheme["EIP712"] = "eip712";
+    /** EIP-191 personal_sign (for wallets that do not support typed data). */
     SigningScheme["EIP191"] = "eip191";
 })(SigningScheme || (exports.SigningScheme = SigningScheme = {}));
+/**
+ * V1 payment guarantee request claims. Signed by the payer and submitted to the
+ * core RPC to obtain a BLS guarantee certificate.
+ *
+ * Build with the static {@link PaymentGuaranteeRequestClaims.new} factory which
+ * normalises addresses and parses `uint256` values.
+ */
 class PaymentGuaranteeRequestClaims {
     userAddress;
     recipientAddress;
@@ -44,6 +55,39 @@ class PaymentGuaranteeRequestClaims {
     }
 }
 exports.PaymentGuaranteeRequestClaims = PaymentGuaranteeRequestClaims;
+/**
+ * V2 payment guarantee request claims — extends V1 with a full on-chain validation policy.
+ *
+ * Compute `validationSubjectHash` via `computeValidationSubjectHash(baseClaims)` and
+ * `validationRequestHash` via `computeValidationRequestHash(partialV2)` before constructing.
+ *
+ * @throws {@link ValidationError} if `minValidationScore` is outside [1, 100].
+ */
+class PaymentGuaranteeRequestClaimsV2 extends PaymentGuaranteeRequestClaims {
+    validationRegistryAddress;
+    validationRequestHash;
+    validationChainId;
+    validatorAddress;
+    validatorAgentId;
+    minValidationScore;
+    validationSubjectHash;
+    requiredValidationTag;
+    constructor(init) {
+        super(init);
+        if (init.minValidationScore < 1 || init.minValidationScore > 100) {
+            throw new utils_1.ValidationError(`minValidationScore must be in [1, 100], got ${init.minValidationScore}`);
+        }
+        this.validationRegistryAddress = (0, utils_1.normalizeAddress)(init.validationRegistryAddress);
+        this.validationRequestHash = (0, utils_1.ensureHexPrefix)(init.validationRequestHash).toLowerCase();
+        this.validationChainId = init.validationChainId;
+        this.validatorAddress = (0, utils_1.normalizeAddress)(init.validatorAddress);
+        this.validatorAgentId = init.validatorAgentId;
+        this.minValidationScore = init.minValidationScore;
+        this.validationSubjectHash = (0, utils_1.ensureHexPrefix)(init.validationSubjectHash).toLowerCase();
+        this.requiredValidationTag = init.requiredValidationTag;
+    }
+}
+exports.PaymentGuaranteeRequestClaimsV2 = PaymentGuaranteeRequestClaimsV2;
 class UserSuspensionStatus {
     userAddress;
     suspended;
@@ -232,3 +276,78 @@ class RecipientPaymentInfo {
     }
 }
 exports.RecipientPaymentInfo = RecipientPaymentInfo;
+class SupportedTokensResponse {
+    chainId;
+    tokens;
+    constructor(chainId, tokens) {
+        this.chainId = chainId;
+        this.tokens = tokens;
+    }
+    static fromRpc(raw) {
+        const tokensRaw = (0, serde_1.getAny)(raw, 'tokens');
+        const tokens = [];
+        if (Array.isArray(tokensRaw)) {
+            for (const token of tokensRaw) {
+                const address = (0, serde_1.getAny)(token, 'address');
+                if (typeof address !== 'string' || address.length === 0)
+                    continue;
+                const decimals = (0, serde_1.getAny)(token, 'decimals');
+                tokens.push({
+                    symbol: String((0, serde_1.getAny)(token, 'symbol') ?? ''),
+                    address,
+                    decimals: decimals === undefined || decimals === null ? undefined : Number(decimals),
+                });
+            }
+        }
+        return new SupportedTokensResponse(Number((0, serde_1.getAny)(raw, 'chain_id', 'chainId') ?? 0), tokens);
+    }
+}
+exports.SupportedTokensResponse = SupportedTokensResponse;
+class CorePublicParameters {
+    publicKey;
+    contractAddress;
+    ethereumHttpRpcUrl;
+    eip712Name;
+    eip712Version;
+    chainId;
+    maxAcceptedGuaranteeVersion;
+    acceptedGuaranteeVersions;
+    activeGuaranteeDomainSeparator;
+    trustedValidationRegistries;
+    validationHashCanonicalizationVersion;
+    constructor(publicKey, contractAddress, ethereumHttpRpcUrl, eip712Name, eip712Version, chainId, maxAcceptedGuaranteeVersion = 1, acceptedGuaranteeVersions = [], activeGuaranteeDomainSeparator = '', 
+    /** Allowlist of trusted validation registry addresses configured in core (may be empty). */
+    trustedValidationRegistries = [], validationHashCanonicalizationVersion = '4MICA_VALIDATION_REQUEST_V1') {
+        this.publicKey = publicKey;
+        this.contractAddress = contractAddress;
+        this.ethereumHttpRpcUrl = ethereumHttpRpcUrl;
+        this.eip712Name = eip712Name;
+        this.eip712Version = eip712Version;
+        this.chainId = chainId;
+        this.maxAcceptedGuaranteeVersion = maxAcceptedGuaranteeVersion;
+        this.acceptedGuaranteeVersions = acceptedGuaranteeVersions;
+        this.activeGuaranteeDomainSeparator = activeGuaranteeDomainSeparator;
+        this.trustedValidationRegistries = trustedValidationRegistries;
+        this.validationHashCanonicalizationVersion = validationHashCanonicalizationVersion;
+    }
+    static fromRpc(payload) {
+        const pkRaw = payload.public_key ?? payload.publicKey;
+        const pk = typeof pkRaw === 'string'
+            ? (0, viem_1.toBytes)(pkRaw)
+            : pkRaw instanceof Uint8Array
+                ? pkRaw
+                : Array.isArray(pkRaw)
+                    ? Uint8Array.from(pkRaw)
+                    : new Uint8Array();
+        const registriesRaw = payload.trusted_validation_registries ?? payload.trustedValidationRegistries;
+        const trustedValidationRegistries = Array.isArray(registriesRaw)
+            ? registriesRaw.map(String)
+            : [];
+        return new CorePublicParameters(pk, String(payload.contract_address ?? payload.contractAddress ?? ''), String(payload.ethereum_http_rpc_url ?? payload.ethereumHttpRpcUrl ?? ''), (payload.eip712_name ?? payload.eip712Name ?? '4Mica'), (payload.eip712_version ?? payload.eip712Version ?? '1'), Number(payload.chain_id ?? payload.chainId), Number(payload.max_accepted_guarantee_version ?? payload.maxAcceptedGuaranteeVersion ?? 1), Array.isArray(payload.accepted_guarantee_versions ?? payload.acceptedGuaranteeVersions)
+            ? (payload.accepted_guarantee_versions ?? payload.acceptedGuaranteeVersions).map((version) => Number(version))
+            : [], String(payload.active_guarantee_domain_separator ?? payload.activeGuaranteeDomainSeparator ?? ''), trustedValidationRegistries, String(payload.validation_hash_canonicalization_version ??
+            payload.validationHashCanonicalizationVersion ??
+            '4MICA_VALIDATION_REQUEST_V1'));
+    }
+}
+exports.CorePublicParameters = CorePublicParameters;

package/dist/payment.d.ts

@@ -1,6 +1,5 @@
-import { PaymentGuaranteeRequestClaims, PaymentSignature, SigningScheme } from './models';
-export interface PaymentPayloadClaims {
-    version: string;
+import { PaymentGuaranteeRequestClaims, PaymentGuaranteeRequestClaimsV2, PaymentSignature, SigningScheme } from './models';
+interface PaymentPayloadClaimsBase {
     user_address: string;
     recipient_address: string;
     tab_id: string;
@@ -9,11 +8,74 @@ export interface PaymentPayloadClaims {
     timestamp: number;
     asset_address: string;
 }
+/** Wire-format representation of V1 payment guarantee claims sent to the core RPC. */
+export interface PaymentPayloadClaims extends PaymentPayloadClaimsBase {
+    version: 'v1';
+}
+/** Wire-format representation of V2 payment guarantee claims sent to the core RPC. */
+export interface PaymentPayloadClaimsV2 extends PaymentPayloadClaimsBase {
+    version: 'v2';
+    validation_registry_address: string;
+    validation_request_hash: string;
+    validation_chain_id: number;
+    validator_address: string;
+    validator_agent_id: string;
+    min_validation_score: number;
+    validation_subject_hash: string;
+    required_validation_tag: string;
+}
+/** Assembled payment payload ready to be submitted to the core RPC `issueGuarantee` endpoint. */
 export interface PaymentPayload {
-    claims: PaymentPayloadClaims;
+    claims: PaymentPayloadClaims | PaymentPayloadClaimsV2;
+    /** 65-byte ECDSA signature as a `0x`-prefixed hex string. */
     signature: string;
     scheme: SigningScheme;
 }
+/**
+ * Serialize V1 payment claims to the wire format expected by the core RPC.
+ *
+ * @param claims - V1 payment guarantee request claims.
+ * @returns JSON-serialisable object with snake_case keys and hex-encoded `uint256` fields.
+ */
 export declare function serializePaymentClaims(claims: PaymentGuaranteeRequestClaims): PaymentPayloadClaims;
+/**
+ * Serialize V2 payment claims to the wire format expected by the core RPC.
+ *
+ * Extends the V1 serialisation with the eight additional validation policy fields.
+ *
+ * @param claims - V2 payment guarantee request claims with validation policy.
+ * @returns JSON-serialisable object with snake_case keys and hex-encoded `uint256` fields.
+ */
+export declare function serializePaymentClaimsV2(claims: PaymentGuaranteeRequestClaimsV2): PaymentPayloadClaimsV2;
+/**
+ * Build a {@link PaymentPayload} from V2 claims and a {@link PaymentSignature}.
+ *
+ * @param claims - V2 payment guarantee request claims.
+ * @param signature - Pre-built signature object (includes the scheme).
+ */
+export declare function buildPaymentPayload(claims: PaymentGuaranteeRequestClaimsV2, signature: PaymentSignature): PaymentPayload;
+/**
+ * Build a {@link PaymentPayload} from V2 claims, a raw signature hex string, and a scheme.
+ *
+ * @param claims - V2 payment guarantee request claims.
+ * @param signature - 65-byte ECDSA signature as a `0x`-prefixed hex string.
+ * @param scheme - Signing scheme used to produce the signature.
+ */
+export declare function buildPaymentPayload(claims: PaymentGuaranteeRequestClaimsV2, signature: string, scheme: SigningScheme): PaymentPayload;
+/**
+ * Build a {@link PaymentPayload} from V1 claims and a {@link PaymentSignature}.
+ *
+ * @param claims - V1 payment guarantee request claims.
+ * @param signature - Pre-built signature object (includes the scheme).
+ */
 export declare function buildPaymentPayload(claims: PaymentGuaranteeRequestClaims, signature: PaymentSignature): PaymentPayload;
+/**
+ * Build a {@link PaymentPayload} from V1 claims, a raw signature hex string, and a scheme.
+ *
+ * @param claims - V1 payment guarantee request claims.
+ * @param signature - 65-byte ECDSA signature as a `0x`-prefixed hex string.
+ * @param scheme - Signing scheme used to produce the signature.
+ * @throws {@link SigningError} if `signature` is a string but no `scheme` is provided.
+ */
 export declare function buildPaymentPayload(claims: PaymentGuaranteeRequestClaims, signature: string, scheme: SigningScheme): PaymentPayload;
+export {};

package/dist/payment.js

@@ -1,31 +1,65 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serializePaymentClaims = serializePaymentClaims;
+exports.serializePaymentClaimsV2 = serializePaymentClaimsV2;
 exports.buildPaymentPayload = buildPaymentPayload;
+const models_1 = require("./models");
 const utils_1 = require("./utils");
+const errors_1 = require("./errors");
+/**
+ * Serialize V1 payment claims to the wire format expected by the core RPC.
+ *
+ * @param claims - V1 payment guarantee request claims.
+ * @returns JSON-serialisable object with snake_case keys and hex-encoded `uint256` fields.
+ */
 function serializePaymentClaims(claims) {
     return {
         version: 'v1',
-        user_address: claims.userAddress,
-        recipient_address: claims.recipientAddress,
+        user_address: claims.userAddress.toLowerCase(),
+        recipient_address: claims.recipientAddress.toLowerCase(),
         tab_id: (0, utils_1.serializeU256)(claims.tabId),
         req_id: (0, utils_1.serializeU256)(claims.reqId),
         amount: (0, utils_1.serializeU256)(claims.amount),
-        asset_address: claims.assetAddress,
+        asset_address: claims.assetAddress.toLowerCase(),
         timestamp: claims.timestamp,
     };
 }
+/**
+ * Serialize V2 payment claims to the wire format expected by the core RPC.
+ *
+ * Extends the V1 serialisation with the eight additional validation policy fields.
+ *
+ * @param claims - V2 payment guarantee request claims with validation policy.
+ * @returns JSON-serialisable object with snake_case keys and hex-encoded `uint256` fields.
+ */
+function serializePaymentClaimsV2(claims) {
+    return {
+        ...serializePaymentClaims(claims),
+        version: 'v2',
+        validation_registry_address: claims.validationRegistryAddress.toLowerCase(),
+        validation_request_hash: claims.validationRequestHash.toLowerCase(),
+        validation_chain_id: claims.validationChainId,
+        validator_address: claims.validatorAddress.toLowerCase(),
+        validator_agent_id: (0, utils_1.serializeU256)(claims.validatorAgentId),
+        min_validation_score: claims.minValidationScore,
+        validation_subject_hash: claims.validationSubjectHash.toLowerCase(),
+        required_validation_tag: claims.requiredValidationTag,
+    };
+}
 function buildPaymentPayload(claims, signature, scheme) {
     const signed = typeof signature === 'string'
         ? (() => {
             if (!scheme) {
-                throw new Error('scheme is required when providing a signature string');
+                throw new errors_1.SigningError('scheme is required when providing a signature string');
             }
             return { signature, scheme };
         })()
         : signature;
+    const serialized = claims instanceof models_1.PaymentGuaranteeRequestClaimsV2
+        ? serializePaymentClaimsV2(claims)
+        : serializePaymentClaims(claims);
     return {
-        claims: serializePaymentClaims(claims),
+        claims: serialized,
         signature: signed.signature,
         scheme: signed.scheme,
     };

package/dist/rpc.d.ts

@@ -1,5 +1,4 @@
-import { AdminApiKeyInfo, AdminApiKeySecret, UserSuspensionStatus } from './models';
-import { CorePublicParameters } from './signing';
+import { AdminApiKeyInfo, AdminApiKeySecret, CorePublicParameters, SupportedTokensResponse, UserSuspensionStatus } from './models';
 import { type FetchFn as HttpFetchFn } from './http';
 export type FetchFn = HttpFetchFn;
 export type BearerTokenProvider = () => string | Promise<string>;
@@ -18,6 +17,7 @@ export declare class RpcProxy {
     private get;
     private post;
     getPublicParams(): Promise<CorePublicParameters>;
+    getSupportedTokens(): Promise<SupportedTokensResponse>;
     issueGuarantee(body: unknown): Promise<Record<string, unknown>>;
     createPaymentTab(body: unknown): Promise<Record<string, unknown>>;
     listSettledTabs(recipientAddress: string): Promise<Record<string, unknown>[]>;

package/dist/rpc.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RpcProxy = void 0;
 const constants_1 = require("./constants");
 const models_1 = require("./models");
-const signing_1 = require("./signing");
 const errors_1 = require("./errors");
 const http_1 = require("./http");
 function serializeTabId(tabId) {
@@ -83,7 +82,11 @@ class RpcProxy {
     }
     async getPublicParams() {
         const data = await this.get('/core/public-params');
-        return signing_1.CorePublicParameters.fromRpc(data);
+        return models_1.CorePublicParameters.fromRpc(data);
+    }
+    async getSupportedTokens() {
+        const data = await this.get('/core/tokens');
+        return models_1.SupportedTokensResponse.fromRpc(data);
     }
     async issueGuarantee(body) {
         return this.post('/core/guarantees', body);

package/dist/signing.d.ts

@@ -1,15 +1,6 @@
 import { Account, type Hex } from 'viem';
-import { PaymentGuaranteeRequestClaims, PaymentSignature, SigningScheme } from './models';
-export declare class CorePublicParameters {
-    publicKey: Uint8Array;
-    contractAddress: string;
-    ethereumHttpRpcUrl: string;
-    eip712Name: string;
-    eip712Version: string;
-    chainId: number;
-    constructor(publicKey: Uint8Array, contractAddress: string, ethereumHttpRpcUrl: string, eip712Name: string, eip712Version: string, chainId: number);
-    static fromRpc(payload: Record<string, unknown>): CorePublicParameters;
-}
+export { computeValidationSubjectHash, computeValidationRequestHash } from './validation';
+import { CorePublicParameters, PaymentGuaranteeRequestClaims, PaymentGuaranteeRequestClaimsV2, PaymentSignature, SigningScheme } from './models';
 export declare const GUARANTEE_EIP712_TYPES: {
     readonly EIP712Domain: readonly [{
         readonly name: "name";
@@ -44,6 +35,64 @@ export declare const GUARANTEE_EIP712_TYPES: {
         readonly type: "uint64";
     }];
 };
+export declare const GUARANTEE_EIP712_TYPES_V2: {
+    readonly EIP712Domain: readonly [{
+        readonly name: "name";
+        readonly type: "string";
+    }, {
+        readonly name: "version";
+        readonly type: "string";
+    }, {
+        readonly name: "chainId";
+        readonly type: "uint256";
+    }];
+    readonly SolGuaranteeRequestClaimsV2: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly name: "recipient";
+        readonly type: "address";
+    }, {
+        readonly name: "tabId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "reqId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "asset";
+        readonly type: "address";
+    }, {
+        readonly name: "timestamp";
+        readonly type: "uint64";
+    }, {
+        readonly name: "validationRegistryAddress";
+        readonly type: "address";
+    }, {
+        readonly name: "validationRequestHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "validationChainId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "validatorAddress";
+        readonly type: "address";
+    }, {
+        readonly name: "validatorAgentId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "minValidationScore";
+        readonly type: "uint8";
+    }, {
+        readonly name: "validationSubjectHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "requiredValidationTag";
+        readonly type: "string";
+    }];
+};
 export type GuaranteeTypedData = {
     types: typeof GUARANTEE_EIP712_TYPES;
     primaryType: 'SolGuaranteeRequestClaimsV1';
@@ -62,6 +111,32 @@ export type GuaranteeTypedData = {
         timestamp: bigint;
     };
 };
+export type GuaranteeTypedDataV2 = {
+    types: typeof GUARANTEE_EIP712_TYPES_V2;
+    primaryType: 'SolGuaranteeRequestClaimsV2';
+    domain: {
+        name: string;
+        version: string;
+        chainId: number;
+    };
+    message: {
+        user: Hex;
+        recipient: Hex;
+        tabId: bigint;
+        reqId: bigint;
+        amount: bigint;
+        asset: Hex;
+        timestamp: bigint;
+        validationRegistryAddress: Hex;
+        validationRequestHash: Hex;
+        validationChainId: bigint;
+        validatorAddress: Hex;
+        validatorAgentId: bigint;
+        minValidationScore: number;
+        validationSubjectHash: Hex;
+        requiredValidationTag: string;
+    };
+};
 export type GuaranteeTypedDataValidationOptions = {
     expectedChainId?: number;
     expectedSigner?: string;
@@ -81,9 +156,11 @@ export declare function validateGuaranteeTypedData(payload: {
 }, options?: GuaranteeTypedDataValidationOptions): void;
 export declare function validateGuaranteeSigningContext(params: CorePublicParameters, claims: PaymentGuaranteeRequestClaims, options?: GuaranteeSigningContextOptions): void;
 export declare function buildGuaranteeTypedData(params: CorePublicParameters, claims: PaymentGuaranteeRequestClaims): GuaranteeTypedData;
+export declare function buildGuaranteeTypedDataV2(params: CorePublicParameters, claims: PaymentGuaranteeRequestClaimsV2): GuaranteeTypedDataV2;
+export declare function encodeGuaranteeEip191V2(claims: PaymentGuaranteeRequestClaimsV2): string;
 export declare function encodeGuaranteeEip191(claims: PaymentGuaranteeRequestClaims): string;
 export declare class PaymentSigner {
     readonly signer: Account;
     constructor(signer: Account);
-    signRequest(params: CorePublicParameters, claims: PaymentGuaranteeRequestClaims, scheme?: SigningScheme): Promise<PaymentSignature>;
+    signRequest(params: CorePublicParameters, claims: PaymentGuaranteeRequestClaims | PaymentGuaranteeRequestClaimsV2, scheme?: SigningScheme): Promise<PaymentSignature>;
 }