@stacks/blockchain-api-client 1.0.4 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stacks/blockchain-api-client",
-  "version": "1.0.4",
+  "version": "2.0.0",
   "access": "public",
   "description": "Client for the Stacks Blockchain API",
   "homepage": "https://github.com/hirosystems/stacks-blockchain-api/tree/master/client#readme",
@@ -57,7 +57,7 @@
     "eslint": "^7.25.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-plugin-prettier": "^3.4.0",
-    "http-server": "^0.12.3",
+    "http-server": "^14.0.0",
     "microbundle": "^0.13.0",
     "prettier": "^2.2.1",
     "rimraf": "^3.0.2",

package/src/generated/.openapi-generator/FILES

@@ -58,6 +58,8 @@ models/GetRawTransactionResult.ts
 models/GetStxSupplyLegacyFormatResponse.ts
 models/GetStxSupplyResponse.ts
 models/InboundStxTransfer.ts
+models/InlineObject.ts
+models/InlineObject1.ts
 models/InlineResponse200.ts
 models/MapEntryResponse.ts
 models/MempoolTransactionListResponse.ts
@@ -68,7 +70,10 @@ models/NetworkBlockTimesResponse.ts
 models/NetworkBlockTimesResponseMainnet.ts
 models/NetworkIdentifier.ts
 models/NftEvent.ts
+models/NonFungibleTokenHistoryEventList.ts
+models/NonFungibleTokenHoldingsList.ts
 models/NonFungibleTokenMetadata.ts
+models/NonFungibleTokenMintList.ts
 models/NonFungibleTokensMetadataList.ts
 models/OtherTransactionIdentifier.ts
 models/PostCoreNodeTransactionsError.ts

package/src/generated/apis/AccountsApi.ts

