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

package/dist/shared/envUtils.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCredentialsFromEnv = createCredentialsFromEnv;
+/**
+ * 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.
+ */
+const credentials_1 = require("../credentials");
+/**
+ * Shared utility function to create credentials from environment variables
+ * Used by both CoinbasePrimeClient and CoinbasePrimeClientWithServices
+ *
+ * Automatically attempts to load .env file if dotenv is available.
+ * If dotenv is not installed or .env file doesn't exist, falls back to
+ * using environment variables set directly.
+ *
+ * @advanced For custom scenarios. Most users should use Client.fromEnv() instead.
+ * @example
+ * ```typescript
+ * // Basic usage (recommended)
+ * const client = CoinbasePrimeClient.fromEnv();
+ *
+ * // Advanced usage (custom scenarios)
+ * const credentials = createCredentialsFromEnv();
+ * const client = new CoinbasePrimeClient(credentials, 'custom-url');
+ * ```
+ */
+function createCredentialsFromEnv() {
+    // Try to load .env file if dotenv is available (optional)
+    try {
+        require('dotenv').config();
+    }
+    catch (error) {
+        // dotenv not installed or .env file doesn't exist - that's fine
+        // Environment variables might be set directly via shell, Docker, CI/CD, etc.
+    }
+    const credsJson = process.env.PRIME_CREDENTIALS;
+    if (!credsJson) {
+        throw new Error('PRIME_CREDENTIALS environment variable is required. ' +
+            'Set it to a JSON string with AccessKey, SecretKey, and Passphrase. ' +
+            'You can set it directly (export PRIME_CREDENTIALS=\'{"AccessKey":"...","SecretKey":"...","Passphrase":"..."}\') ' +
+            'or create a .env file with PRIME_CREDENTIALS={"AccessKey":"...","SecretKey":"...","Passphrase":"..."}.');
+    }
+    let creds;
+    try {
+        creds = JSON.parse(credsJson);
+    }
+    catch (error) {
+        throw new Error('PRIME_CREDENTIALS must be valid JSON with AccessKey, SecretKey, and Passphrase fields.');
+    }
+    if (!creds.AccessKey || !creds.SecretKey || !creds.Passphrase) {
+        throw new Error('PRIME_CREDENTIALS must contain AccessKey, SecretKey, and Passphrase fields.');
+    }
+    return new credentials_1.CoinbasePrimeCredentials(creds.AccessKey, creds.SecretKey, creds.Passphrase);
+}

package/dist/shared/fieldMapping.js

