@coinbase-sample/prime-sdk-ts 0.6.3 → 0.6.4

package/dist/types/shared/dynamicEnumValidation.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Copyright 2025-present Coinbase Global, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Dynamic enum validation system that automatically discovers and validates
+ * enum fields in request objects without manual service-specific configuration.
+ *
+ * This approach is more scalable and maintainable than manual validation rules.
+ */
+import { enumRegistry } from './enumRegistry';
+import { DynamicEnumValidationError, DynamicValidationConfig, FieldTypeInfo } from './enumValidationCore';
+/**
+ * Set global configuration for dynamic enum validation
+ */
+export declare function setDynamicValidationConfig(config: Partial<DynamicValidationConfig>): void;
+/**
+ * Get current dynamic validation configuration
+ */
+export declare function getDynamicValidationConfig(): DynamicValidationConfig;
+/**
+ * Main API: Validate and normalize request with type-safe generics
+ */
+export declare function dynamicValidateRequest<T>(request: T, config?: Partial<DynamicValidationConfig>): T;
+/**
+ * Get information about discovered enums
+ */
+export declare function getEnumInfo(): {
+    totalEnums: number;
+    enumNames: string[];
+    enumDetails: Record<string, {
+        values: string[];
+        keys: string[];
+    }>;
+};
+export { DynamicEnumValidationError, DynamicValidationConfig, FieldTypeInfo };
+export { enumRegistry };

package/dist/types/shared/dynamicEnumValidation.old.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Copyright 2025-present Coinbase Global, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Error thrown when a request contains invalid enum values
+ */
+export declare class DynamicEnumValidationError extends Error {
+    field: string;
+    value: string;
+    enumName: string;
+    validValues: string[];
+    validKeys?: string[] | undefined;
+    constructor(field: string, value: string, enumName: string, validValues: string[], validKeys?: string[] | undefined);
+}
+/**
+ * Registry of all available enums for dynamic lookup
+ */
+declare class EnumRegistry {
+    private enumMap;
+    private enumNameMap;
+    constructor();
+    /**
+     * Automatically register all enums from the model/enums directory
+     */
+    private registerAllEnums;
+    /**
+     * Check if an object is a valid enum
+     */
+    private isValidEnum;
+    /**
+     * Get enum by name
+     */
+    getEnum(enumName: string): Record<string, string> | undefined;
+    /**
+     * Get enum name for a given enum object
+     */
+    getEnumName(enumObject: Record<string, string>): string | undefined;
+    /**
+     * Find enum that contains a specific value
+     */
+    findEnumByValue(value: string): {
+        enum: Record<string, string>;
+        name: string;
+    } | undefined;
+    /**
+     * Find enum that contains a specific key
+     */
+    findEnumByKey(key: string): {
+        enum: Record<string, string>;
+        name: string;
+    } | undefined;
+    /**
+     * Get all registered enum names
+     */
+    getAllEnumNames(): string[];
+    /**
+     * Validate a value against a specific enum with prefix handling
+     */
+    validateEnumValue(enumName: string, value: string): {
+        valid: boolean;
+        normalizedValue?: string;
+        error?: string;
+    };
+}
+declare const enumRegistry: EnumRegistry;
+/**
+ * Validates and normalizes enum fields in a request object
+ */
+export declare function validateRequestEnums(request: any, options?: {
+    strict?: boolean;
+    autoNormalize?: boolean;
+}): {
+    validatedRequest: any;
+    errors: string[];
+};
+/**
+ * Simplified validation function that throws on first error
+ */
+export declare function validateAndNormalizeRequest(request: any): any;
+/**
+ * Configuration for dynamic validation
+ */
+export interface DynamicValidationConfig {
+    enabled?: boolean;
+    strict?: boolean;
+    autoNormalize?: boolean;
+    logWarnings?: boolean;
+}
+/**
+ * Set global dynamic validation configuration
+ */
+export declare function setDynamicValidationConfig(config: Partial<DynamicValidationConfig>): void;
+/**
+ * Get current dynamic validation configuration
+ */
+export declare function getDynamicValidationConfig(): DynamicValidationConfig;
+/**
+ * Type-safe dynamic enum validation function
+ *
+ * Automatically validates and normalizes enum values in request objects
+ * using the auto-generated prefix patterns from the OpenAPI specification.
+ *
+ * @param request - The request object to validate and normalize
+ * @param config - Optional validation configuration
+ * @returns The validated request with normalized enum values
+ *
+ * @example
+ * ```typescript
+ * const validated = dynamicValidateRequest<CreateOrderRequest>({
+ *   portfolioId: 'portfolio-123',
+ *   side: 'buy',      // → 'BUY'
+ *   type: 'market'    // → 'MARKET'
+ * });
+ * ```
+ */
+export declare function dynamicValidateRequest<T>(request: T, config?: Partial<DynamicValidationConfig>): T;
+/**
+ * Export the enum registry for advanced usage
+ */
+export { enumRegistry };
+/**
+ * Utility function to get information about available enums
+ */
+export declare function getEnumInfo(): {
+    enumNames: string[];
+    totalEnums: number;
+    enumDetails: Record<string, {
+        values: string[];
+        keys: string[];
+    }>;
+};

