@dynamic-labs-sdk/client 1.25.0 → 1.26.0

package/dist/index.cjs

@@ -1,9 +1,9 @@
-const require_updateAuthFromVerifyResponse = require('./updateAuthFromVerifyResponse-D9kFrAkK.cjs');
-const require_getNetworkProviderFromNetworkId = require('./getNetworkProviderFromNetworkId-CtXKqsri.cjs');
-const require_isDynamicWaasEnabled = require('./isDynamicWaasEnabled-BWvSMhAP.cjs');
-const require_isUserOnboardingComplete = require('./isUserOnboardingComplete-B9vzjs71.cjs');
-const require_getWalletProviderByKey = require('./getWalletProviderByKey-DtcD_nPD.cjs');
-const require_isMfaRequiredForAction = require('./isMfaRequiredForAction-Dr44C3-l.cjs');
+const require_updateAuthFromVerifyResponse = require('./updateAuthFromVerifyResponse-CPOvKWih.cjs');
+const require_getNetworkProviderFromNetworkId = require('./getNetworkProviderFromNetworkId-CSxvdrc9.cjs');
+const require_isDynamicWaasEnabled = require('./isDynamicWaasEnabled-idmeju9B.cjs');
+const require_isUserOnboardingComplete = require('./isUserOnboardingComplete-BfRUVwrT.cjs');
+const require_getWalletProviderByKey = require('./getWalletProviderByKey-BMJ9TcjM.cjs');
+const require_isMfaRequiredForAction = require('./isMfaRequiredForAction-D5o4qznt.cjs');
 let _dynamic_labs_sdk_assert_package_version = require("@dynamic-labs-sdk/assert-package-version");
 let _dynamic_labs_sdk_api_core = require("@dynamic-labs/sdk-api-core");
 let zod_mini = require("zod/mini");
@@ -978,6 +978,7 @@ const createCore = (config) => {
 	});
 	const fetch = config.coreConfig?.fetch ?? createWebFetch();
 	const openDeeplink = config.coreConfig?.openDeeplink ?? createDeeplinkOpener();
+	const subscribeToAppForeground = require_getNetworkProviderFromNetworkId.createAppForegroundSubscriber();
 	const openAuthSession = config.coreConfig?.openAuthSession;
 	const navigate = config.coreConfig?.navigate ?? createNavigationHandler();
 	const state = createObservableState(getInitialState);
@@ -1033,6 +1034,7 @@ const createCore = (config) => {
 		sdkSessionId,
 		state,
 		storage,
+		subscribeToAppForeground,
 		transformers: config.transformers,
 		version: require_updateAuthFromVerifyResponse.version,
 		waas: config.waas
@@ -1158,6 +1160,150 @@ var CheckoutSessionTokenMissingError = class extends require_updateAuthFromVerif
 	}
 };
 