@@ -0,0 +1,242 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFieldNameVariations = getFieldNameVariations;
+exports.extractContextClues = extractContextClues;
+exports.findEnumWithContext = findEnumWithContext;
+exports.findEnumByFieldName = findEnumByFieldName;
+exports.getDirectEnumMapping = getDirectEnumMapping;
+/**
+ * Field-to-enum mapping logic for dynamic enum detection
+ */
+const enumRegistry_1 = require("./enumRegistry");
+const serviceContext_1 = require("./serviceContext");
+/**
+ * Generate field name variations for plural/singular matching
+ */
+function getFieldNameVariations(fieldName) {
+    const variations = [fieldName];
+    // Handle irregular plurals and common patterns
+    const irregularPlurals = {
+        categories: 'category',
+        statuses: 'status',
+        activities: 'activity',
+        entities: 'entity',
+        currencies: 'currency',
+        portfolios: 'portfolio',
+    };
+    const irregularSingulars = {
+        category: 'categories',
+        status: 'statuses',
+        activity: 'activities',
+        entity: 'entities',
+        currency: 'currencies',
+        portfolio: 'portfolios',
+    };
+    // Check irregular mappings first
+    if (irregularPlurals[fieldName]) {
+        variations.push(irregularPlurals[fieldName]);
+    }
+    if (irregularSingulars[fieldName]) {
+        variations.push(irregularSingulars[fieldName]);
+    }
+    // Handle regular -s plurals only if not already handled by irregular rules
+    if (!irregularPlurals[fieldName] && !irregularSingulars[fieldName]) {
+        if (fieldName.endsWith('s') && fieldName.length > 3) {
+            // Remove 's' for potential singular
+            const singular = fieldName.slice(0, -1);
+            // Avoid cases like "address" -> "addres"
+            if (!singular.endsWith('s')) {
+                variations.push(singular);
+            }
+        }
+        else {
+            // Add regular plural
+            variations.push(fieldName + 's');
+        }
+    }
+    return variations;
+}
+/**
+ * Extract context clues from field names to resolve enum ambiguity
+ */
+function extractContextClues(fieldName) {
+    const clues = [];
+    const fieldLower = fieldName.toLowerCase();
+    // Extract prefix context (e.g., "activitystatus" → ["activity"])
+    const prefixMatch = fieldLower.match(/^([a-z]+?)(?:status|type|category)$/);
+    if (prefixMatch) {
+        clues.push(prefixMatch[1]);
+    }
+    // Extract camelCase components (e.g., "activityStatus" → ["activity"])
+    const camelComponents = fieldName
+        .replace(/([A-Z])/g, '_$1')
+        .toLowerCase()
+        .split('_')
+        .filter(Boolean);
+    clues.push(...camelComponents.slice(0, -1)); // Exclude the last component (status/type/category)
+    // Extract underscore/dash separated components
+    const separatedComponents = fieldName.toLowerCase().split(/[_-]+/);
+    clues.push(...separatedComponents.slice(0, -1));
+    return [...new Set(clues)]; // Remove duplicates
+}
+/**
+ * Find enum with context awareness to resolve collisions
+ */
+function findEnumWithContext(fieldName, allEnumNames) {
+    // Handle ambiguous suffixes that appear in multiple enums
+    const ambiguousSuffixes = ['status', 'type', 'category'];
+    const fieldLower = fieldName.toLowerCase();
+    // Check if this is an ambiguous field name
+    const isAmbiguous = ambiguousSuffixes.some((suffix) => fieldLower.endsWith(suffix) || fieldLower === suffix);
+    if (isAmbiguous) {
+        // For ambiguous cases, look for context clues in the field name
+        const contextClues = extractContextClues(fieldName);
+        // Find enum that best matches the context
+        const matches = allEnumNames.filter((enumName) => {
+            const enumLower = enumName.toLowerCase();
+            // Exact compound match (e.g., "activitystatus" → "ActivityStatus")
+            if (enumLower === fieldLower)
+                return true;
+            // Context-based matching
+            for (const clue of contextClues) {
+                if (enumLower.includes(clue) &&
+                    enumLower.endsWith(fieldLower.split(/(?=[a-z])/).pop() || '')) {
+                    return true;
+                }
+            }
+            return false;
+        });
+        // Return the most specific match
+        if (matches.length === 1) {
+            return matches[0];
+        }
+        // If multiple matches, prefer the longest/most specific one
+        if (matches.length > 1) {
+            return matches.reduce((longest, current) => current.length > longest.length ? current : longest);
+        }
+    }
+    // Non-ambiguous cases: use careful substring matching
+    // Sort enums by name length (shortest first) to prefer simpler matches
+    const sortedEnumNames = allEnumNames
+        .slice()
+        .sort((a, b) => a.length - b.length);
+    for (const enumName of sortedEnumNames) {
+        const enumNameLower = enumName.toLowerCase();
+        // Only match if field name is a meaningful part of the enum name
+        // Avoid greedy matches like "side" matching "FcmPositionSide"
+        if (enumNameLower === fieldLower) {
+            return enumName; // Exact match
+        }
+        // Check if field name appears as a word boundary in enum name
+        // e.g., "side" should match "OrderSide" but not "FcmPositionSide"
+        const wordBoundaryRegex = new RegExp(`\\b${fieldLower}\\b`, 'i');
+        if (wordBoundaryRegex.test(enumName)) {
+            return enumName;
+        }
+        // Check for field name at the end of enum name (most common pattern)
+        if (enumNameLower.endsWith(fieldLower) && enumNameLower !== fieldLower) {
+            // Ensure it's not a substring within a word
+            const beforeField = enumNameLower.slice(0, -fieldLower.length);
+            if (beforeField.length > 0 && /[a-z]$/.test(beforeField)) {
+                continue; // Skip if it's part of a word
+            }
+            return enumName;
+        }
+    }
+    return null;
+}
+/**
+ * Dynamically find enum name based on field name patterns
+ */
+function findEnumByFieldName(fieldName) {
+    const allEnumNames = enumRegistry_1.enumRegistry.getAllEnumNames();
+    // Strategy 1: Direct name match (e.g., "ActivityCategory" field → "ActivityCategory" enum)
+    const exactMatch = allEnumNames.find((enumName) => enumName.toLowerCase() === fieldName.toLowerCase());
+    if (exactMatch)
+        return exactMatch;
+    // Strategy 2: Smart plural/singular variations
+    const variations = getFieldNameVariations(fieldName);
+    for (const enumName of allEnumNames) {
+        const enumNameLower = enumName.toLowerCase();
+        if (variations.includes(enumNameLower)) {
+            return enumName;
+        }
+    }
+    // Strategy 3: Context-aware enum matching (handles collisions)
+    const contextMatch = findEnumWithContext(fieldName, allEnumNames);
+    if (contextMatch) {
+        return contextMatch;
+    }
+    // Strategy 4: Smart pattern matching for compound field names
+    // Handle cases like "activitycategory" → "ActivityCategory"
+    for (const enumName of allEnumNames) {
+        const enumWords = enumName
+            .toLowerCase()
+            .replace(/([A-Z])/g, ' $1')
+            .trim()
+            .split(' ');
+        const fieldWords = fieldName
+            .replace(/([A-Z])/g, ' $1')
+            .trim()
+            .split(/[\s_-]+/);
+        // Check if all field words are contained in enum words
+        const allWordsMatch = fieldWords.every((word) => enumWords.some((enumWord) => enumWord.includes(word) || word.includes(enumWord)));
+        if (allWordsMatch && fieldWords.length > 1) {
+            return enumName;
+        }
+    }
+    return null;
+}
+/**
+ * Get direct field-to-enum mapping with service context and fallback to essential mappings
+ */
+function getDirectEnumMapping(fieldName, serviceName) {
+    const fieldNameLower = fieldName.toLowerCase();
+    // First priority: Service context-specific mapping
+    if (serviceName) {
+        const serviceMapping = (0, serviceContext_1.resolveFieldWithServiceContext)(fieldName, serviceName);
+        if (serviceMapping) {
+            return serviceMapping;
+        }
+    }
+    // Second priority: Dynamic enum name matching
+    const dynamicMatch = findEnumByFieldName(fieldNameLower);
+    if (dynamicMatch) {
+        return dynamicMatch;
+    }
+    // Fall back to essential manual mappings for common patterns that don't follow naming conventions
+    // These should be conservative and only include non-ambiguous cases
+    const essentialMappings = {
+        // Common trading/order fields (most frequent use case)
+        side: 'OrderSide',
+        status: 'OrderStatus', // Default to OrderStatus, validation will catch mismatches
+        role: 'UserRole',
+        action: 'Action',
+        direction: 'SortDirection',
+        // Specific compound fields to prevent wrong mappings
+        orderside: 'OrderSide',
+        ordertype: 'OrderType',
+        orderstatus: 'OrderStatus',
+        wallettype: 'WalletType',
+        transactiontype: 'TransactionType',
+        activitytype: 'CustodyActivityType',
+        activitystatus: 'ActivityStatus',
+        // Note: 'type' still removed (too ambiguous - let value-based detection handle it)
+    };
+    return essentialMappings[fieldNameLower] || null;
+}