package/dist/types/shared/enumHelpers.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Copyright 2025-present Coinbase Global, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Enum transformation utilities for JavaScript developers.
+ * These helpers make it easier to work with enums by providing:
+ * - Case-insensitive enum lookups
+ * - CamelCase to SNAKE_CASE conversion
+ * - Enum validation with helpful error messages
+ * - Support for prefix-aware transformations
+ */
+/**
+ * Converts a string from various formats to the expected enum value format (SCREAMING_SNAKE_CASE)
+ *
+ * @param input - The input string in any case format
+ * @returns The normalized SCREAMING_SNAKE_CASE string
+ *
+ * @example
+ * normalizeEnumValue('buy') // 'BUY'
+ * normalizeEnumValue('marketOrder') // 'MARKET_ORDER'
+ * normalizeEnumValue('STOP_LIMIT') // 'STOP_LIMIT'
+ * normalizeEnumValue('Order_Type_Market') // 'ORDER_TYPE_MARKET'
+ */
+export declare function normalizeEnumValue(input: string): string;
+/**
+ * Safely gets an enum value by normalizing the input and checking if it exists
+ *
+ * @param enumObject - The enum object to search in
+ * @param input - The input value to normalize and find
+ * @param enumName - Optional enum name for better error messages
+ * @returns The matching enum value or undefined if not found
+ *
+ * @example
+ * import { OrderSide } from '../model/enums/OrderSide';
+ *
+ * getEnumValue(OrderSide, 'buy') // OrderSide.Buy
+ * getEnumValue(OrderSide, 'BUY') // OrderSide.Buy
+ * getEnumValue(OrderSide, 'invalid') // undefined
+ */
+export declare function getEnumValue<T extends Record<string, string>>(enumObject: T, input: string, enumName?: string): T[keyof T] | undefined;
+/**
+ * Gets an enum value with strict validation, throwing an error if not found
+ *
+ * @param enumObject - The enum object to search in
+ * @param input - The input value to normalize and find
+ * @param enumName - Optional enum name for better error messages
+ * @returns The matching enum value
+ * @throws Error if the enum value is not found
+ *
+ * @example
+ * import { OrderSide } from '../model/enums/OrderSide';
+ *
+ * requireEnumValue(OrderSide, 'buy') // OrderSide.Buy
+ * requireEnumValue(OrderSide, 'invalid') // throws Error
+ */
+export declare function requireEnumValue<T extends Record<string, string>>(enumObject: T, input: string, enumName?: string): T[keyof T];
+/**
+ * Checks if a string is a valid enum value (case-insensitive)
+ *
+ * @param enumObject - The enum object to check against
+ * @param input - The input value to validate
+ * @returns True if the input is a valid enum value
+ *
+ * @example
+ * import { OrderSide } from '../model/enums/OrderSide';
+ *
+ * isValidEnumValue(OrderSide, 'buy') // true
+ * isValidEnumValue(OrderSide, 'BUY') // true
+ * isValidEnumValue(OrderSide, 'invalid') // false
+ */
+export declare function isValidEnumValue<T extends Record<string, string>>(enumObject: T, input: string): boolean;
+/**
+ * Gets all possible enum values as an array
+ *
+ * @param enumObject - The enum object
+ * @returns Array of all enum values
+ *
+ * @example
+ * import { OrderSide } from '../model/enums/OrderSide';
+ *
+ * getEnumValues(OrderSide) // ['BUY', 'SELL']
+ */
+export declare function getEnumValues<T extends Record<string, string>>(enumObject: T): T[keyof T][];
+/**
+ * Gets all possible enum keys as an array
+ *
+ * @param enumObject - The enum object
+ * @returns Array of all enum keys
+ *
+ * @example
+ * import { OrderSide } from '../model/enums/OrderSide';
+ *
+ * getEnumKeys(OrderSide) // ['Buy', 'Sell']
+ */
+export declare function getEnumKeys<T extends Record<string, string>>(enumObject: T): (keyof T)[];
+/**
+ * Validates that a string has the correct prefix for enum values
+ * Useful for ensuring enum values follow expected patterns
+ *
+ * @param input - The enum value to check
+ * @param expectedPrefix - The expected prefix (e.g., 'ORDER_TYPE_', 'ACTIVITY_TYPE_')
+ * @param strict - If true, requires exact prefix match. If false, allows values without prefix
+ * @returns True if the prefix is correct
+ *
+ * @example
+ * validateEnumPrefix('ORDER_TYPE_MARKET', 'ORDER_TYPE_') // true
+ * validateEnumPrefix('MARKET', 'ORDER_TYPE_', false) // true (non-strict)
+ * validateEnumPrefix('MARKET', 'ORDER_TYPE_', true) // false (strict)
+ */
+export declare function validateEnumPrefix(input: string, expectedPrefix: string, strict?: boolean): boolean;
+/**
+ * Transforms enum input to the correct format, optionally adding a prefix
+ *
+ * @param input - The input string
+ * @param prefix - Optional prefix to add if not present
+ * @returns The transformed enum value
+ *
+ * @example
+ * transformEnumValue('market', 'ORDER_TYPE_') // 'ORDER_TYPE_MARKET'
+ * transformEnumValue('ORDER_TYPE_MARKET', 'ORDER_TYPE_') // 'ORDER_TYPE_MARKET'
+ * transformEnumValue('marketOrder') // 'MARKET_ORDER'
+ */
+export declare function transformEnumValue(input: string, prefix?: string): string;