+//#endregion
+//#region src/errors/CoinbaseTransferMfaFailedError.ts
+/**
+* Thrown when a {@link createCoinbaseExchangeTransfer} retry supplies an
+* `mfaCode` that Coinbase rejects -- the two-step verification code was
+* incorrect, or it expired before the retry was submitted. Coinbase's own
+* codes are short-lived, so this is expected to happen occasionally even
+* with correct user input; it does not mean the transfer itself is invalid.
+*
+* Coinbase does not automatically send a new code on this failure -- prompt
+* the user again and retry, which triggers
+* {@link CoinbaseTransferMfaRequiredError} again and, with it, a fresh code.
+*
+* @example
+* ```ts
+* const transferParams = { accountId, amount: 0.5, currency: 'USDC', to };
+* const submitWithMfaCode = (mfaCode: string) =>
+*   createCoinbaseExchangeTransfer({ ...transferParams, mfaCode });
+*
+* try {
+*   await submitWithMfaCode(mfaCode);
+* } catch (error) {
+*   if (error instanceof CoinbaseTransferMfaFailedError) {
+*     // wrong or expired code -- ask the user to try again
+*     await createCoinbaseExchangeTransfer(transferParams);
+*   }
+* }
+* ```
+* @see createCoinbaseExchangeTransfer
+* @see CoinbaseTransferMfaRequiredError
+*/
+var CoinbaseTransferMfaFailedError = class extends require_updateAuthFromVerifyResponse.BaseError {
+	constructor({ cause }) {
+		super({
+			cause,
+			code: "transfer_mfa_failed",
+			docsUrl: null,
+			name: "CoinbaseTransferMfaFailedError",
+			shortMessage: "The Coinbase two-step verification code was incorrect or has expired. Retry createCoinbaseExchangeTransfer with a fresh 'mfaCode'."
+		});
+	}
+};
+
+//#endregion
+//#region src/errors/CoinbaseTransferMfaRequiredError.ts
+/**
+* Thrown when Coinbase rejects a {@link createCoinbaseExchangeTransfer} call
+* because the account holder's two-step verification ("2FA") is required to
+* authorize the transfer. This is unrelated to Dynamic's own step-up auth
+* (see {@link checkStepUpAuth}) -- it is a security requirement enforced by
+* Coinbase itself, on the Coinbase account being transferred from.
+*
+* The first `createCoinbaseExchangeTransfer` call for a transfer
+* automatically triggers Coinbase to send the account holder a verification
+* code (SMS, or push to an authenticator app such as Authy if one is
+* linked). Retry the *same* transfer with `mfaCode` set to that code before
+* it expires. If the code is wrong or has expired, the retry throws
+* {@link CoinbaseTransferMfaFailedError} instead, so a fresh code can be
+* requested and retried again.
+*
+* @example
+* ```ts
+* const transferParams = { accountId, amount: 0.5, currency: 'USDC', to };
+*
+* try {
+*   await createCoinbaseExchangeTransfer(transferParams);
+* } catch (error) {
+*   if (error instanceof CoinbaseTransferMfaRequiredError) {
+*     // Coinbase already sent a code to the account holder -- prompt for it
+*     const mfaCode = await promptUserForCoinbase2faCode();
+*     await createCoinbaseExchangeTransfer({ ...transferParams, mfaCode });
+*   }
+* }
+* ```
+* @see createCoinbaseExchangeTransfer
+* @see CoinbaseTransferMfaFailedError
+*/
+var CoinbaseTransferMfaRequiredError = class extends require_updateAuthFromVerifyResponse.BaseError {
+	constructor({ cause }) {
+		super({
+			cause,
+			code: "transfer_mfa_required",
+			docsUrl: null,
+			name: "CoinbaseTransferMfaRequiredError",
+			shortMessage: "Coinbase requires a two-step verification code to complete this transfer. Coinbase has automatically sent the code to the account holder (SMS or authenticator app) -- retry createCoinbaseExchangeTransfer with 'mfaCode' set to that code before it expires."
+		});
+	}
+};
+
+//#endregion
+//#region src/errors/CoinbaseTravelRuleRequiredError.ts
+/**
+* Thrown when Coinbase rejects a {@link createCoinbaseExchangeTransfer} call
+* because it's missing "Travel Rule" information about the transfer's
+* recipient. The Travel Rule is a regulatory requirement on custodial
+* exchanges (like Coinbase) to collect basic counterparty information above
+* certain transfer thresholds -- which fields are required depends on the
+* sender's and recipient's jurisdictions and the transfer amount, so it can't
+* be predicted client-side; Coinbase reports the exact missing fields on
+* {@link missingFields}.
+*
+* Unlike {@link CoinbaseTransferMfaRequiredError}, retrying does not require
+* waiting for anything from Coinbase -- collect the listed fields (each has a
+* user-facing `description`) and retry the same transfer with
+* `travelRuleData` set.
+*
+* @example
+* ```ts
+* const transferParams = { accountId, amount: 0.5, currency: 'USDC', to };
+*
+* try {
+*   await createCoinbaseExchangeTransfer(transferParams);
+* } catch (error) {
+*   if (error instanceof CoinbaseTravelRuleRequiredError) {
+*     // e.g. [{ name: 'BENEFICIARY_NAME', description: "The recipient's full legal name." }, ...]
+*     console.log(error.missingFields);
+*
+*     const travelRuleData = await promptUserForTravelRuleFields(
+*       error.missingFields
+*     );
+*     await createCoinbaseExchangeTransfer({ ...transferParams, travelRuleData });
+*   }
+* }
+* ```
+* @see createCoinbaseExchangeTransfer
+* @see CoinbaseTravelRuleData
+* @see CoinbaseTravelRuleFieldName
+* @see https://docs.cdp.coinbase.com/coinbase-app/transfer-apis/travel-rule
+*/
+var CoinbaseTravelRuleRequiredError = class extends require_updateAuthFromVerifyResponse.BaseError {
+	missingFields;
+	constructor({ cause, missingFields }) {
+		super({
+			cause,
+			code: "coinbase_travel_rule_required",
+			docsUrl: "https://docs.cdp.coinbase.com/coinbase-app/transfer-apis/travel-rule",
+			metaMessages: missingFields.map(({ name: name$1, description }) => `- ${name$1}: ${description}`),
+			name: "CoinbaseTravelRuleRequiredError",
+			shortMessage: "Coinbase requires additional recipient information (Travel Rule compliance) before this transfer can complete."
+		});
+		this.missingFields = missingFields;
+	}
+};
+
 //#endregion
 //#region src/errors/DeeplinkConnectAndVerifyUnsupportedError.ts
 var DeeplinkConnectAndVerifyUnsupportedError = class extends require_updateAuthFromVerifyResponse.BaseError {
@@ -3970,6 +4116,196 @@ const addCoinbaseOnrampOrderEventListener = ({ listener }, client = require_upda
 	};
 };
 