package/dist/shared/serviceContext.js

@@ -0,0 +1,157 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SERVICE_CONTEXTS = void 0;
+exports.getServiceContext = getServiceContext;
+exports.resolveFieldWithServiceContext = resolveFieldWithServiceContext;
+exports.getAllServiceContexts = getAllServiceContexts;
+exports.hasServiceContext = hasServiceContext;
+/**
+ * Registry of service contexts for accurate enum detection
+ */
+exports.SERVICE_CONTEXTS = {
+    // Activities Service
+    activities: {
+        serviceName: 'ActivitiesService',
+        fieldMappings: {
+            status: 'ActivityStatus',
+            type: 'CustodyActivityType',
+            category: 'ActivityCategory',
+            categories: 'ActivityCategory',
+            secondaryType: 'ActivitySecondaryType',
+        },
+        description: 'Portfolio and entity activity operations',
+    },
+    // Orders Service
+    orders: {
+        serviceName: 'OrdersService',
+        fieldMappings: {
+            status: 'OrderStatus',
+            type: 'OrderType',
+            side: 'OrderSide',
+            timeInForce: 'TimeInForceType',
+        },
+        description: 'Trading order operations',
+    },
+    // Transactions Service
+    transactions: {
+        serviceName: 'TransactionsService',
+        fieldMappings: {
+            status: 'TransactionStatus',
+            type: 'TransactionType',
+            destinationType: 'DestinationType',
+        },
+        description: 'Transaction and transfer operations',
+    },
+    // Wallets Service
+    wallets: {
+        serviceName: 'WalletsService',
+        fieldMappings: {
+            type: 'WalletType',
+            status: 'WalletStatus',
+        },
+        description: 'Wallet management operations',
+    },
+    // Allocations Service
+    allocations: {
+        serviceName: 'AllocationsService',
+        fieldMappings: {
+            status: 'AllocationStatus',
+            type: 'AllocationType',
+        },
+        description: 'Portfolio allocation operations',
+    },
+    // Users Service
+    users: {
+        serviceName: 'UsersService',
+        fieldMappings: {
+            role: 'UserRole',
+            status: 'UserStatus',
+        },
+        description: 'User management operations',
+    },
+    // Balances Service
+    balances: {
+        serviceName: 'BalancesService',
+        fieldMappings: {
+            type: 'PortfolioBalanceType',
+        },
+        description: 'Balance and portfolio operations',
+    },
+    // Portfolios Service
+    portfolios: {
+        serviceName: 'PortfoliosService',
+        fieldMappings: {
+            type: 'PortfolioType',
+            status: 'PortfolioStatus',
+        },
+        description: 'Portfolio management operations',
+    },
+    // Products Service
+    products: {
+        serviceName: 'ProductsService',
+        fieldMappings: {
+            type: 'ProductType',
+            permissions: 'ProductPermissions',
+            category: 'ProductCategory',
+        },
+        description: 'Product and market data operations',
+    },
+    // Assets Service
+    assets: {
+        serviceName: 'AssetsService',
+        fieldMappings: {
+            type: 'AssetType',
+            status: 'AssetStatus',
+        },
+        description: 'Asset management operations',
+    },
+};
+/**
+ * Get service context by service name
+ */
+function getServiceContext(serviceName) {
+    // Normalize service name (remove "Service" suffix if present)
+    const normalizedName = serviceName.toLowerCase().replace(/service$/, '');
+    return exports.SERVICE_CONTEXTS[normalizedName] || null;
+}
+/**
+ * Resolve field to enum using service context
+ */
+function resolveFieldWithServiceContext(fieldName, serviceName) {
+    if (!serviceName) {
+        return null;
+    }
+    const context = getServiceContext(serviceName);
+    if (!context) {
+        return null;
+    }
+    const fieldLower = fieldName.toLowerCase();
+    return context.fieldMappings[fieldLower] || null;
+}
+/**
+ * Get all available service contexts
+ */
+function getAllServiceContexts() {
+    return Object.assign({}, exports.SERVICE_CONTEXTS);
+}
+/**
+ * Check if a service has context defined
+ */
+function hasServiceContext(serviceName) {
+    return getServiceContext(serviceName) !== null;
+}

