@coinbase/cdp-sdk
Version:
SDK for interacting with the Coinbase Developer Platform Wallet API
440 lines • 20.6 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. 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.
*/
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, 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 = (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)
.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 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 = (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 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.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 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