+//#endregion
+//#region src/modules/funding/coinbase/coinbase.consts.ts
+/**
+* Whether the transfer's destination wallet is self-hosted (controlled
+* directly by its owner, with no custodial exchange in between) or held at
+* another exchange -- required by some jurisdictions' Travel Rule rules, see
+* {@link CoinbaseTravelRuleData}.
+*
+* @example
+* ```typescript
+* const walletType = CoinbaseBeneficiaryWalletType.SelfHosted;
+* ```
+* @see CoinbaseTravelRuleData
+* @see https://docs.cdp.coinbase.com/coinbase-app/transfer-apis/travel-rule
+*/
+const CoinbaseBeneficiaryWalletType = {
+	Exchange: "WALLET_TYPE_EXCHANGE",
+	SelfHosted: "WALLET_TYPE_SELF_HOSTED"
+};
+/**
+* Whether the transfer's destination wallet also belongs to the sender --
+* required by some jurisdictions' Travel Rule rules, see
+* {@link CoinbaseTravelRuleData}.
+*
+* @example
+* ```typescript
+* const isSelfTransfer = CoinbaseIsSelfTransfer.SelfOwned;
+* ```
+* @see CoinbaseTravelRuleData
+* @see https://docs.cdp.coinbase.com/coinbase-app/transfer-apis/travel-rule
+*/
+const CoinbaseIsSelfTransfer = {
+	NotSelfOwned: "IS_SELF_FALSE",
+	SelfOwned: "IS_SELF_TRUE"
+};
+/**
+* The individual Travel Rule fields Coinbase can require on a transfer.
+* Which of these are actually required depends on the sender's and
+* recipient's jurisdictions and the transfer amount -- Coinbase reports the
+* exact list that's missing for a given transfer via
+* {@link CoinbaseTravelRuleRequiredError.missingFields}.
+*
+* @example
+* ```typescript
+* const fieldName = CoinbaseTravelRuleFieldName.BeneficiaryName;
+* ```
+* @see CoinbaseTravelRuleRequiredError
+* @see https://docs.cdp.coinbase.com/coinbase-app/transfer-apis/travel-rule
+*/
+const CoinbaseTravelRuleFieldName = {
+	BeneficiaryAddress: "BENEFICIARY_ADDRESS",
+	BeneficiaryCountry: "BENEFICIARY_COUNTRY",
+	BeneficiaryFinancialInstitution: "BENEFICIARY_FINANCIAL_INSTITUTION",
+	BeneficiaryName: "BENEFICIARY_NAME",
+	BeneficiaryWalletType: "BENEFICIARY_WALLET_TYPE",
+	IsSelf: "IS_SELF",
+	TransferPurpose: "TRANSFER_PURPOSE"
+};
+/**
+* Human-readable description of a {@link CoinbaseTravelRuleFieldName},
+* written to be shown directly to an end user (for example, as helper text
+* next to the form field that collects it).
+*
+* @example
+* ```typescript
+* const description = COINBASE_TRAVEL_RULE_FIELD_DESCRIPTIONS.IS_SELF;
+* // "Whether the destination wallet also belongs to you."
+* ```
+* @see CoinbaseTravelRuleFieldName
+* @see CoinbaseTravelRuleRequiredError
+*/
+const COINBASE_TRAVEL_RULE_FIELD_DESCRIPTIONS = {
+	BENEFICIARY_ADDRESS: "The recipient's postal address.",
+	BENEFICIARY_COUNTRY: "The recipient's country, as an ISO 3166-1 alpha-2 code (e.g. \"US\", \"GB\").",
+	BENEFICIARY_FINANCIAL_INSTITUTION: "The identifier (VASP ID) of the recipient exchange, required when the destination wallet is held at another exchange rather than self-hosted.",
+	BENEFICIARY_NAME: "The recipient's full legal name.",
+	BENEFICIARY_WALLET_TYPE: "Whether the destination wallet is self-hosted (the recipient controls it directly) or held at another exchange.",
+	IS_SELF: "Whether the destination wallet also belongs to you.",
+	TRANSFER_PURPOSE: "The reason for this transfer (e.g. \"Rent\", \"Gift\")."
+};
+
+//#endregion
+//#region src/modules/funding/coinbase/utils/parseCoinbaseTravelRuleMissingFields/parseCoinbaseTravelRuleMissingFields.ts
+/**
+* Coinbase reports missing Travel Rule fields as a bracketed, comma-separated
+* list appended to its error message, e.g. `"... Param:
+* [BENEFICIARY_WALLET_TYPE, BENEFICIARY_NAME]"`.
+*/
+const TRAVEL_RULE_PARAM_LIST_REGEX = /Param:\s*\[([^\]]+)\]/;
+const isCoinbaseTravelRuleFieldName = (name$1) => Object.hasOwn(COINBASE_TRAVEL_RULE_FIELD_DESCRIPTIONS, name$1);
+/**
+* Extracts the list of missing Travel Rule fields from a Coinbase
+* `unknown_transfer_error` message, pairing each field with its user-facing
+* description. Returns an empty array if the message doesn't contain a
+* recognizable Travel Rule field list (i.e. this isn't a Travel Rule error).
+*
+* @param params.message - The raw `error` string from Coinbase's response body.
+* @returns The missing fields, or an empty array if none were found.
+* @example
+* ```typescript
+* const missingFields = parseCoinbaseTravelRuleMissingFields({
+*   message: 'Incomplete travel rules information provided. Param: [BENEFICIARY_NAME, IS_SELF]',
+* });
+* // [
+* //   { name: 'BENEFICIARY_NAME', description: "The recipient's full legal name." },
+* //   { name: 'IS_SELF', description: 'Whether the destination wallet also belongs to you.' },
+* // ]
+* ```
+* @see CoinbaseTravelRuleRequiredError
+* @notInstrumented
+*/
+const parseCoinbaseTravelRuleMissingFields = ({ message }) => {
+	const match = TRAVEL_RULE_PARAM_LIST_REGEX.exec(message);
+	if (!match) return [];
+	return match[1].split(",").map((name$1) => name$1.trim()).filter(isCoinbaseTravelRuleFieldName).map((name$1) => ({
+		description: COINBASE_TRAVEL_RULE_FIELD_DESCRIPTIONS[name$1],
+		name: name$1
+	}));
+};
+
+//#endregion
+//#region src/modules/funding/coinbase/createCoinbaseExchangeTransfer/createCoinbaseExchangeTransfer.ts
+/**
+* Creates a Coinbase exchange transfer to send crypto from a Coinbase account to an external address.
+*
+* Coinbase may reject the transfer for reasons that require a second attempt
+* rather than a hard failure:
+* - {@link CoinbaseTransferMfaRequiredError} / {@link CoinbaseTransferMfaFailedError} --
+*   Coinbase's own two-step verification on the sending account.
+* - {@link CoinbaseTravelRuleRequiredError} -- missing recipient information
+*   required by regulation for this transfer's jurisdictions/amount.
+*
+* @param transferParams - The parameters for the transfer including accountId.
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns A promise resolving to the created exchange transfer.
+* @throws {CoinbaseTransferMfaRequiredError} When the API requires MFA for the transfer.
+* @throws {CoinbaseTransferMfaFailedError} When the provided MFA code is rejected.
+* @throws {CoinbaseTravelRuleRequiredError} When Coinbase requires additional recipient information for the transfer.
+* @throws {APIError} For any other API error returned by the exchange transfer request.
+* @example
+* ```typescript
+* // Include any known recipient info upfront -- see travelRuleData below for why.
+* const transferParams = {
+*   accountId: accounts[0].id,
+*   amount: 0.5,
+*   currency: 'USDC',
+*   to: '0x71C7656EC7ab88b098defB751B7401B5f6d8976F',
+*   travelRuleData: { beneficiaryName: 'Jane Doe', beneficiaryCountry: 'US' },
+* };
+*
+* try {
+*   const transfer = await createCoinbaseExchangeTransfer(transferParams);
+* } catch (error) {
+*   if (error instanceof CoinbaseTravelRuleRequiredError) {
+*     const travelRuleData = await promptUserForTravelRuleFields(error.missingFields);
+*     await createCoinbaseExchangeTransfer({ ...transferParams, travelRuleData });
+*   }
+* }
+* ```
+* @see getCoinbaseAccounts
+* @see CoinbaseTransferMfaRequiredError
+* @see CoinbaseTravelRuleRequiredError
+* @notInstrumented
+*/
+const createCoinbaseExchangeTransfer = async (transferParams, client = require_updateAuthFromVerifyResponse.getDefaultClient()) => {
+	const core = require_updateAuthFromVerifyResponse.getCore(client);
+	const apiClient = require_updateAuthFromVerifyResponse.createApiClient({ includeMfaToken: true }, client);
+	const { accountId, ...createExchangeTransferRequest } = transferParams;
+	try {
+		return await apiClient.postExchangeAccountTransfer({
+			accountId,
+			createExchangeTransferRequest,
+			environmentId: core.environmentId,
+			exchangeKey: _dynamic_labs_sdk_api_core.ExchangeKeyEnum.Coinbase
+		});
+	} catch (error) {
+		if (!(error instanceof require_updateAuthFromVerifyResponse.APIError)) throw error;
+		if (error.code === "transfer_mfa_required") throw new CoinbaseTransferMfaRequiredError({ cause: error });
+		if (error.code === "transfer_mfa_failed") throw new CoinbaseTransferMfaFailedError({ cause: error });
+		if (error.code === "unknown_transfer_error") {
+			const missingFields = parseCoinbaseTravelRuleMissingFields({ message: error.message });
+			if (missingFields.length > 0) throw new CoinbaseTravelRuleRequiredError({
+				cause: error,
+				missingFields
+			});
+		}
+		throw error;
+	}
+};
+
 //#endregion
 //#region src/modules/funding/coinbase/getMissingVerificationForCoinbaseOnrampOrder/getMissingVerificationForCoinbaseOnrampOrder.ts
 /**
@@ -4091,6 +4427,59 @@ const __createCoinbaseOnrampOrder_wrapped = require_updateAuthFromVerifyResponse
 	}
 });
 
+//#endregion
+//#region src/utils/assertChainName/assertChainName.ts
+const CHAIN_ENUM_VALUES = Object.values(_dynamic_labs_sdk_api_core.ChainEnum);
+/**
+* Validates that a chain name is a recognized ChainEnum value.
+*
+* Throws an {@link InvalidParamError} when the value is undefined or is not a
+* valid chain name.
+*
+* @category Extension Development
+*
+* @param chainName - The chain name to validate.
+* @throws {InvalidParamError} When chainName is undefined or not a valid ChainEnum value.
+* @notInstrumented
+*/
+const assertChainName = (chainName) => {
+	if (chainName === void 0) throw new require_updateAuthFromVerifyResponse.InvalidParamError("chainName is required");
+	if (!CHAIN_ENUM_VALUES.includes(chainName)) throw new require_updateAuthFromVerifyResponse.InvalidParamError(`Invalid chainName: ${chainName}`);
+};
+
+//#endregion
+//#region src/modules/funding/coinbase/getCoinbaseAccounts/getCoinbaseAccounts.ts
+/**
+* Gets the Coinbase accounts (balances) for the authenticated user.
+*
+* @param [params] GetCoinbaseAccountsParams - Optional filters for the accounts.
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns A promise resolving to an array of Coinbase accounts with balances.
+* @throws {InvalidParamError} When chainName is not a valid ChainEnum value or networkId is a non-integer or negative number.
+* @example
+* ```typescript
+* const accounts = await getCoinbaseAccounts({ chainName: 'EVM' });
+* console.log(accounts[0].balances);
+* ```
+* @see createCoinbaseExchangeTransfer
+* @see GetCoinbaseAccountsParams
+* @notInstrumented
+*/
+const getCoinbaseAccounts = async (params, client = require_updateAuthFromVerifyResponse.getDefaultClient()) => {
+	const core = require_updateAuthFromVerifyResponse.getCore(client);
+	const apiClient = require_updateAuthFromVerifyResponse.createApiClient({ includeMfaToken: true }, client);
+	const chainName = params?.chainName;
+	if (chainName !== void 0) assertChainName(chainName);
+	const networkId = params?.networkId;
+	if (networkId !== void 0 && (!Number.isInteger(networkId) || networkId < 0)) throw new require_updateAuthFromVerifyResponse.InvalidParamError(`Invalid networkId: ${networkId}`);
+	return await apiClient.getUserAccounts({
+		chainName,
+		environmentId: core.environmentId,
+		exchangeKey: _dynamic_labs_sdk_api_core.ExchangeKeyEnum.Coinbase,
+		networkId
+	});
+};
+
 //#endregion
 //#region src/modules/funding/coinbase/getCoinbaseBuyUrl/getCoinbaseBuyUrl.ts
 /**
@@ -9201,9 +9590,16 @@ const parseUserAgent = ({ userAgent }) => {
 
 //#endregion
 exports.BaseError = require_updateAuthFromVerifyResponse.BaseError;
+exports.COINBASE_TRAVEL_RULE_FIELD_DESCRIPTIONS = COINBASE_TRAVEL_RULE_FIELD_DESCRIPTIONS;
 exports.CaptchaProviderEnum = CaptchaProviderEnum;
 exports.CheckoutSessionTokenMissingError = CheckoutSessionTokenMissingError;
 exports.ClientAlreadyInitializedError = ClientAlreadyInitializedError;
+exports.CoinbaseBeneficiaryWalletType = CoinbaseBeneficiaryWalletType;
+exports.CoinbaseIsSelfTransfer = CoinbaseIsSelfTransfer;
+exports.CoinbaseTransferMfaFailedError = CoinbaseTransferMfaFailedError;
+exports.CoinbaseTransferMfaRequiredError = CoinbaseTransferMfaRequiredError;
+exports.CoinbaseTravelRuleFieldName = CoinbaseTravelRuleFieldName;
+exports.CoinbaseTravelRuleRequiredError = CoinbaseTravelRuleRequiredError;
 exports.DeeplinkConnectAndVerifyUnsupportedError = DeeplinkConnectAndVerifyUnsupportedError;
 exports.DeviceRegistrationIdentityMismatchError = DeviceRegistrationIdentityMismatchError;
 exports.FeeEstimationFailedError = FeeEstimationFailedError;
@@ -9257,6 +9653,7 @@ Object.defineProperty(exports, 'TokenScope', {
   }
 });
 exports.TokenSwapError = TokenSwapError;
+exports.TransactionBroadcastError = require_isDynamicWaasEnabled.TransactionBroadcastError;
 exports.UnauthorizedError = require_updateAuthFromVerifyResponse.UnauthorizedError;
 exports.UnavailableInServerSideError = require_getNetworkProviderFromNetworkId.UnavailableInServerSideError;
 exports.UnrecognizedNetworkError = UnrecognizedNetworkError;
@@ -9299,6 +9696,7 @@ exports.connectAndVerifyWithWalletProvider = __connectAndVerifyWithWalletProvide
 exports.connectWithWalletProvider = __connectWithWalletProvider_wrapped;
 exports.consumeMfaToken = require_isMfaRequiredForAction.__consumeMfaToken_wrapped;
 exports.createCheckoutTransaction = __createCheckoutTransaction_wrapped;
+exports.createCoinbaseExchangeTransfer = createCoinbaseExchangeTransfer;
 exports.createCoinbaseOnrampOrder = __createCoinbaseOnrampOrder_wrapped;
 exports.createCryptoDotComPayment = __createCryptoDotComPayment_wrapped;
 exports.createDynamicClient = __createDynamicClient_wrapped;
@@ -9323,6 +9721,7 @@ exports.getBalances = getBalances;
 exports.getCaptchaSettings = getCaptchaSettings;
 exports.getCheckoutTransaction = getCheckoutTransaction;
 exports.getCheckoutTransactionQuote = getCheckoutTransactionQuote;
+exports.getCoinbaseAccounts = getCoinbaseAccounts;
 exports.getCoinbaseBuyUrl = getCoinbaseBuyUrl;
 exports.getConnectedAddresses = getConnectedAddresses;
 exports.getDefaultClient = require_updateAuthFromVerifyResponse.getDefaultClient;