package/dist/staking/index.js

@@ -25,7 +25,7 @@ exports.StakingService = void 0;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const core_ts_1 = require("@coinbase-sample/core-ts");
+const clients_1 = require("../clients");
 class StakingService {
     constructor(client) {
         this.client = client;
@@ -35,7 +35,7 @@ class StakingService {
             const bodyParams = Object.assign(Object.assign({}, request), { portfolioId: undefined, walletId: undefined });
             const response = yield this.client.request({
                 url: `portfolios/${request.portfolioId}/wallets/${request.walletId}/staking/initiate`,
-                method: core_ts_1.Method.POST,
+                method: clients_1.Method.POST,
                 bodyParams,
                 callOptions: options,
             });
@@ -47,7 +47,7 @@ class StakingService {
             const bodyParams = Object.assign(Object.assign({}, request), { portfolioId: undefined, walletId: undefined });
             const response = yield this.client.request({
                 url: `portfolios/${request.portfolioId}/wallets/${request.walletId}/staking/unstake`,
-                method: core_ts_1.Method.POST,
+                method: clients_1.Method.POST,
                 bodyParams,
                 callOptions: options,
             });
@@ -59,7 +59,7 @@ class StakingService {
             const bodyParams = Object.assign(Object.assign({}, request), { portfolioId: undefined });
             const response = yield this.client.request({
                 url: `portfolios/${request.portfolioId}/staking/initiate`,
-                method: core_ts_1.Method.POST,
+                method: clients_1.Method.POST,
                 bodyParams,
                 callOptions: options,
             });
@@ -71,7 +71,7 @@ class StakingService {
             const bodyParams = Object.assign(Object.assign({}, request), { portfolioId: undefined });
             const response = yield this.client.request({
                 url: `portfolios/${request.portfolioId}/staking/unstake`,
-                method: core_ts_1.Method.POST,
+                method: clients_1.Method.POST,
                 bodyParams,
                 callOptions: options,
             });

package/dist/transactions/index.js

@@ -36,7 +36,7 @@ exports.TransactionsService = void 0;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const core_ts_1 = require("@coinbase-sample/core-ts");
+const clients_1 = require("../clients");
 const paginatedResponse_1 = require("../shared/paginatedResponse");
 class TransactionsService {
     constructor(client) {
@@ -91,7 +91,7 @@ class TransactionsService {
             const response = yield this.client.request({
                 url: `portfolios/${request.portfolioId}/wallets/${request.walletId}/conversion`,
                 bodyParams,
-                method: core_ts_1.Method.POST,
+                method: clients_1.Method.POST,
                 callOptions: options,
             });
             return response.data;
@@ -103,7 +103,7 @@ class TransactionsService {
             const response = yield this.client.request({
                 url: `portfolios/${request.portfolioId}/wallets/${request.walletId}/transfers`,
                 bodyParams,
-                method: core_ts_1.Method.POST,
+                method: clients_1.Method.POST,
                 callOptions: options,
             });
             return response.data;
@@ -115,7 +115,7 @@ class TransactionsService {
             const response = yield this.client.request({
                 url: `portfolios/${request.portfolioId}/wallets/${request.walletId}/withdrawals`,
                 bodyParams,
-                method: core_ts_1.Method.POST,
+                method: clients_1.Method.POST,
                 callOptions: options,
             });
             return response.data;
@@ -127,7 +127,7 @@ class TransactionsService {
             const response = yield this.client.request({
                 url: `portfolios/${request.portfolioId}/wallets/${request.walletId}/onchain_transaction`,
                 bodyParams,
-                method: core_ts_1.Method.POST,
+                method: clients_1.Method.POST,
                 callOptions: options,
             });
             return response.data;

package/dist/types/activities/index.d.ts

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { CoinbaseCallOptions } from '@coinbase-sample/core-ts';
-import { CoinbasePrimeClient } from '../client';
+import { IPrimeApiClient, CoinbaseCallOptions } from '../clients';
 import { GetActivityRequest, GetActivityResponse, GetPortfolioActivitiesRequest, GetPortfolioActivityResponse, ListPortfolioActivitiesRequest, ListPortfolioActivitiesResponse, ListEntityActivitiesRequest, ListEntityActivitiesResponse } from './types';
 export interface IActivitiesService {
     getActivity(request: GetActivityRequest): Promise<GetActivityResponse>;
@@ -24,7 +23,7 @@ export interface IActivitiesService {
 }
 export declare class ActivitiesService implements IActivitiesService {
     private client;
-    constructor(client: CoinbasePrimeClient);
+    constructor(client: IPrimeApiClient);
     getActivity(request: GetActivityRequest, options?: CoinbaseCallOptions): Promise<GetActivityResponse>;
     getPortfolioActivity(request: GetPortfolioActivitiesRequest, options?: CoinbaseCallOptions): Promise<GetPortfolioActivityResponse>;
     listEntityActivities(request: ListEntityActivitiesRequest, options?: CoinbaseCallOptions): Promise<ListEntityActivitiesResponse>;

package/dist/types/addressBooks/index.d.ts

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { CoinbaseCallOptions } from '@coinbase-sample/core-ts';
-import { CoinbasePrimeClient } from '../client';
+import { CoinbaseCallOptions, IPrimeApiClient } from '../clients';
 import { ListAddressBooksRequest, ListAddressBooksResponse, CreateAddressBookRequest, CreateAddressBookResponse } from './types';
 export interface IAddressBooksService {
     listAddressBooks(request: ListAddressBooksRequest, options?: CoinbaseCallOptions): Promise<ListAddressBooksResponse>;
@@ -22,7 +21,7 @@ export interface IAddressBooksService {
 }
 export declare class AddressBooksService implements IAddressBooksService {
     private client;
-    constructor(client: CoinbasePrimeClient);
+    constructor(client: IPrimeApiClient);
     listAddressBooks(request: ListAddressBooksRequest, options?: CoinbaseCallOptions): Promise<ListAddressBooksResponse>;
     createAddressBook(request: CreateAddressBookRequest, options?: CoinbaseCallOptions): Promise<CreateAddressBookResponse>;
 }

package/dist/types/allocations/index.d.ts

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { CoinbaseCallOptions } from '@coinbase-sample/core-ts';
-import { CoinbasePrimeClient } from '../client';
+import { CoinbaseCallOptions, IPrimeApiClient } from '../clients';
 import { CreateAllocationRequest, CreateAllocationResponse, CreateNetAllocationRequest, CreateNetAllocationResponse, ListPortfolioAllocationsRequest, ListPortfolioAllocationsResponse, ListNetAllocationsRequest, ListNetAllocationsResponse, GetAllocationRequest, GetAllocationResponse } from './types';
 export interface IAllocationService {
     createAllocation(request: CreateAllocationRequest, options?: CoinbaseCallOptions): Promise<CreateAllocationResponse>;
@@ -25,7 +24,7 @@ export interface IAllocationService {
 }
 export declare class AllocationService implements IAllocationService {
     private client;
-    constructor(client: CoinbasePrimeClient);
+    constructor(client: IPrimeApiClient);
     createAllocation(request: CreateAllocationRequest, options?: CoinbaseCallOptions): Promise<CreateAllocationResponse>;
     createNetAllocation(request: CreateNetAllocationRequest, options?: CoinbaseCallOptions): Promise<CreateNetAllocationResponse>;
     listPortfolioAllocations(request: ListPortfolioAllocationsRequest, options?: CoinbaseCallOptions): Promise<ListPortfolioAllocationsResponse>;

package/dist/types/assets/index.d.ts

@@ -13,14 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { CoinbaseCallOptions } from '@coinbase-sample/core-ts';
-import { CoinbasePrimeClient } from '../client';
+import { IPrimeApiClient, CoinbaseCallOptions } from '../clients';
 import { ListAssetsRequest, ListAssetsResponse } from './types';
 export interface IAssetsService {
     listAssets(request: ListAssetsRequest, options?: CoinbaseCallOptions): Promise<ListAssetsResponse>;
 }
 export declare class AssetsService implements IAssetsService {
     private client;
-    constructor(client: CoinbasePrimeClient);
+    constructor(client: IPrimeApiClient);
     listAssets(request: ListAssetsRequest, options?: CoinbaseCallOptions): Promise<ListAssetsResponse>;
 }

package/dist/types/balances/index.d.ts

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { CoinbaseCallOptions } from '@coinbase-sample/core-ts';
-import { CoinbasePrimeClient } from '../client';
+import { CoinbaseCallOptions, IPrimeApiClient } from '../clients';
 import { GetWalletBalanceRequest, GetWalletBalanceResponse, ListOnchainWalletBalancesRequest, ListOnchainWalletBalancesResponse, ListPortfolioBalancesRequest, ListPortfolioBalancesResponse, ListEntityBalancesRequest, ListEntityBalancesResponse } from './types';
 export interface IBalancesService {
     listPortfolioBalances(request: ListPortfolioBalancesRequest, options?: CoinbaseCallOptions): Promise<ListPortfolioBalancesResponse>;
@@ -24,7 +23,7 @@ export interface IBalancesService {
 }
 export declare class BalancesService implements IBalancesService {
     private client;
-    constructor(client: CoinbasePrimeClient);
+    constructor(client: IPrimeApiClient);
     listPortfolioBalances(request: ListPortfolioBalancesRequest, options?: CoinbaseCallOptions): Promise<ListPortfolioBalancesResponse>;
     getWalletBalance(request: GetWalletBalanceRequest, options?: CoinbaseCallOptions): Promise<GetWalletBalanceResponse>;
     listOnchainWalletBalances(request: ListOnchainWalletBalancesRequest, options?: CoinbaseCallOptions): Promise<ListOnchainWalletBalancesResponse>;

package/dist/types/balances/types.d.ts

@@ -19,7 +19,7 @@ import { GetPortfolioBalancesResponse, GetWalletBalanceResponse as internalGetRe
 import { BasePaginatedRequest, PaginatedResponseMethods } from '../shared/paginatedResponse';
 export type ListPortfolioBalancesRequest = {
     portfolioId: string;
-    symbol: string;
+    symbols?: string[];
     balanceType?: PortfolioBalanceType;
 };
 export type ListPortfolioBalancesResponse = Brand<GetPortfolioBalancesResponse, 'ListPortfolioBalancesResponse'>;