package/dist/types/shared/enumRegistry.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Copyright 2025-present Coinbase Global, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Registry for managing discovered enums and providing lookup capabilities
+ */
+export declare class EnumRegistry {
+    private enums;
+    private enumsByValue;
+    private enumsByKey;
+    constructor();
+    /**
+     * Automatically discover and register all enums from the model/enums directory
+     */
+    private populateEnums;
+    /**
+     * Check if an object is a valid TypeScript enum
+     */
+    private isValidEnum;
+    /**
+     * Index enum values and keys for fast lookup
+     */
+    private indexEnumValues;
+    /**
+     * Get a specific enum by name
+     */
+    getEnum(enumName: string): Record<string, string> | null;
+    /**
+     * Get all registered enum names
+     */
+    getAllEnumNames(): string[];
+    /**
+     * Find enum by value (exact match)
+     */
+    findEnumByValue(value: string): {
+        enum: Record<string, string>;
+        name: string;
+    } | null;
+    /**
+     * Find enum by key (exact match)
+     */
+    findEnumByKey(key: string): {
+        enum: Record<string, string>;
+        name: string;
+    } | null;
+    /**
+     * Get statistics about discovered enums
+     */
+    getStats(): {
+        totalEnums: number;
+        totalValues: number;
+        totalKeys: number;
+    };
+    /**
+     * Get detailed information about all enums
+     */
+    getEnumDetails(): Record<string, {
+        values: string[];
+        keys: string[];
+    }>;
+}
+export declare const enumRegistry: EnumRegistry;

