opensea-js 5.0.2 → 6.0.0

package/README.md

@@ -12,9 +12,7 @@
 [![Docs][docs-badge]][docs-link]
 [![Discussions][discussions-badge]][discussions-link]
 
-A JavaScript library for crypto-native ecommerce: buying, selling, and bidding on any cryptogood. With OpenSea.js, you can easily build your own native marketplace for your non-fungible tokens, or NFTs. These can be ERC-721 or ERC-1155 (semi-fungible) items. You don't have to deploy your own smart contracts or backend orderbooks.
-
-Published on [GitHub](https://github.com/ProjectOpenSea/opensea-js) and [npm](https://www.npmjs.com/package/opensea-js)
+A JavaScript library for crypto-native e-commerce: buying, selling, and bidding on NFTs (non-fungible tokens). With OpenSea.js, you can easily build your own native marketplace. These can be ERC-721 or ERC-1155 (semi-fungible) items. You don't have to deploy your own smart contracts or manage backend orderbooks.
 
 - [Synopsis](#synopsis)
 - [Installation](#installation)
@@ -37,7 +35,7 @@ Published on [GitHub](https://github.com/ProjectOpenSea/opensea-js) and [npm](ht
   - [Private Auctions](#private-auctions)
   - [Listening to Events](#listening-to-events)
 - [Learning More](#learning-more)
-- [Migrating to version 1.0](#migrating-to-version-10)
+- [Changelog](#changelog)
 - [Development Information](#development-information)
 - [Diagnosing Common Issues](#diagnosing-common-issues)
 - [Testing your branch locally](#testing-your-branch-locally)
@@ -60,46 +58,36 @@ Then, in your project, run:
 
 ```bash
 npm install --save opensea-js
-```
-
-> **Warning**
-> Due to the use of git-url dependencies, versions of `npm` below 8.5.2 are incompatible with this package due to broken integrity checksum validation.
-> Above version 8.5.2, `npm` will no longer validate integrity checksums for git-url dependencies.
-
-Install [web3](https://github.com/ethereum/web3.js) too if you haven't already.
-
-If you run into an error while building the dependencies and you're on a Mac, run this:
-
-```bash
-xcode-select --install # Install Command Line Tools if you haven't already.
-sudo xcode-select --switch /Library/Developer/CommandLineTools # Enable command line tools
-sudo npm explore npm -g -- npm install node-gyp@latest # (Optional) update node-gyp
+# or
+yarn add opensea-js
 ```
 
 ## Getting Started
 
 To get started, first request an API key [here](https://docs.opensea.io/reference). Note the terms of use for using API data.
 
-Then, create a new OpenSeaJS client, called an OpenSeaSDK 🚢, using your Web3 provider:
+Then, create a new OpenSeaJS client, called an OpenSeaSDK 🚢, using your web3 provider:
 
-```JavaScript
-import * as Web3 from 'web3'
-import { OpenSeaSDK, Network } from 'opensea-js'
+```typescript
+import { ethers } from "ethers";
+import { OpenSeaSDK, Chain } from "opensea-js";
 
 // This example provider won't let you make transactions, only read-only calls:
-const provider = new Web3.providers.HttpProvider('https://mainnet.infura.io')
+const provider = new ethers.providers.JsonRpcProvider(
+  "https://mainnet.infura.io"
+);
 
 const openseaSDK = new OpenSeaSDK(provider, {
-  networkName: Network.Main,
-  apiKey: YOUR_API_KEY
-})
+  chain: Chain.Mainnet,
+  apiKey: YOUR_API_KEY,
+});
 ```
 
-**NOTE:** for testnet, please use `Network.Goerli` as the `networkName` - Rinkeby was deprecated in 2022.
+**NOTE:** For testnet, please use `Chain.Goerli` as the `chain`. Rinkeby was deprecated in 2022.
 
-**NOTE:** Using the sample Infura provider above won't let you authorize transactions, which are needed when approving and trading assets and currency. To make transactions, you need a provider with a private key or mnemonic set.
+**NOTE:** Using the sample provider above won't let you authorize transactions, which are needed when approving and trading assets and currency. To make transactions, you need a provider with a private key or mnemonic set.
 
-In a browser with web3 or an extension like [MetaMask](https://metamask.io/) or [Dapper](http://www.meetdapper.com/), you can use `window.ethereum` (or `window.web3.currentProvider` for legacy mobile web3 browsers) to access the native provider. In a Node.js script, you can follow [this example](https://github.com/ProjectOpenSea/opensea-creatures/blob/master/scripts/sell.js) to use a custom mnemonic.
+In a browser with web3 or an extension like [MetaMask](https://metamask.io/) or [Coinbase Wallet](https://www.coinbase.com/wallet), you can use `window.ethereum` to access the native provider.
 
 ### Fetching Assets
 
@@ -116,8 +104,8 @@ export interface Asset {
   tokenId: string | null,
   // The asset's contract address
   tokenAddress: string,
-  // The Wyvern schema name (defaults to "ERC721") for this asset
-  schemaName?: WyvernSchemaName,
+  // The schema name (defaults to "ERC721") for this asset
+  tokenStandard?: TokenStandard,
   // Optional for ENS names
   name?: string,
   // Optional for fungible items
@@ -125,14 +113,14 @@ export interface Asset {
 }
 ```
 
-The `Asset` type is the minimal type you need for most marketplace actions. `WyvernSchemaName` is optional. If omitted, most actions will assume you're referring to a non-fungible, ERC721 asset. Other options include 'ERC20' and 'ERC1155'. You can import `import { WyvernSchemaName } from "opensea-js/lib/types"` to get the full range of schemas supported.
+The `Asset` type is the minimal type you need for most marketplace actions. `TokenStandard` is optional. If omitted, most actions will assume you're referring to a non-fungible, ERC721 asset. Other options include 'ERC20' and 'ERC1155'. You can import `import { TokenStandard } from "opensea-js/lib/types"` to get the full range of schemas supported.
 
 You can fetch an asset using the `OpenSeaAPI`, which will return an `OpenSeaAsset` for you (`OpenSeaAsset` extends `Asset`):
 
 ```TypeScript
 const asset: OpenSeaAsset = await openseaSDK.api.getAsset({
   tokenAddress, // string
-  tokenId, // string | number | null
+  tokenId, // string | number | BigNumber | null
 })
 ```
 
@@ -144,50 +132,40 @@ The nice thing about the `Asset` type is that it unifies logic between fungibles
 
 Once you have an `Asset`, you can see how many any account owns, regardless of whether it's an ERC-20 token or a non-fungible good:
 
-```JavaScript
-
+```typescript
 const asset = {
   tokenAddress: "0x06012c8cf97bead5deae237070f9587f8e7a266d", // CryptoKitties
   tokenId: "1", // Token ID
-}
+};
 
-const balance = await openseaSDK.getAssetBalance({
+const balance = await openseaSDK.getBalance({
   accountAddress, // string
   asset, // Asset
-})
+});
 
-const ownsKitty = balance.greaterThan(0)
-```
-
-You can use this same method for fungible ERC-20 tokens like wrapped ETH (WETH). As a convenience, you can use this fungible wrapper for checking fungible balances:
-
-```JavaScript
-const balanceOfWETH = await openseaSDK.getTokenBalance({
-  accountAddress, // string
-  tokenAddress: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
-})
+const ownsKitty = balance.greaterThan(0);
 ```
 
 ### Making Offers
 
 Once you have your asset, you can do this to make an offer on it:
 
-```JavaScript
+```typescript
 // Token ID and smart contract address for a non-fungible token:
-const { tokenId, tokenAddress } = YOUR_ASSET
+const { tokenId, tokenAddress } = YOUR_ASSET;
 // The offerer's wallet address:
-const accountAddress = "0x1234..."
+const accountAddress = "0x1234...";
 
 const offer = await openseaSDK.createBuyOrder({
   asset: {
     tokenId,
     tokenAddress,
-    schemaName // WyvernSchemaName. If omitted, defaults to 'ERC721'. Other options include 'ERC20' and 'ERC1155'
+    tokenStandard, // TokenStandard. If omitted, defaults to 'ERC721'. Other options include 'ERC20' and 'ERC1155'
   },
   accountAddress,
   // Value of the offer, in units of the payment token (or wrapped ETH if none is specified):
   startAmount: 1.2,
-})
+});
 ```
 
 When you make an offer on an item owned by an OpenSea user, **that user will automatically get an email notifying them with the offer amount**, if it's above their desired threshold.
@@ -198,7 +176,7 @@ The Ethereum Name Service (ENS) is auctioning short (3-6 character) names that c
 
 To bid, you must use the ENS Short Name schema:
 
-```JavaScript
+```typescript
 const {
   tokenId,
   // Token address should be `0xfac7bea255a6990f749363002136af6556b31e04` on mainnet
@@ -214,7 +192,7 @@ const offer = await openseaSDK.createBuyOrder({
     name,
     // Only needed for the short-name auction, not ENS names
     // that have been sold once already:
-    schemaName: "ENSShortNameAuction"
+    tokenStandard: "ENSShortNameAuction"
   },
   // Your wallet address (the bidder's address):
   accountAddress: "0x1234..."
@@ -231,10 +209,10 @@ Note: The total value of buy orders must not exceed 1000 x wallet balance.
 
 To sell an asset, call `createSellOrder`. You can do a fixed-price listing, where `startAmount` is equal to `endAmount`, or a declining [Dutch auction](https://en.wikipedia.org/wiki/Dutch_auction), where `endAmount` is lower and the price declines until `expirationTime` is hit:
 
-```JavaScript
+```typescript
 // Expire this auction one day from now.
 // Note that we convert from the JavaScript timestamp (milliseconds):
-const expirationTime = Math.round(Date.now() / 1000 + 60 * 60 * 24)
+const expirationTime = Math.round(Date.now() / 1000 + 60 * 60 * 24);
 
 const listing = await openseaSDK.createSellOrder({
   asset: {
@@ -245,8 +223,8 @@ const listing = await openseaSDK.createSellOrder({
   startAmount: 3,
   // If `endAmount` is specified, the order will decline in value to that amount until `expirationTime`. Otherwise, it's a fixed-price order:
   endAmount: 0.1,
-  expirationTime
-})
+  expirationTime,
+});
 ```
 
 The units for `startAmount` and `endAmount` are Ether, ETH. If you want to specify another ERC-20 token to use, see [Using ERC-20 Tokens Instead of Ether](#using-erc-20-tokens-instead-of-ether).
@@ -259,12 +237,11 @@ English Auctions are auctions that start at a small amount (we recommend even do
 
 To create an English Auction, create a listing that waits for the highest bid by setting `waitForHighestBid` to `true`:
 
-```JavaScript
-
+```typescript
 // Create an auction to receive Wrapped Ether (WETH). See note below.
-const paymentTokenAddress = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
+const paymentTokenAddress = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
 
-const startAmount = 0 // The minimum amount to sell for, in normal units (e.g. ETH)
+const startAmount = 0; // The minimum amount to sell for, in normal units (e.g. ETH)
 
 const auction = await openseaSDK.createSellOrder({
   asset: {
@@ -275,8 +252,8 @@ const auction = await openseaSDK.createSellOrder({
   startAmount,
   expirationTime,
   paymentTokenAddress,
-  waitForHighestBid: true
-})
+  waitForHighestBid: true,
+});
 ```
 
 Note that auctions aren't supported with Ether directly due to limitations in Ethereum, so you have to use an ERC20 token, like Wrapped Ether (WETH), a stablecoin like DAI, etc. See [Using ERC-20 Tokens Instead of Ether](#using-erc-20-tokens-instead-of-ether) for more info.
@@ -285,20 +262,23 @@ Note that auctions aren't supported with Ether directly due to limitations in Et
 
 To retrieve a list of offers and auctions on an asset, you can use an instance of the `OpenSeaAPI` exposed on the client. Parameters passed into API filter objects are camel-cased and serialized before being sent as [OpenSea API parameters](https://docs.opensea.io/v2.0/reference):
 
-```JavaScript
+```typescript
 // Get offers (bids), a.k.a. orders where `side == 0`
 const { orders, count } = await openseaSDK.api.getOrders({
   assetContractAddress: tokenAddress,
   tokenId,
-  side: "bid"
-})
+  side: "bid",
+});
 
 // Get page 2 of all auctions, a.k.a. orders where `side == 1`
-const { orders, count } = await openseaSDK.api.getOrders({
-  assetContractAddress: tokenAddress,
-  tokenId,
-  side: "ask"
-}, 2)
+const { orders, count } = await openseaSDK.api.getOrders(
+  {
+    assetContractAddress: tokenAddress,
+    tokenId,
+    side: "ask",
+  },
+  2
+);
 ```
 
 Note that the listing price of an asset is equal to the `currentPrice` of the **lowest valid sell order** on the asset. Users can lower their listing price without invalidating previous sell orders, so all get shipped down until they're canceled, or one is fulfilled.
@@ -337,7 +317,7 @@ The available API filters for the orders endpoint is documented in the `OrdersQu
 
 To buy an item, you need to **fulfill a sell order**. To do that, it's just one call:
 
-```JavaScript
+```typescript
 const order = await openseaSDK.api.getOrder({ side: "ask", ... })
 const accountAddress = "0x..." // The buyer's wallet address, also the taker
 const transactionHash = await openseaSDK.fulfillOrder({ order, accountAddress })
@@ -351,7 +331,7 @@ If the order is a sell order (`order.side === "ask"`), the taker is the _buyer_
 
 Similar to fulfilling sell orders above, you need to fulfill a buy order on an item you own to receive the tokens in the offer.
 
-```JavaScript
+```typescript
 const order = await openseaSDK.api.getOrder({ side: "bid", ... })
 const accountAddress = "0x..." // The owner's wallet address, also the taker
 await openseaSDK.fulfillOrder({ order, accountAddress })
@@ -365,51 +345,50 @@ A handy feature in OpenSea.js is the ability to transfer any supported asset (fu
 
 To transfer an ERC-721 asset or an ERC-1155 asset, it's just one call:
 
-```JavaScript
-
+```typescript
 const transactionHash = await openseaSDK.transfer({
   asset: { tokenId, tokenAddress },
   fromAddress, // Must own the asset
-  toAddress
-})
+  toAddress,
+});
 ```
 
-For fungible ERC-1155 assets, you can set `schemaName` to "ERC1155" and pass a `quantity` in to transfer multiple at once:
-
-```JavaScript
+For fungible ERC-1155 assets, you can set `tokenStandard` to "ERC1155" and pass a `quantity` in to transfer multiple at once:
 
+```typescript
 const transactionHash = await openseaSDK.transfer({
   asset: {
     tokenId,
     tokenAddress,
-    schemaName: "ERC1155"
+    tokenStandard: "ERC1155",
   },
   fromAddress, // Must own the asset
   toAddress,
   quantity: 2,
-})
+});
 ```
 
-To transfer fungible assets without token IDs, like ERC20 tokens, you can pass in an `OpenSeaFungibleToken` as the `asset`, set `schemaName` to "ERC20", and include `quantity` in base units (e.g. wei) to indicate how many.
+To transfer fungible assets without token IDs, like ERC20 tokens, you can pass in an `OpenSeaFungibleToken` as the `asset`, set `tokenStandard` to "ERC20", and include `quantity` in base units (e.g. wei) to indicate how many.
 
 Example for transferring 2 DAI ($2) to another address:
 
-```JavaScript
-const paymentToken = (await openseaSDK.api.getPaymentTokens({ symbol: 'DAI'})).tokens[0]
-const quantity = new BigNumber(Math.pow(10, paymentToken.decimals)).times(2)
+```typescript
+const paymentToken = (await openseaSDK.api.getPaymentTokens({ symbol: "DAI" }))
+  .tokens[0];
+const quantity = ethers.utils.parseUnits("2", paymentToken.decimals);
 const transactionHash = await openseaSDK.transfer({
   asset: {
     tokenId: null,
     tokenAddress: paymentToken.address,
-    schemaName: "ERC20"
+    tokenStandard: "ERC20",
   },
   fromAddress, // Must own the tokens
   toAddress,
-  quantity
-})
+  quantity,
+});
 ```
 
-For more information, check out the documentation for WyvernSchemas on https://projectopensea.github.io/opensea-js/.
+For more information, check out the [documentation](https://projectopensea.github.io/opensea-js/).
 
 ## Advanced
 
@@ -419,21 +398,21 @@ Interested in purchasing for users server-side or with a bot, scheduling future
 
 You can create sell orders that aren't fulfillable until a future date. Just pass in a `listingTime` (a UTC timestamp in seconds) to your SDK instance:
 
-```JavaScript
+```typescript
 const auction = await openseaSDK.createSellOrder({
   tokenAddress,
   tokenId,
   accountAddress,
   startAmount: 1,
-  listingTime: Math.round(Date.now() / 1000 + 60 * 60 * 24) // One day from now
-})
+  listingTime: Math.round(Date.now() / 1000 + 60 * 60 * 24), // One day from now
+});
 ```
 
 ### Purchasing Items for Other Users
 
 You can buy and transfer an item to someone else in one step! Just pass the `recipientAddress` parameter:
 
-```JavaScript
+```typescript
 const order = await openseaSDK.api.getOrder({ side: "ask", ... })
 await openseaSDK.fulfillOrder({
   order,
@@ -444,31 +423,15 @@ await openseaSDK.fulfillOrder({
 
 If the order is a sell order (`order.side === "ask"`), the taker is the _buyer_ and this will prompt the buyer to pay for the item(s) but send them to the `recipientAddress`. If the order is a buy order ( `"bid"`), the taker is the _seller_ but the bid amount be sent to the `recipientAddress`.
 
-### Bulk Transfers
-
-A handy feature in OpenSea.js is the ability to transfer multiple items at once in a single transaction. This works by grouping together as many `transferFrom` calls as the Ethereum gas limit allows, which is usually under 30 items, for most item contracts.
-
-To make a bulk transfer, it's just one call:
-
-```JavaScript
-const assets: Array<{tokenId: string; tokenAddress: string}> = [...]
-
-const transactionHash = await openseaSDK.transferAll({
-  assets,
-  fromAddress, // Must own all the assets
-  toAddress
-})
-```
-
 This will automatically approve the assets for trading and confirm the transaction for sending them.
 
 ### Using ERC-20 Tokens Instead of Ether
 
 Here's an example of listing the Genesis CryptoKitty for $100! No more needing to worry about the exchange rate:
 
-```JavaScript
+```typescript
 // Token address for the DAI stablecoin, which is pegged to $1 USD
-const paymentTokenAddress = "0x89d24a6b4ccb1b6faa2625fe562bdd9a23260359"
+const paymentTokenAddress = "0x89d24a6b4ccb1b6faa2625fe562bdd9a23260359";
 
 // The units for `startAmount` and `endAmount` are now in DAI, so $100 USD
 const auction = await openseaSDK.createSellOrder({
@@ -476,19 +439,20 @@ const auction = await openseaSDK.createSellOrder({
   tokenId: "1", // Token ID
   accountAddress: OWNERS_WALLET_ADDRESS,
   startAmount: 100,
-  paymentTokenAddress
-})
+  paymentTokenAddress,
+});
 ```
 
 You can use `getPaymentTokens` to search for tokens by symbol name. And you can even list all orders for a specific ERC-20 token by querying the API:
 
-```JavaScript
-const token = (await openseaSDK.api.getPaymentTokens({ symbol: 'MANA'})).tokens[0]
+```typescript
+const token = (await openseaSDK.api.getPaymentTokens({ symbol: "MANA" }))
+  .tokens[0];
 
 const order = await openseaSDK.api.getOrders({
   side: "ask",
-  paymentTokenAddress: token.address
-})
+  paymentTokenAddress: token.address,
+});
 ```
 
 **Fun note:** soon, all ERC-20 tokens will be allowed! This will mean you can create crazy offers on crypto collectibles **using your own ERC-20 token**. However, opensea.io will only display offers and auctions in ERC-20 tokens that it knows about, optimizing the user experience of order takers. Orders made with the following tokens will be shown on OpenSea:
@@ -502,17 +466,18 @@ Now you can make auctions and listings that can only be fulfilled by an address
 
 Here's an example of listing a Decentraland parcel for 10 ETH with a specific buyer address allowed to take it. No more needing to worry about whether they'll give you enough back!
 
-```JavaScript
+```typescript
 // Address allowed to buy from you
-const buyerAddress = "0x123..."
+const buyerAddress = "0x123...";
 
 const listing = await openseaSDK.createSellOrder({
   tokenAddress: "0xf87e31492faf9a91b02ee0deaad50d51d56d5d4d", // Decentraland
-  tokenId: "115792089237316195423570985008687907832853042650384256231655107562007036952461", // Token ID
+  tokenId:
+    "115792089237316195423570985008687907832853042650384256231655107562007036952461", // Token ID
   accountAddress: OWNERS_WALLET_ADDRESS,
   startAmount: 10,
-  buyerAddress
-})
+  buyerAddress,
+});
 ```
 
 ### Listening to Events
@@ -521,10 +486,9 @@ Events are fired whenever transactions or orders are being created, and when tra
 
 Our recommendation is that you "forward" OpenSea events to your own store or state management system. Here's an example of doing that with a Redux action:
 
-```JavaScript
-import { EventType } from 'opensea-js'
+```typescript
+import { openSeaSDK, EventType } from 'opensea-js'
 import * as ActionTypes from './index'
-import { openSeaSDK } from '../globalSingletons'
 
 // ...
 
@@ -565,12 +529,12 @@ handleSDKEvents() {
       console.info({ accountAddress, tokenAddress })
       dispatch({ type: ActionTypes.APPROVE_WETH })
     })
-    openSeaSDK.addListener(EventType.ApproveAllAssets, ({ accountAddress, proxyAddress, tokenAddress }) => {
-      console.info({ accountAddress, proxyAddress, tokenAddress })
+    openSeaSDK.addListener(EventType.ApproveAllAssets, ({ accountAddress, tokenAddress }) => {
+      console.info({ accountAddress, tokenAddress })
       dispatch({ type: ActionTypes.APPROVE_ALL_ASSETS })
     })
-    openSeaSDK.addListener(EventType.ApproveAsset, ({ accountAddress, proxyAddress, tokenAddress, tokenId }) => {
-      console.info({ accountAddress, proxyAddress, tokenAddress, tokenId })
+    openSeaSDK.addListener(EventType.ApproveAsset, ({ accountAddress, tokenAddress, tokenId }) => {
+      console.info({ accountAddress, tokenAddress, tokenId })
       dispatch({ type: ActionTypes.APPROVE_ASSET })
     })
     openSeaSDK.addListener(EventType.CreateOrder, ({ order, accountAddress }) => {
@@ -599,7 +563,7 @@ To remove all listeners and start over, just call `openseaSDK.removeAllListeners
 
 Auto-generated documentation for each export is available [here](https://projectopensea.github.io/opensea-js/).
 
-## Migrating to version 1.0
+## Changelog
 
 See the [Changelog](CHANGELOG.md).
 
@@ -616,7 +580,7 @@ npm install
 And install TypeScript if you haven't already:
 
 ```bash
-npm install -g tslint typescript
+npm install -g typescript
 ```
 
 **Build**
@@ -633,14 +597,14 @@ Or run the tests:
 npm test
 ```
 
-Note that the tests require access to both Infura and the OpenSea API. The timeout is adjustable via the `test` script in `package.json`.
+Note that the tests require access to Alchemy and the OpenSea API. The timeout is adjustable via the `test` script in `package.json`.
 
 **Generate Documentation**
 
 Generate html docs, also available for browsing [here](https://projectopensea.github.io/opensea-js/):
 
 ```bash
-yarn docs-build
+npm run docs-build
 ```
 
 **Contributing**
@@ -658,8 +622,8 @@ Contributions welcome! Please use GitHub issues for suggestions/concerns - if yo
 ## Testing your branch locally
 
 ```sh
-yarn link # in opensea-js repo
-yarn link opensea-js # in repo you're working on
+npm link # in opensea-js repo
+npm link opensea-js # in repo you're working on
 ```
 
 [version-badge]: https://img.shields.io/github/package-json/v/ProjectOpenSea/opensea-js
@@ -668,8 +632,8 @@ yarn link opensea-js # in repo you're working on
 [npm-link]: https://www.npmjs.com/package/opensea-js
 [ci-badge]: https://github.com/ProjectOpenSea/opensea-js/actions/workflows/code-quality.yml/badge.svg
 [ci-link]: https://github.com/ProjectOpenSea/opensea-js/actions/workflows/code-quality.yml
-[coverage-badge]: https://coveralls.io/repos/github/ProjectOpenSea/opensea-js/badge.svg?branch=master
-[coverage-link]: https://coveralls.io/github/ProjectOpenSea/opensea-js?branch=master
+[coverage-badge]: https://coveralls.io/repos/github/ProjectOpenSea/opensea-js/badge.svg?branch=main
+[coverage-link]: https://coveralls.io/github/ProjectOpenSea/opensea-js?branch=main
 [license-badge]: https://img.shields.io/github/license/ProjectOpenSea/opensea-js
 [license-link]: https://github.com/ProjectOpenSea/opensea-js/blob/main/LICENSE
 [docs-badge]: https://img.shields.io/badge/OpenSea.js-documentation-informational

package/lib/__integration_tests__/getAsset.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/__integration_tests__/getAsset.js

@@ -0,0 +1,64 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var chai_1 = require("chai");
+var mocha_1 = require("mocha");
+var init_1 = require("./init");
+(0, mocha_1.suite)("SDK: getAsset", function () {
+    (0, mocha_1.test)("Get Asset", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var tokenAddress, assetToGet, asset;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    tokenAddress = "0x059edd72cd353df5106d2b9cc5ab83a52287ac3a";
+                    assetToGet = {
+                        tokenAddress: tokenAddress,
+                        tokenId: "1",
+                    };
+                    return [4 /*yield*/, init_1.sdk.api.getAsset(assetToGet)];
+                case 1:
+                    asset = _a.sent();
+                    (0, chai_1.assert)(asset, "Asset should not be null");
+                    (0, chai_1.assert)(asset.assetContract.address === tokenAddress, "Contract address should match.");
+                    (0, chai_1.assert)(asset.animationUrl, "Animation URL should not be null");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+//# sourceMappingURL=getAsset.js.map

package/lib/__integration_tests__/getAsset.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getAsset.js","sourceRoot":"","sources":["../../src/__integration_tests__/getAsset.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6BAA8B;AAC9B,+BAAoC;AACpC,+BAA6B;AAE7B,IAAA,aAAK,EAAC,eAAe,EAAE;IACrB,IAAA,YAAI,EAAC,WAAW,EAAE;;;;;oBACV,YAAY,GAAG,4CAA4C,CAAC;oBAC5D,UAAU,GAAG;wBACjB,YAAY,cAAA;wBACZ,OAAO,EAAE,GAAG;qBACb,CAAC;oBACY,qBAAM,UAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAA;;oBAA1C,KAAK,GAAG,SAAkC;oBAChD,IAAA,aAAM,EAAC,KAAK,EAAE,0BAA0B,CAAC,CAAC;oBAC1C,IAAA,aAAM,EACJ,KAAK,CAAC,aAAa,CAAC,OAAO,KAAK,YAAY,EAC5C,gCAAgC,CACjC,CAAC;oBACF,IAAA,aAAM,EAAC,KAAK,CAAC,YAAY,EAAE,kCAAkC,CAAC,CAAC;;;;SAChE,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/lib/__integration_tests__/getCollection.d.ts

@@ -0,0 +1 @@
+export {};