@coinbase/cdp-sdk
Version:
SDK for interacting with the Coinbase Developer Platform Wallet API
403 lines • 18.7 kB
JavaScript
/**
* @module Accounts
*/
import { normalizeClientOptionsWithAuth } from "../../../../BaseClient.js";
import { mergeHeaders, mergeOnlyDefinedHeaders } from "../../../../core/headers.js";
import * as core from "../../../../core/index.js";
import * as environments from "../../../../environments.js";
import { handleNonStatusCodeError } from "../../../../errors/handleNonStatusCodeError.js";
import * as errors from "../../../../errors/index.js";
import * as CoinbaseApi from "../../../index.js";
/**
* The Accounts APIs enable developers to create and manage accounts for their Entity. An Account is a container that holds assets and can be used for transacting. Accounts can be of different types including entity accounts, prime accounts, and business accounts. Support for Customer-owned accounts is in development.
*/
export class AccountsClient {
_options;
constructor(options) {
this._options = normalizeClientOptionsWithAuth(options);
}
/**
* List all accounts. The API will return all accounts that the API Key has Permissions to access. You can filter the results by using query parameters, which will be treated as a single conjunction (i.e. AND). Results are sorted by creation date in descending order (newest first).
*
* @param {CoinbaseApi.ListAccountsRequest} request
* @param {AccountsClient.RequestOptions} requestOptions - Request-specific configuration.
*
* @throws CoinbaseApi.BadRequestError
*
* @example
* ```ts
* await client.accounts.listAccounts({
* pageToken: "eyJsYXN0X2lkIjogImFiYzEyMyIsICJ0aW1lc3RhbXAiOiAxNzA3ODIzNzAxfQ=="
* })
* ```
*/
listAccounts(request = {}, requestOptions) {
return core.HttpResponsePromise.fromPromise(this.__listAccounts(request, requestOptions));
}
async __listAccounts(request = {}, requestOptions) {
const _metadata = {
security: [{ apiKeyAuth: [] }],
method: "GET",
path: "v2/accounts",
operationId: "endpoint_accounts.listAccounts",
};
const { pageSize, pageToken, type: type_ } = request;
const _queryParams = {
pageSize,
pageToken,
type: type_ != null ? type_ : undefined,
};
const _authRequest = await this._options.authProvider.getAuthRequest({
endpointMetadata: _metadata,
clientOptions: this._options,
request: {
method: "GET",
},
});
const _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
const _response = await core.fetcher({
url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
(await core.Supplier.get(this._options.environment)) ??
environments.CoinbaseApiEnvironment.Default, "v2/accounts"),
method: "GET",
headers: _headers,
queryString: core.url
.queryBuilder()
.addMany(_queryParams)
.mergeAdditional(requestOptions?.queryParams)
.build(),
timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
abortSignal: requestOptions?.abortSignal,
endpointMetadata: _metadata,
fetchFn: this._options?.fetch,
logging: this._options.logging,
});
if (_response.ok) {
return { data: _response.body, rawResponse: _response.rawResponse };
}
if (_response.error.reason === "status-code") {
switch (_response.error.statusCode) {
case 400:
throw new CoinbaseApi.BadRequestError(_response.error.body, _response.rawResponse);
default:
throw new errors.CoinbaseApiError({
statusCode: _response.error.statusCode,
body: _response.error.body,
rawResponse: _response.rawResponse,
});
}
}
return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v2/accounts");
}
/**
* Create an account for your Entity. Support for creating Customer-owned accounts is in development.
*
* @param {CoinbaseApi.CreateAccountRequest} request
* @param {AccountsClient.RequestOptions} requestOptions - Request-specific configuration.
*
* @throws CoinbaseApi.BadRequestError
* @throws CoinbaseApi.UnprocessableEntityError
* @throws CoinbaseApi.ServiceUnavailableError
*
* @example
* ```ts
* await client.accounts.createAccount({
* idempotencyKey: "8e03978e-40d5-43e8-bc93-6894a57f9324",
* name: "My Business Account"
* })
* ```
*/
createAccount(request = {}, requestOptions) {
return core.HttpResponsePromise.fromPromise(this.__createAccount(request, requestOptions));
}
async __createAccount(request = {}, requestOptions) {
const _metadata = {
security: [{ apiKeyAuth: [] }],
method: "POST",
path: "v2/accounts",
operationId: "endpoint_accounts.createAccount",
headers: ["X-Idempotency-Key"],
};
const { idempotencyKey, ..._body } = request;
const _authRequest = await this._options.authProvider.getAuthRequest({
endpointMetadata: _metadata,
clientOptions: this._options,
request: {
method: "POST",
body: _body,
},
});
const _headers = mergeHeaders(_authRequest.headers, this._options?.headers, mergeOnlyDefinedHeaders({ "X-Idempotency-Key": idempotencyKey }), requestOptions?.headers);
const _response = await core.fetcher({
url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
(await core.Supplier.get(this._options.environment)) ??
environments.CoinbaseApiEnvironment.Default, "v2/accounts"),
method: "POST",
headers: _headers,
contentType: "application/json",
queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
requestType: "json",
body: _body,
timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
abortSignal: requestOptions?.abortSignal,
endpointMetadata: _metadata,
fetchFn: this._options?.fetch,
logging: this._options.logging,
});
if (_response.ok) {
return { data: _response.body, rawResponse: _response.rawResponse };
}
if (_response.error.reason === "status-code") {
switch (_response.error.statusCode) {
case 400:
throw new CoinbaseApi.BadRequestError(_response.error.body, _response.rawResponse);
case 422:
throw new CoinbaseApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
case 503:
throw new CoinbaseApi.ServiceUnavailableError(_response.error.body, _response.rawResponse);
default:
throw new errors.CoinbaseApiError({
statusCode: _response.error.statusCode,
body: _response.error.body,
rawResponse: _response.rawResponse,
});
}
}
return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v2/accounts");
}
/**
* Get an account by its ID.
*
* @param {CoinbaseApi.GetAccountByIdRequest} request
* @param {AccountsClient.RequestOptions} requestOptions - Request-specific configuration.
*
* @throws CoinbaseApi.BadRequestError
* @throws CoinbaseApi.NotFoundError
*
* @example
* ```ts
* await client.accounts.getAccountById({
* accountId: "account_af2937b0-9846-4fe7-bfe9-ccc22d935114"
* })
* ```
*/
getAccountById(request, requestOptions) {
return core.HttpResponsePromise.fromPromise(this.__getAccountById(request, requestOptions));
}
async __getAccountById(request, requestOptions) {
const _metadata = {
security: [{ apiKeyAuth: [] }],
method: "GET",
path: "v2/accounts/{accountId}",
operationId: "endpoint_accounts.getAccountById",
};
const { accountId } = request;
const _authRequest = await this._options.authProvider.getAuthRequest({
endpointMetadata: _metadata,
clientOptions: this._options,
request: {
method: "GET",
},
});
const _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
const _response = await core.fetcher({
url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
(await core.Supplier.get(this._options.environment)) ??
environments.CoinbaseApiEnvironment.Default, `v2/accounts/${core.url.encodePathParam(accountId)}`),
method: "GET",
headers: _headers,
queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
abortSignal: requestOptions?.abortSignal,
endpointMetadata: _metadata,
fetchFn: this._options?.fetch,
logging: this._options.logging,
});
if (_response.ok) {
return { data: _response.body, rawResponse: _response.rawResponse };
}
if (_response.error.reason === "status-code") {
switch (_response.error.statusCode) {
case 400:
throw new CoinbaseApi.BadRequestError(_response.error.body, _response.rawResponse);
case 404:
throw new CoinbaseApi.NotFoundError(_response.error.body, _response.rawResponse);
default:
throw new errors.CoinbaseApiError({
statusCode: _response.error.statusCode,
body: _response.error.body,
rawResponse: _response.rawResponse,
});
}
}
return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v2/accounts/{accountId}");
}
/**
* List the balances for an account. Results are sorted by native-fiat equivalent balance in descending order.
*
* @param {CoinbaseApi.ListBalancesRequest} request
* @param {AccountsClient.RequestOptions} requestOptions - Request-specific configuration.
*
* @throws CoinbaseApi.BadRequestError
* @throws CoinbaseApi.UnauthorizedError
* @throws CoinbaseApi.NotFoundError
* @throws CoinbaseApi.InternalServerError
* @throws CoinbaseApi.ServiceUnavailableError
*
* @example
* ```ts
* await client.accounts.listBalances({
* accountId: "account_af2937b0-9846-4fe7-bfe9-ccc22d935114",
* pageToken: "eyJsYXN0X2lkIjogImFiYzEyMyIsICJ0aW1lc3RhbXAiOiAxNzA3ODIzNzAxfQ=="
* })
* ```
*/
listBalances(request, requestOptions) {
return core.HttpResponsePromise.fromPromise(this.__listBalances(request, requestOptions));
}
async __listBalances(request, requestOptions) {
const _metadata = {
security: [{ apiKeyAuth: [] }],
method: "GET",
path: "v2/accounts/{accountId}/balances",
operationId: "endpoint_accounts.listBalances",
};
const { accountId, pageSize, pageToken } = request;
const _queryParams = {
pageSize,
pageToken,
};
const _authRequest = await this._options.authProvider.getAuthRequest({
endpointMetadata: _metadata,
clientOptions: this._options,
request: {
method: "GET",
},
});
const _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
const _response = await core.fetcher({
url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
(await core.Supplier.get(this._options.environment)) ??
environments.CoinbaseApiEnvironment.Default, `v2/accounts/${core.url.encodePathParam(accountId)}/balances`),
method: "GET",
headers: _headers,
queryString: core.url
.queryBuilder()
.addMany(_queryParams)
.mergeAdditional(requestOptions?.queryParams)
.build(),
timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
abortSignal: requestOptions?.abortSignal,
endpointMetadata: _metadata,
fetchFn: this._options?.fetch,
logging: this._options.logging,
});
if (_response.ok) {
return { data: _response.body, rawResponse: _response.rawResponse };
}
if (_response.error.reason === "status-code") {
switch (_response.error.statusCode) {
case 400:
throw new CoinbaseApi.BadRequestError(_response.error.body, _response.rawResponse);
case 401:
throw new CoinbaseApi.UnauthorizedError(_response.error.body, _response.rawResponse);
case 404:
throw new CoinbaseApi.NotFoundError(_response.error.body, _response.rawResponse);
case 500:
throw new CoinbaseApi.InternalServerError(_response.error.body, _response.rawResponse);
case 503:
throw new CoinbaseApi.ServiceUnavailableError(_response.error.body, _response.rawResponse);
default:
throw new errors.CoinbaseApiError({
statusCode: _response.error.statusCode,
body: _response.error.body,
rawResponse: _response.rawResponse,
});
}
}
return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v2/accounts/{accountId}/balances");
}
/**
* Get the balance for an account by asset.
*
* @param {CoinbaseApi.GetBalanceByAssetRequest} request
* @param {AccountsClient.RequestOptions} requestOptions - Request-specific configuration.
*
* @throws CoinbaseApi.BadRequestError
* @throws CoinbaseApi.UnauthorizedError
* @throws CoinbaseApi.NotFoundError
* @throws CoinbaseApi.InternalServerError
* @throws CoinbaseApi.ServiceUnavailableError
*
* @example
* ```ts
* await client.accounts.getBalanceByAsset({
* accountId: "account_af2937b0-9846-4fe7-bfe9-ccc22d935114",
* asset: "usd"
* })
* ```
*/
getBalanceByAsset(request, requestOptions) {
return core.HttpResponsePromise.fromPromise(this.__getBalanceByAsset(request, requestOptions));
}
async __getBalanceByAsset(request, requestOptions) {
const _metadata = {
security: [{ apiKeyAuth: [] }],
method: "GET",
path: "v2/accounts/{accountId}/balances/{asset}",
operationId: "endpoint_accounts.getBalanceByAsset",
};
const { accountId, asset } = request;
const _authRequest = await this._options.authProvider.getAuthRequest({
endpointMetadata: _metadata,
clientOptions: this._options,
request: {
method: "GET",
},
});
const _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
const _response = await core.fetcher({
url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
(await core.Supplier.get(this._options.environment)) ??
environments.CoinbaseApiEnvironment.Default, `v2/accounts/${core.url.encodePathParam(accountId)}/balances/${core.url.encodePathParam(asset)}`),
method: "GET",
headers: _headers,
queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
abortSignal: requestOptions?.abortSignal,
endpointMetadata: _metadata,
fetchFn: this._options?.fetch,
logging: this._options.logging,
});
if (_response.ok) {
return { data: _response.body, rawResponse: _response.rawResponse };
}
if (_response.error.reason === "status-code") {
switch (_response.error.statusCode) {
case 400:
throw new CoinbaseApi.BadRequestError(_response.error.body, _response.rawResponse);
case 401:
throw new CoinbaseApi.UnauthorizedError(_response.error.body, _response.rawResponse);
case 404:
throw new CoinbaseApi.NotFoundError(_response.error.body, _response.rawResponse);
case 500:
throw new CoinbaseApi.InternalServerError(_response.error.body, _response.rawResponse);
case 503:
throw new CoinbaseApi.ServiceUnavailableError(_response.error.body, _response.rawResponse);
default:
throw new errors.CoinbaseApiError({
statusCode: _response.error.statusCode,
body: _response.error.body,
rawResponse: _response.rawResponse,
});
}
}
return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v2/accounts/{accountId}/balances/{asset}");
}
}
//# sourceMappingURL=Client.js.map