package/dist/types/shared/enumValidationCore.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Copyright 2025-present Coinbase Global, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Error thrown when a request contains invalid enum values
+ */
+export declare class DynamicEnumValidationError extends Error {
+    field: string;
+    value: string;
+    enumName: string;
+    validValues: string[];
+    validKeys?: string[] | undefined;
+    constructor(field: string, value: string, enumName: string, validValues: string[], validKeys?: string[] | undefined);
+}
+/**
+ * Configuration for dynamic validation behavior
+ */
+export interface DynamicValidationConfig {
+    enabled: boolean;
+    strict: boolean;
+    autoNormalize: boolean;
+    logWarnings: boolean;
+    serviceName?: string;
+}
+/**
+ * Information about a field that contains enum values
+ */
+export interface FieldTypeInfo {
+    fieldName: string;
+    enumName: string;
+    isOptional: boolean;
+    isArray: boolean;
+}
+/**
+ * Check if a value is valid for a specific enum (includes normalization)
+ */
+export declare function isValueValidForEnum(value: string, enumObject: Record<string, string>): boolean;
+/**
+ * Detects the enum type for a field based on field name patterns and value analysis
+ */
+export declare function detectEnumType(fieldName: string, value: string, serviceName?: string): {
+    enum: Record<string, string>;
+    name: string;
+} | null;
+/**
+ * Analyzes a single field to determine if it's an enum
+ */
+export declare function analyzeField(fieldName: string, value: any, serviceName?: string): FieldTypeInfo | null;
+/**
+ * Validate and normalize a single enum value
+ */
+export declare function validateEnumValue(value: string, enumObject: Record<string, string>, enumName: string, fieldName: string, config: DynamicValidationConfig): {
+    isValid: boolean;
+    normalizedValue?: string;
+    error?: string;
+};

package/dist/types/shared/enumValidators.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Copyright 2025-present Coinbase Global, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Convenient enum validators for common Prime API enums.
+ * These provide pre-configured validation for frequently used enum types.
+ *
+ * Note: Most users should use the dynamic validation system instead, which
+ * automatically handles all enums. These validators are useful for explicit
+ * control or when you need to validate individual enum values.
+ */
+import { normalizeEnumValue } from './enumHelpers';
+import { OrderType } from '../model/enums/OrderType';
+import { OrderSide } from '../model/enums/OrderSide';
+import { OrderStatus } from '../model/enums/OrderStatus';
+import { TransactionType } from '../model/enums/TransactionType';
+import { TimeInForceType } from '../model/enums/TimeInForceType';
+/**
+ * Order-related enum helpers
+ */
+export declare const OrderEnums: {
+    /**
+     * Validates and normalizes order type values
+     * Accepts: 'market', 'limit', 'twap', 'block', 'vwap', 'stopLimit', 'rfq' (case-insensitive)
+     */
+    getOrderType: (input: string) => OrderType | undefined;
+    requireOrderType: (input: string) => OrderType;
+    isValidOrderType: (input: string) => boolean;
+    /**
+     * Validates and normalizes order side values
+     * Accepts: 'buy', 'sell' (case-insensitive)
+     */
+    getOrderSide: (input: string) => OrderSide | undefined;
+    requireOrderSide: (input: string) => OrderSide;
+    isValidOrderSide: (input: string) => boolean;
+    /**
+     * Validates and normalizes order status values
+     * Accepts: 'open', 'filled', 'cancelled', 'expired', 'failed', 'pending' (case-insensitive)
+     */
+    getOrderStatus: (input: string) => OrderStatus | undefined;
+    requireOrderStatus: (input: string) => OrderStatus;
+    isValidOrderStatus: (input: string) => boolean;
+    /**
+     * Validates and normalizes time in force type values
+     * Accepts: 'good_until_cancelled', 'good_until_time', 'immediate_or_cancel', 'fill_or_kill' (case-insensitive)
+     */
+    getTimeInForceType: (input: string) => TimeInForceType | undefined;
+    requireTimeInForceType: (input: string) => TimeInForceType;
+    isValidTimeInForceType: (input: string) => boolean;
+};
+/**
+ * Transaction-related enum helpers
+ */
+export declare const TransactionEnums: {
+    /**
+     * Validates and normalizes transaction type values
+     * Accepts various transaction types like 'deposit', 'withdrawal', 'internalDeposit', etc. (case-insensitive)
+     */
+    getTransactionType: (input: string) => TransactionType | undefined;
+    requireTransactionType: (input: string) => TransactionType;
+    isValidTransactionType: (input: string) => boolean;
+};
+/**
+ * Utility for creating custom enum validators for any enum type
+ *
+ * @param enumObject - The enum object to create validators for
+ * @param enumName - Name of the enum for error messages
+ * @returns Object with validation methods
+ *
+ * @example
+ * import { WalletType } from '../model/enums/WalletType';
+ *
+ * const WalletValidators = createEnumValidators(WalletType, 'WalletType');
+ * WalletValidators.get('trading'); // Gets WalletType value
+ * WalletValidators.require('custody'); // Gets WalletType value or throws
+ * WalletValidators.isValid('invalid'); // false
+ */
+export declare function createEnumValidators<T extends Record<string, string>>(enumObject: T, enumName: string): {
+    get: (input: string) => T[keyof T] | undefined;
+    require: (input: string) => T[keyof T];
+    isValid: (input: string) => boolean;
+    values: string[];
+    keys: string[];
+};
+/**
+ * Convenience function to normalize any string to enum format
+ * Useful for debugging or preparing values for API calls
+ *
+ * @example
+ * toEnumFormat('marketOrder') // 'MARKET_ORDER'
+ * toEnumFormat('buy') // 'BUY'
+ * toEnumFormat('stop-limit') // 'STOP_LIMIT'
+ */
+export { normalizeEnumValue as toEnumFormat };
+/**
+ * @deprecated Use the dynamic validation system instead.
+ *
+ * Most users should prefer:
+ * ```javascript
+ * import { dynamicValidateRequest } from '@coinbase/prime-sdk';
+ * const validated = dynamicValidateRequest(request);
+ * ```
+ *
+ * This provides automatic validation for all enum fields without manual configuration.
+ */

