@coinbase/cdp-sdk
Version:
SDK for interacting with the Coinbase Developer Platform Wallet API
472 lines • 22.2 kB
JavaScript
"use strict";
/**
* @module Accounts
*/
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.AccountsClient = void 0;
const BaseClient_js_1 = require("../../../../BaseClient.js");
const headers_js_1 = require("../../../../core/headers.js");
const core = __importStar(require("../../../../core/index.js"));
const environments = __importStar(require("../../../../environments.js"));
const handleNonStatusCodeError_js_1 = require("../../../../errors/handleNonStatusCodeError.js");
const errors = __importStar(require("../../../../errors/index.js"));
const CoinbaseApi = __importStar(require("../../../index.js"));
/**
* The Accounts APIs enable developers to create and manage accounts for their Entity and for their Customers. 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. Use `GET /v2/accounts/{accountId}/products` to discover the spot products available to trade for an account (valid `productId`s to pass when creating an order).
*/
class AccountsClient {
_options;
constructor(options) {
this._options = (0, BaseClient_js_1.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, owner, type: type_ } = request;
const _queryParams = {
pageSize,
pageToken,
owner,
type: type_ != null ? type_ : undefined,
};
const _authRequest = await this._options.authProvider.getAuthRequest({
endpointMetadata: _metadata,
clientOptions: this._options,
request: {
method: "GET",
},
});
const _headers = (0, headers_js_1.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)
.add("owner", _queryParams.owner, { style: "comma" })
.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 (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/v2/accounts");
}
/**
* Create an account. Two ownership modes are supported:
*
* - **Entity-owned**: when `owner` is omitted, the account is owned by the
* Entity making the request. Returns an account with `owner: entity_<uuid>`.
* Omit `compliance`; it has no effect for Entity-owned accounts.
*
* - **Customer-owned**: pass a Customer ID as `owner`
* (e.g. `customer_af2937b0-9846-4fe7-bfe9-ccc22d935114`). The Customer
* must have the `custodyCrypto`, `custodyFiat`, and `custodyStablecoin`
* capabilities enabled, otherwise the request is rejected with
* `customer_not_authorized` (HTTP 403). `compliance.requesterIpAddress`
* is required; use the IP address of the end-customer who initiated the
* request (not the partner server's IP).
*
* @param {CoinbaseApi.CreateAccountRequest} request
* @param {AccountsClient.RequestOptions} requestOptions - Request-specific configuration.
*
* @throws CoinbaseApi.BadRequestError
* @throws CoinbaseApi.ForbiddenError
* @throws CoinbaseApi.UnprocessableEntityError
* @throws CoinbaseApi.ServiceUnavailableError
*
* @example
* ```ts
* await client.accounts.createAccount({
* idempotencyKey: "8e03978e-40d5-43e8-bc93-6894a57f9324",
* name: "My Business Account"
* })
* ```
*
* @example
* ```ts
* await client.accounts.createAccount({
* idempotencyKey: "8e03978e-40d5-43e8-bc93-6894a57f9324",
* owner: "customer_af2937b0-9846-4fe7-bfe9-ccc22d935114",
* name: "ABC XYZ Customer Account",
* compliance: {
* requesterIpAddress: "203.0.113.42"
* }
* })
* ```
*/
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 = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, (0, headers_js_1.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 403:
throw new CoinbaseApi.ForbiddenError(_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 (0, handleNonStatusCodeError_js_1.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 = (0, headers_js_1.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 (0, handleNonStatusCodeError_js_1.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.ConflictError
* @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 = (0, headers_js_1.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 409:
throw new CoinbaseApi.ConflictError(_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 (0, handleNonStatusCodeError_js_1.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 = (0, headers_js_1.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 (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/v2/accounts/{accountId}/balances/{asset}");
}
}
exports.AccountsClient = AccountsClient;
//# sourceMappingURL=Client.js.map