@@ -83,6 +83,8 @@ export interface GetAccountNftRequest {
 
 export interface GetAccountNoncesRequest {
     principal: string;
+    blockHeight?: number;
+    blockHash?: string;
 }
 
 export interface GetAccountStxBalanceRequest {
@@ -199,7 +201,7 @@ export interface AccountsApiInterface {
     getAccountInfo(requestParameters: GetAccountInfoRequest, initOverrides?: RequestInit): Promise<AccountDataResponse>;
 
     /**
-     * Retrieves a list of all nfts owned by an address, contains the clarity value of the identifier of the nft 
+     * **NOTE:** This endpoint is deprecated in favor of [Non-Fungible Token holdings](#operation/get_nft_holdings).  Retrieves a list of all nfts owned by an address, contains the clarity value of the identifier of the nft. 
      * @summary Get nft events
      * @param {string} principal Stacks address or a Contract identifier (e.g. &#x60;SP31DA6FTSJX2WGTZ69SFY11BH51NZMB0ZW97B5P0.get-info&#x60;)
      * @param {number} [limit] number of items to return
@@ -213,7 +215,7 @@ export interface AccountsApiInterface {
     getAccountNftRaw(requestParameters: GetAccountNftRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<AddressNftListResponse>>;
 
     /**
-     * Retrieves a list of all nfts owned by an address, contains the clarity value of the identifier of the nft 
+     * **NOTE:** This endpoint is deprecated in favor of [Non-Fungible Token holdings](#operation/get_nft_holdings).  Retrieves a list of all nfts owned by an address, contains the clarity value of the identifier of the nft. 
      * Get nft events
      */
     getAccountNft(requestParameters: GetAccountNftRequest, initOverrides?: RequestInit): Promise<AddressNftListResponse>;
@@ -222,6 +224,8 @@ export interface AccountsApiInterface {
      * Retrieves the latest nonce values used by an account by inspecting the mempool, microblock transactions, and anchored transactions.
      * @summary Get the latest nonce used by an account
      * @param {string} principal Stacks address (e.g. &#x60;SP31DA6FTSJX2WGTZ69SFY11BH51NZMB0ZW97B5P0&#x60;)
+     * @param {number} [blockHeight] Optionally get the nonce at a given block height
+     * @param {string} [blockHash] Optionally get the nonce at a given block hash
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof AccountsApiInterface
@@ -499,7 +503,7 @@ export class AccountsApi extends runtime.BaseAPI implements AccountsApiInterface
     }
 
     /**
-     * Retrieves a list of all nfts owned by an address, contains the clarity value of the identifier of the nft 
+     * **NOTE:** This endpoint is deprecated in favor of [Non-Fungible Token holdings](#operation/get_nft_holdings).  Retrieves a list of all nfts owned by an address, contains the clarity value of the identifier of the nft. 
      * Get nft events
      */
     async getAccountNftRaw(requestParameters: GetAccountNftRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<AddressNftListResponse>> {
@@ -538,7 +542,7 @@ export class AccountsApi extends runtime.BaseAPI implements AccountsApiInterface
     }
 
     /**
-     * Retrieves a list of all nfts owned by an address, contains the clarity value of the identifier of the nft 
+     * **NOTE:** This endpoint is deprecated in favor of [Non-Fungible Token holdings](#operation/get_nft_holdings).  Retrieves a list of all nfts owned by an address, contains the clarity value of the identifier of the nft. 
      * Get nft events
      */
     async getAccountNft(requestParameters: GetAccountNftRequest, initOverrides?: RequestInit): Promise<AddressNftListResponse> {
@@ -557,6 +561,14 @@ export class AccountsApi extends runtime.BaseAPI implements AccountsApiInterface
 
         const queryParameters: any = {};
 
+        if (requestParameters.blockHeight !== undefined) {
+            queryParameters['block_height'] = requestParameters.blockHeight;
+        }
+
+        if (requestParameters.blockHash !== undefined) {
+            queryParameters['block_hash'] = requestParameters.blockHash;
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({

package/src/generated/apis/FaucetsApi.ts

@@ -15,6 +15,12 @@
 
 import * as runtime from '../runtime';
 import {
+    InlineObject,
+    InlineObjectFromJSON,
+    InlineObjectToJSON,
+    InlineObject1,
+    InlineObject1FromJSON,
+    InlineObject1ToJSON,
     RunFaucetResponse,
     RunFaucetResponseFromJSON,
     RunFaucetResponseToJSON,
@@ -22,11 +28,13 @@ import {
 
 export interface RunFaucetBtcRequest {
     address: string;
+    inlineObject1?: InlineObject1;
 }
 
 export interface RunFaucetStxRequest {
     address: string;
     stacking?: boolean;
+    inlineObject?: InlineObject;
 }
 
 /**
@@ -37,9 +45,10 @@ export interface RunFaucetStxRequest {
  */
 export interface FaucetsApiInterface {
     /**
-     * Retrieves BTC tokens into your TestNet BTC address.
-     * @summary Get BTC tokens
-     * @param {string} address BTC address
+     * Add 1 BTC token to the specified testnet BTC address.  The endpoint returns the transaction ID, which you can use to view the transaction in a testnet Bitcoin block explorer. The tokens are delivered once the transaction has been included in a block.  **Note:** This is a testnet only endpoint. This endpoint will not work on the mainnet. 
+     * @summary Add testnet BTC tokens to address
+     * @param {string} address A valid testnet BTC address
+     * @param {InlineObject1} [inlineObject1] 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof FaucetsApiInterface
@@ -47,16 +56,17 @@ export interface FaucetsApiInterface {
     runFaucetBtcRaw(requestParameters: RunFaucetBtcRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<RunFaucetResponse>>;
 
     /**
-     * Retrieves BTC tokens into your TestNet BTC address.
-     * Get BTC tokens
+     * Add 1 BTC token to the specified testnet BTC address.  The endpoint returns the transaction ID, which you can use to view the transaction in a testnet Bitcoin block explorer. The tokens are delivered once the transaction has been included in a block.  **Note:** This is a testnet only endpoint. This endpoint will not work on the mainnet. 
+     * Add testnet BTC tokens to address
      */
     runFaucetBtc(requestParameters: RunFaucetBtcRequest, initOverrides?: RequestInit): Promise<RunFaucetResponse>;
 
     /**
-     * Retrieves STX tokens into you TestNet STX address.
-     * @summary Get STX tokens
-     * @param {string} address STX address
-     * @param {boolean} [stacking] Request the amount of STX needed for stacking
+     * Add 500 STX tokens to the specified testnet address. Testnet STX addresses begin with `ST`. If the `stacking` parameter is set to `true`, the faucet will add the required number of tokens for individual stacking to the specified testnet address.  The endpoint returns the transaction ID, which you can use to view the transaction in the [Stacks Explorer](https://explorer.stacks.co/?chain=testnet). The tokens are delivered once the transaction has been included in an anchor block.  A common reason for failed faucet transactions is that the faucet has run out of tokens. If you are experiencing failed faucet transactions to a testnet address, you can get help in [Discord](https://stacks.chat).  **Note:** This is a testnet only endpoint. This endpoint will not work on the mainnet. 
+     * @summary Get STX testnet tokens
+     * @param {string} address A valid testnet STX address
+     * @param {boolean} [stacking] Request the amount of STX tokens needed for individual address stacking
+     * @param {InlineObject} [inlineObject] 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof FaucetsApiInterface
@@ -64,8 +74,8 @@ export interface FaucetsApiInterface {
     runFaucetStxRaw(requestParameters: RunFaucetStxRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<RunFaucetResponse>>;
 
     /**
-     * Retrieves STX tokens into you TestNet STX address.
-     * Get STX tokens
+     * Add 500 STX tokens to the specified testnet address. Testnet STX addresses begin with `ST`. If the `stacking` parameter is set to `true`, the faucet will add the required number of tokens for individual stacking to the specified testnet address.  The endpoint returns the transaction ID, which you can use to view the transaction in the [Stacks Explorer](https://explorer.stacks.co/?chain=testnet). The tokens are delivered once the transaction has been included in an anchor block.  A common reason for failed faucet transactions is that the faucet has run out of tokens. If you are experiencing failed faucet transactions to a testnet address, you can get help in [Discord](https://stacks.chat).  **Note:** This is a testnet only endpoint. This endpoint will not work on the mainnet. 
+     * Get STX testnet tokens
      */
     runFaucetStx(requestParameters: RunFaucetStxRequest, initOverrides?: RequestInit): Promise<RunFaucetResponse>;
 
@@ -77,8 +87,8 @@ export interface FaucetsApiInterface {
 export class FaucetsApi extends runtime.BaseAPI implements FaucetsApiInterface {
 
     /**
-     * Retrieves BTC tokens into your TestNet BTC address.
-     * Get BTC tokens
+     * Add 1 BTC token to the specified testnet BTC address.  The endpoint returns the transaction ID, which you can use to view the transaction in a testnet Bitcoin block explorer. The tokens are delivered once the transaction has been included in a block.  **Note:** This is a testnet only endpoint. This endpoint will not work on the mainnet. 
+     * Add testnet BTC tokens to address
      */
     async runFaucetBtcRaw(requestParameters: RunFaucetBtcRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<RunFaucetResponse>> {
         if (requestParameters.address === null || requestParameters.address === undefined) {
@@ -93,19 +103,22 @@ export class FaucetsApi extends runtime.BaseAPI implements FaucetsApiInterface {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
+        headerParameters['Content-Type'] = 'application/json';
+
         const response = await this.request({
             path: `/extended/v1/faucets/btc`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: InlineObject1ToJSON(requestParameters.inlineObject1),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => RunFaucetResponseFromJSON(jsonValue));
     }
 
     /**
-     * Retrieves BTC tokens into your TestNet BTC address.
-     * Get BTC tokens
+     * Add 1 BTC token to the specified testnet BTC address.  The endpoint returns the transaction ID, which you can use to view the transaction in a testnet Bitcoin block explorer. The tokens are delivered once the transaction has been included in a block.  **Note:** This is a testnet only endpoint. This endpoint will not work on the mainnet. 
+     * Add testnet BTC tokens to address
      */
     async runFaucetBtc(requestParameters: RunFaucetBtcRequest, initOverrides?: RequestInit): Promise<RunFaucetResponse> {
         const response = await this.runFaucetBtcRaw(requestParameters, initOverrides);
@@ -113,8 +126,8 @@ export class FaucetsApi extends runtime.BaseAPI implements FaucetsApiInterface {
     }
 
     /**
-     * Retrieves STX tokens into you TestNet STX address.
-     * Get STX tokens
+     * Add 500 STX tokens to the specified testnet address. Testnet STX addresses begin with `ST`. If the `stacking` parameter is set to `true`, the faucet will add the required number of tokens for individual stacking to the specified testnet address.  The endpoint returns the transaction ID, which you can use to view the transaction in the [Stacks Explorer](https://explorer.stacks.co/?chain=testnet). The tokens are delivered once the transaction has been included in an anchor block.  A common reason for failed faucet transactions is that the faucet has run out of tokens. If you are experiencing failed faucet transactions to a testnet address, you can get help in [Discord](https://stacks.chat).  **Note:** This is a testnet only endpoint. This endpoint will not work on the mainnet. 
+     * Get STX testnet tokens
      */
     async runFaucetStxRaw(requestParameters: RunFaucetStxRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<RunFaucetResponse>> {
         if (requestParameters.address === null || requestParameters.address === undefined) {
@@ -133,19 +146,22 @@ export class FaucetsApi extends runtime.BaseAPI implements FaucetsApiInterface {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
+        headerParameters['Content-Type'] = 'application/json';
+
         const response = await this.request({
             path: `/extended/v1/faucets/stx`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: InlineObjectToJSON(requestParameters.inlineObject),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => RunFaucetResponseFromJSON(jsonValue));
     }
 
     /**
-     * Retrieves STX tokens into you TestNet STX address.
-     * Get STX tokens
+     * Add 500 STX tokens to the specified testnet address. Testnet STX addresses begin with `ST`. If the `stacking` parameter is set to `true`, the faucet will add the required number of tokens for individual stacking to the specified testnet address.  The endpoint returns the transaction ID, which you can use to view the transaction in the [Stacks Explorer](https://explorer.stacks.co/?chain=testnet). The tokens are delivered once the transaction has been included in an anchor block.  A common reason for failed faucet transactions is that the faucet has run out of tokens. If you are experiencing failed faucet transactions to a testnet address, you can get help in [Discord](https://stacks.chat).  **Note:** This is a testnet only endpoint. This endpoint will not work on the mainnet. 
+     * Get STX testnet tokens
      */
     async runFaucetStx(requestParameters: RunFaucetStxRequest, initOverrides?: RequestInit): Promise<RunFaucetResponse> {
         const response = await this.runFaucetStxRaw(requestParameters, initOverrides);

package/src/generated/apis/NonFungibleTokensApi.ts

@@ -15,9 +15,18 @@
 
 import * as runtime from '../runtime';
 import {
+    NonFungibleTokenHistoryEventList,
+    NonFungibleTokenHistoryEventListFromJSON,
+    NonFungibleTokenHistoryEventListToJSON,
+    NonFungibleTokenHoldingsList,
+    NonFungibleTokenHoldingsListFromJSON,
+    NonFungibleTokenHoldingsListToJSON,
     NonFungibleTokenMetadata,
     NonFungibleTokenMetadataFromJSON,
     NonFungibleTokenMetadataToJSON,
+    NonFungibleTokenMintList,
+    NonFungibleTokenMintListFromJSON,
+    NonFungibleTokenMintListToJSON,
     NonFungibleTokensMetadataList,
     NonFungibleTokensMetadataListFromJSON,
     NonFungibleTokensMetadataListToJSON,
@@ -27,11 +36,37 @@ export interface GetContractNftMetadataRequest {
     contractId: string;
 }
 
+export interface GetNftHistoryRequest {
+    assetIdentifier: string;
+    value: string;
+    limit?: number;
+    offset?: number;
+    unanchored?: boolean;
+    txMetadata?: boolean;
+}
+
+export interface GetNftHoldingsRequest {
+    principal: string;
+    assetIdentifiers?: Array<string>;
+    limit?: number;
+    offset?: number;
+    unanchored?: boolean;
+    txMetadata?: boolean;
+}
+
 export interface GetNftMetadataListRequest {
     limit?: number;
     offset?: number;
 }
 
+export interface GetNftMintsRequest {
+    assetIdentifier: string;
+    limit?: number;
+    offset?: number;
+    unanchored?: boolean;
+    txMetadata?: boolean;
+}
+
 /**
  * NonFungibleTokensApi - interface
  * 
@@ -55,6 +90,48 @@ export interface NonFungibleTokensApiInterface {
      */
     getContractNftMetadata(requestParameters: GetContractNftMetadataRequest, initOverrides?: RequestInit): Promise<NonFungibleTokenMetadata>;
 
+    /**
+     * Retrieves all events relevant to a Non-Fungible Token. Useful to determine the ownership history of a particular asset.  More information on Non-Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#non-fungible-tokens-nfts). 
+     * @summary Non-Fungible Token history
+     * @param {string} assetIdentifier token asset class identifier
+     * @param {string} value hex representation of the token\&#39;s unique value
+     * @param {number} [limit] max number of events to fetch
+     * @param {number} [offset] index of first event to fetch
+     * @param {boolean} [unanchored] whether or not to include events from unconfirmed transactions
+     * @param {boolean} [txMetadata] whether or not to include the complete transaction metadata instead of just &#x60;tx_id&#x60;. Enabling this option can affect performance and response times.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof NonFungibleTokensApiInterface
+     */
+    getNftHistoryRaw(requestParameters: GetNftHistoryRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<NonFungibleTokenHistoryEventList>>;
+
+    /**
+     * Retrieves all events relevant to a Non-Fungible Token. Useful to determine the ownership history of a particular asset.  More information on Non-Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#non-fungible-tokens-nfts). 
+     * Non-Fungible Token history
+     */
+    getNftHistory(requestParameters: GetNftHistoryRequest, initOverrides?: RequestInit): Promise<NonFungibleTokenHistoryEventList>;
+
+    /**
+     * Retrieves the list of Non-Fungible Tokens owned by the given principal (STX address or Smart Contract ID). Results can be filtered by one or more asset identifiers and can include metadata about the transaction that made the principal own each token.  More information on Non-Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#non-fungible-tokens-nfts). 
+     * @summary Non-Fungible Token holdings
+     * @param {string} principal token owner\&#39;s STX address or Smart Contract ID
+     * @param {Array<string>} [assetIdentifiers] identifiers of the token asset classes to filter for
+     * @param {number} [limit] max number of tokens to fetch
+     * @param {number} [offset] index of first tokens to fetch
+     * @param {boolean} [unanchored] whether or not to include tokens from unconfirmed transactions
+     * @param {boolean} [txMetadata] whether or not to include the complete transaction metadata instead of just &#x60;tx_id&#x60;. Enabling this option can affect performance and response times.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof NonFungibleTokensApiInterface
+     */
+    getNftHoldingsRaw(requestParameters: GetNftHoldingsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<NonFungibleTokenHoldingsList>>;
+
+    /**
+     * Retrieves the list of Non-Fungible Tokens owned by the given principal (STX address or Smart Contract ID). Results can be filtered by one or more asset identifiers and can include metadata about the transaction that made the principal own each token.  More information on Non-Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#non-fungible-tokens-nfts). 
+     * Non-Fungible Token holdings
+     */
+    getNftHoldings(requestParameters: GetNftHoldingsRequest, initOverrides?: RequestInit): Promise<NonFungibleTokenHoldingsList>;
+
     /**
      * Retrieves a list of non fungible tokens with their metadata. More information on Non-Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#non-fungible-tokens-nfts).
      * @summary Non fungible tokens metadata list
@@ -72,6 +149,26 @@ export interface NonFungibleTokensApiInterface {
      */
     getNftMetadataList(requestParameters: GetNftMetadataListRequest, initOverrides?: RequestInit): Promise<NonFungibleTokensMetadataList>;
 
+    /**
+     * Retrieves all mint events for a Non-Fungible Token asset class. Useful to determine which NFTs of a particular collection have been claimed.  More information on Non-Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#non-fungible-tokens-nfts). 
+     * @summary Non-Fungible Token mints
+     * @param {string} assetIdentifier token asset class identifier
+     * @param {number} [limit] max number of events to fetch
+     * @param {number} [offset] index of first event to fetch
+     * @param {boolean} [unanchored] whether or not to include events from unconfirmed transactions
+     * @param {boolean} [txMetadata] whether or not to include the complete transaction metadata instead of just &#x60;tx_id&#x60;. Enabling this option can affect performance and response times.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof NonFungibleTokensApiInterface
+     */
+    getNftMintsRaw(requestParameters: GetNftMintsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<NonFungibleTokenMintList>>;
+
+    /**
+     * Retrieves all mint events for a Non-Fungible Token asset class. Useful to determine which NFTs of a particular collection have been claimed.  More information on Non-Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#non-fungible-tokens-nfts). 
+     * Non-Fungible Token mints
+     */
+    getNftMints(requestParameters: GetNftMintsRequest, initOverrides?: RequestInit): Promise<NonFungibleTokenMintList>;
+
 }
 
 /**
@@ -111,6 +208,122 @@ export class NonFungibleTokensApi extends runtime.BaseAPI implements NonFungible
         return await response.value();
     }
 
+    /**
+     * Retrieves all events relevant to a Non-Fungible Token. Useful to determine the ownership history of a particular asset.  More information on Non-Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#non-fungible-tokens-nfts). 
+     * Non-Fungible Token history
+     */
+    async getNftHistoryRaw(requestParameters: GetNftHistoryRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<NonFungibleTokenHistoryEventList>> {
+        if (requestParameters.assetIdentifier === null || requestParameters.assetIdentifier === undefined) {
+            throw new runtime.RequiredError('assetIdentifier','Required parameter requestParameters.assetIdentifier was null or undefined when calling getNftHistory.');
+        }
+
+        if (requestParameters.value === null || requestParameters.value === undefined) {
+            throw new runtime.RequiredError('value','Required parameter requestParameters.value was null or undefined when calling getNftHistory.');
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters.assetIdentifier !== undefined) {
+            queryParameters['asset_identifier'] = requestParameters.assetIdentifier;
+        }
+
+        if (requestParameters.value !== undefined) {
+            queryParameters['value'] = requestParameters.value;
+        }
+
+        if (requestParameters.limit !== undefined) {
+            queryParameters['limit'] = requestParameters.limit;
+        }
+
+        if (requestParameters.offset !== undefined) {
+            queryParameters['offset'] = requestParameters.offset;
+        }
+
+        if (requestParameters.unanchored !== undefined) {
+            queryParameters['unanchored'] = requestParameters.unanchored;
+        }
+
+        if (requestParameters.txMetadata !== undefined) {
+            queryParameters['tx_metadata'] = requestParameters.txMetadata;
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        const response = await this.request({
+            path: `/extended/v1/tokens/nft/history`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => NonFungibleTokenHistoryEventListFromJSON(jsonValue));
+    }
+
+    /**
+     * Retrieves all events relevant to a Non-Fungible Token. Useful to determine the ownership history of a particular asset.  More information on Non-Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#non-fungible-tokens-nfts). 
+     * Non-Fungible Token history
+     */
+    async getNftHistory(requestParameters: GetNftHistoryRequest, initOverrides?: RequestInit): Promise<NonFungibleTokenHistoryEventList> {
+        const response = await this.getNftHistoryRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Retrieves the list of Non-Fungible Tokens owned by the given principal (STX address or Smart Contract ID). Results can be filtered by one or more asset identifiers and can include metadata about the transaction that made the principal own each token.  More information on Non-Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#non-fungible-tokens-nfts). 
+     * Non-Fungible Token holdings
+     */
+    async getNftHoldingsRaw(requestParameters: GetNftHoldingsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<NonFungibleTokenHoldingsList>> {
+        if (requestParameters.principal === null || requestParameters.principal === undefined) {
+            throw new runtime.RequiredError('principal','Required parameter requestParameters.principal was null or undefined when calling getNftHoldings.');
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters.principal !== undefined) {
+            queryParameters['principal'] = requestParameters.principal;
+        }
+
+        if (requestParameters.assetIdentifiers) {
+            queryParameters['asset_identifiers'] = requestParameters.assetIdentifiers;
+        }
+
+        if (requestParameters.limit !== undefined) {
+            queryParameters['limit'] = requestParameters.limit;
+        }
+
+        if (requestParameters.offset !== undefined) {
+            queryParameters['offset'] = requestParameters.offset;
+        }
+
+        if (requestParameters.unanchored !== undefined) {
+            queryParameters['unanchored'] = requestParameters.unanchored;
+        }
+
+        if (requestParameters.txMetadata !== undefined) {
+            queryParameters['tx_metadata'] = requestParameters.txMetadata;
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        const response = await this.request({
+            path: `/extended/v1/tokens/nft/holdings`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => NonFungibleTokenHoldingsListFromJSON(jsonValue));
+    }
+
+    /**
+     * Retrieves the list of Non-Fungible Tokens owned by the given principal (STX address or Smart Contract ID). Results can be filtered by one or more asset identifiers and can include metadata about the transaction that made the principal own each token.  More information on Non-Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#non-fungible-tokens-nfts). 
+     * Non-Fungible Token holdings
+     */
+    async getNftHoldings(requestParameters: GetNftHoldingsRequest, initOverrides?: RequestInit): Promise<NonFungibleTokenHoldingsList> {
+        const response = await this.getNftHoldingsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Retrieves a list of non fungible tokens with their metadata. More information on Non-Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#non-fungible-tokens-nfts).
      * Non fungible tokens metadata list
@@ -147,4 +360,56 @@ export class NonFungibleTokensApi extends runtime.BaseAPI implements NonFungible
         return await response.value();
     }
 
+    /**
+     * Retrieves all mint events for a Non-Fungible Token asset class. Useful to determine which NFTs of a particular collection have been claimed.  More information on Non-Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#non-fungible-tokens-nfts). 
+     * Non-Fungible Token mints
+     */
+    async getNftMintsRaw(requestParameters: GetNftMintsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<NonFungibleTokenMintList>> {
+        if (requestParameters.assetIdentifier === null || requestParameters.assetIdentifier === undefined) {
+            throw new runtime.RequiredError('assetIdentifier','Required parameter requestParameters.assetIdentifier was null or undefined when calling getNftMints.');
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters.assetIdentifier !== undefined) {
+            queryParameters['asset_identifier'] = requestParameters.assetIdentifier;
+        }
+
+        if (requestParameters.limit !== undefined) {
+            queryParameters['limit'] = requestParameters.limit;
+        }
+
+        if (requestParameters.offset !== undefined) {
+            queryParameters['offset'] = requestParameters.offset;
+        }
+
+        if (requestParameters.unanchored !== undefined) {
+            queryParameters['unanchored'] = requestParameters.unanchored;
+        }
+
+        if (requestParameters.txMetadata !== undefined) {
+            queryParameters['tx_metadata'] = requestParameters.txMetadata;
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        const response = await this.request({
+            path: `/extended/v1/tokens/nft/mints`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => NonFungibleTokenMintListFromJSON(jsonValue));
+    }
+
+    /**
+     * Retrieves all mint events for a Non-Fungible Token asset class. Useful to determine which NFTs of a particular collection have been claimed.  More information on Non-Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#non-fungible-tokens-nfts). 
+     * Non-Fungible Token mints
+     */
+    async getNftMints(requestParameters: GetNftMintsRequest, initOverrides?: RequestInit): Promise<NonFungibleTokenMintList> {
+        const response = await this.getNftMintsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
 }

package/src/generated/models/InlineObject.ts

@@ -0,0 +1,64 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Stacks Blockchain API
+ * Welcome to the API reference overview for the <a href=\"https://docs.hiro.so/get-started/stacks-blockchain-api\">Stacks Blockchain API</a>.  <a href=\"/collection.json\" download=\"stacks-api-collection.json\">Download Postman collection</a> 
+ *
+ * The version of the OpenAPI document: STACKS_API_VERSION
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface InlineObject
+ */
+export interface InlineObject {
+    /**
+     * STX testnet address
+     * @type {string}
+     * @memberof InlineObject
+     */
+    address?: string;
+    /**
+     * Use required number of tokens for stacking
+     * @type {boolean}
+     * @memberof InlineObject
+     */
+    stacking?: boolean;
+}
+
+export function InlineObjectFromJSON(json: any): InlineObject {
+    return InlineObjectFromJSONTyped(json, false);
+}
+
+export function InlineObjectFromJSONTyped(json: any, ignoreDiscriminator: boolean): InlineObject {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'address': !exists(json, 'address') ? undefined : json['address'],
+        'stacking': !exists(json, 'stacking') ? undefined : json['stacking'],
+    };
+}
+
+export function InlineObjectToJSON(value?: InlineObject | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'address': value.address,
+        'stacking': value.stacking,
+    };
+}
+