package/dist/types/shared/fieldMapping.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Copyright 2025-present Coinbase Global, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Generate field name variations for plural/singular matching
+ */
+export declare function getFieldNameVariations(fieldName: string): string[];
+/**
+ * Extract context clues from field names to resolve enum ambiguity
+ */
+export declare function extractContextClues(fieldName: string): string[];
+/**
+ * Find enum with context awareness to resolve collisions
+ */
+export declare function findEnumWithContext(fieldName: string, allEnumNames: string[]): string | null;
+/**
+ * Dynamically find enum name based on field name patterns
+ */
+export declare function findEnumByFieldName(fieldName: string): string | null;
+/**
+ * Get direct field-to-enum mapping with service context and fallback to essential mappings
+ */
+export declare function getDirectEnumMapping(fieldName: string, serviceName?: string): string | null;

package/dist/types/shared/serviceContext.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Copyright 2025-present Coinbase Global, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Service context for enhanced enum field detection
+ */
+/**
+ * Service-specific enum mappings to resolve ambiguous field names
+ */
+export interface ServiceEnumContext {
+    serviceName: string;
+    fieldMappings: Record<string, string>;
+    description?: string;
+}
+/**
+ * Registry of service contexts for accurate enum detection
+ */
+export declare const SERVICE_CONTEXTS: Record<string, ServiceEnumContext>;
+/**
+ * Get service context by service name
+ */
+export declare function getServiceContext(serviceName: string): ServiceEnumContext | null;
+/**
+ * Resolve field to enum using service context
+ */
+export declare function resolveFieldWithServiceContext(fieldName: string, serviceName?: string): string | null;
+/**
+ * Get all available service contexts
+ */
+export declare function getAllServiceContexts(): Record<string, ServiceEnumContext>;
+/**
+ * Check if a service has context defined
+ */
+export declare function hasServiceContext(serviceName: string): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coinbase-sample/prime-sdk-ts",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "main": "dist/index.js",
   "types": "dist/types/index.d.ts",
   "exports": {
@@ -67,6 +67,6 @@
     "typescript": "^5.9.2"
   },
   "dependencies": {
-    "@coinbase-sample/core-ts": "^0.2.0"
+    "@coinbase-sample/core-ts": "^0.2.1"
   }
 }