Class MarketplaceV3DirectListings<TContract>

Handles direct listings

Type Parameters

TContract extends DirectListingsLogic

Hierarchy

MarketplaceV3DirectListings

Implements

DetectableFeature

Constructors

constructor

new MarketplaceV3DirectListings<TContract>(contractWrapper, storage): MarketplaceV3DirectListings<TContract>
Type Parameters
- TContract extends DirectListingsLogic
Parameters
- contractWrapper: ContractWrapper<TContract>
- storage: ThirdwebStorage<IpfsUploadBatchOptions>
Returns MarketplaceV3DirectListings<TContract>
- Defined in packages/sdk/src/evm/core/classes/marketplacev3-direct-listings.ts:67

Properties

approveBuyerForReservedListing

approveBuyerForReservedListing: {
prepare: ((...args) => Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>);
(...args): Promise<TResult>;
} = ...

Type declaration

- (...args): Promise<TResult>
- Approve buyer for a reserved direct listing
  Parameters
  - Rest ...args: [listingId: BigNumberish, buyer: string]
  Returns Promise<TResult>
  Remarks
  Approve a buyer to buy from a reserved listing.
  
  Example
```
// The listing ID of the direct listing you want to approve buyer for
const listingId = "0";

await contract.directListings.approveBuyerForReservedListing(listingId, "{{wallet_address}}");
```
  Twfeature
  DirectListings
prepare: ((...args) => Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>)
- - (...args): Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>
  - Parameters
    - Rest ...args: [listingId: BigNumberish, buyer: string]
    Returns Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>

approveCurrencyForListing

approveCurrencyForListing: {
prepare: ((...args) => Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>);
(...args): Promise<TResult>;
} = ...

Type declaration

- (...args): Promise<TResult>
- Approve a currency for a direct listing
  Parameters
  - Rest ...args: [listingId: BigNumberish, currencyContractAddress: string, pricePerTokenInCurrency: BigNumberish]
  Returns Promise<TResult>
  Example
```
// The listing ID of the direct listing you want to approve currency for
const listingId = "0";

await contract.directListings.approveCurrencyForListing(listingId, currencyContractAddress, pricePerTokenInCurrency);
```
  Twfeature
  DirectListings
prepare: ((...args) => Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>)
- - (...args): Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>
  - Parameters
    - Rest ...args: [listingId: BigNumberish, currencyContractAddress: string, pricePerTokenInCurrency: BigNumberish]
    Returns Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>

buyFromListing

buyFromListing: {
prepare: ((...args) => Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>);
(...args): Promise<TResult>;
} = ...

Type declaration

- (...args): Promise<TResult>
- Buy direct listing for a specific wallet
  Parameters
  - Rest ...args: [listingId: BigNumberish, quantityDesired: BigNumberish, receiver?: string]
  Returns Promise<TResult>
  Remarks
  Buy from a specific direct listing from the marketplace.
  
  Example
```
// The ID of the listing you want to buy from
const listingId = 0;
// Quantity of the asset you want to buy
const quantityDesired = 1;

await contract.directListings.buyFromListing(listingId, quantityDesired, "{{wallet_address}}");
```
  Twfeature
  DirectListings
prepare: ((...args) => Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>)
- - (...args): Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>
  - Parameters
    - Rest ...args: [listingId: BigNumberish, quantityDesired: BigNumberish, receiver?: string]
    Returns Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>

cancelListing

cancelListing: {
prepare: ((...args) => Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>);
(...args): Promise<TResult>;
} = ...

Type declaration

- (...args): Promise<TResult>
- Cancel Direct Listing
  Parameters
  - Rest ...args: [listingId: BigNumberish]
  Returns Promise<TResult>
  Remarks
  Cancel a direct listing on the marketplace
  
  Example
```
// The listing ID of the direct listing you want to cancel
const listingId = 0;

await contract.directListings.cancelListing(listingId);
```
  Twfeature
  DirectListings
prepare: ((...args) => Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>)
- - (...args): Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>
  - Parameters
    - Rest ...args: [listingId: BigNumberish]
    Returns Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>

`Private` contractWrapper

contractWrapper: ContractWrapper<DirectListingsLogic>

createListing

createListing: {
prepare: ((...args) => Promise<Transaction<TransactionResultWithId>>);
(...args): Promise<TResult>;
} = ...

Type declaration

(...args): Promise<TResult>

Create new direct listing

Parameters

Rest ...args: [listing: {
    assetContractAddress: string;
    currencyContractAddress?: string;
    endTimestamp?: number | Date;
    isReservedListing?: boolean;
    pricePerToken: string | number;
    quantity?: string | number | bigint | BigNumber;
    startTimestamp?: number | Date;
    tokenId: Object;
}]

Returns Promise<TResult>

Remarks

Create a new listing on the marketplace where people can buy an asset directly.

Example

// Data of the listing you want to create
const listing = {
  // address of the contract the asset you want to list is on
  assetContractAddress: "0x...",
  // token ID of the asset you want to list
  tokenId: "0",
  // how many of the asset you want to list
  quantity: 1,
  // address of the currency contract that will be used to pay for the listing
  currencyContractAddress: NATIVE_TOKEN_ADDRESS,
  // The price to pay per unit of NFTs listed.
  pricePerToken: 1.5,
  // when should the listing open up for offers
  startTimestamp: new Date(Date.now()),
  // how long the listing will be open for
  endTimestamp: new Date(Date.now() + 5 * 24 * 60 * 60 * 1000),
  // Whether the listing is reserved for a specific set of buyers.
  isReservedListing: false
}

const tx = await contract.directListings.createListing(listing);
const receipt = tx.receipt; // the transaction receipt
const id = tx.id; // the id of the newly created listing

Twfeature

DirectListings

prepare: ((...args) => Promise<Transaction<TransactionResultWithId>>)
- - (...args): Promise<Transaction<TransactionResultWithId>>
  - Parameters
    - Rest ...args: [listing: {
          assetContractAddress: string;
          currencyContractAddress?: string;
          endTimestamp?: number | Date;
          isReservedListing?: boolean;
          pricePerToken: string | number;
          quantity?: string | number | bigint | BigNumber;
          startTimestamp?: number | Date;
          tokenId: Object;
      }]
    Returns Promise<Transaction<TransactionResultWithId>>

createListingsBatch

createListingsBatch: {
prepare: ((...args) => Promise<Transaction<TransactionResultWithId[]>>);
(...args): Promise<TResult>;
} = ...

Type declaration

- (...args): Promise<TResult>
- Create a batch of new listings
  Parameters
  - Rest ...args: [listings: {
        assetContractAddress: string;
        currencyContractAddress?: string;
        endTimestamp?: number | Date;
        isReservedListing?: boolean;
        pricePerToken: string | number;
        quantity?: string | number | bigint | BigNumber;
        startTimestamp?: number | Date;
        tokenId: Object;
    }[]]
  Returns Promise<TResult>
  Remarks
  Create a batch of new listings on the marketplace
  
  Example
```
const listings = [...];
const tx = await contract.directListings.createListingsBatch(listings);
```
prepare: ((...args) => Promise<Transaction<TransactionResultWithId[]>>)
- - (...args): Promise<Transaction<TransactionResultWithId[]>>
  - Parameters
    - Rest ...args: [listings: {
          assetContractAddress: string;
          currencyContractAddress?: string;
          endTimestamp?: number | Date;
          isReservedListing?: boolean;
          pricePerToken: string | number;
          quantity?: string | number | bigint | BigNumber;
          startTimestamp?: number | Date;
          tokenId: Object;
      }[]]
    Returns Promise<Transaction<TransactionResultWithId[]>>

encoder

encoder: ContractEncoder<DirectListingsLogic>

estimator

estimator: GasCostEstimator<DirectListingsLogic>

events

events: ContractEvents<DirectListingsLogic>

featureName

featureName: "DirectListings" = FEATURE_DIRECT_LISTINGS.name

interceptor

interceptor: ContractInterceptor<DirectListingsLogic>

revokeBuyerApprovalForReservedListing

revokeBuyerApprovalForReservedListing: {
prepare: ((...args) => Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>);
(...args): Promise<TResult>;
} = ...

Type declaration

(...args): Promise<TResult>

Revoke approval of a buyer for a reserved direct listing

Parameters

Rest ...args: [listingId: BigNumberish, buyer: string]

Returns Promise<TResult>

Example

// The listing ID of the direct listing you want to approve buyer for
const listingId = "0";

await contract.directListings.revokeBuyerApprovalForReservedListing(listingId, "{{wallet_address}}");

prepare: ((...args) => Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>)
- - (...args): Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>
  - Parameters
    - Rest ...args: [listingId: BigNumberish, buyer: string]
    Returns Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>

revokeCurrencyApprovalForListing

revokeCurrencyApprovalForListing: {
prepare: ((...args) => Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>);
(...args): Promise<TResult>;
} = ...

Type declaration

- (...args): Promise<TResult>
- Revoke approval of a currency for a direct listing
  Parameters
  - Rest ...args: [listingId: BigNumberish, currencyContractAddress: string]
  Returns Promise<TResult>
  Example
```
// The listing ID of the direct listing you want to revoke currency for
const listingId = "0";

await contract.directListings.revokeCurrencyApprovalForListing(listingId, currencyContractAddress);
```
  Twfeature
  DirectListings
prepare: ((...args) => Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>)
- - (...args): Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>
  - Parameters
    - Rest ...args: [listingId: BigNumberish, currencyContractAddress: string]
    Returns Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>

`Private` storage

storage: ThirdwebStorage<IpfsUploadBatchOptions>

updateListing

updateListing: {
prepare: ((...args) => Promise<Transaction<TransactionResultWithId>>);
(...args): Promise<TResult>;
} = ...

Type declaration

(...args): Promise<TResult>

Update a direct listing

Parameters

Rest ...args: [listingId: BigNumberish, listing: {
    assetContractAddress: string;
    currencyContractAddress?: string;
    endTimestamp?: number | Date;
    isReservedListing?: boolean;
    pricePerToken: string | number;
    quantity?: string | number | bigint | BigNumber;
    startTimestamp?: number | Date;
    tokenId: Object;
}]

Returns Promise<TResult>

Example

// Data of the listing you want to update

const listingId = 0; // ID of the listing you want to update

const listing = {
  // address of the contract the asset you want to list is on
  assetContractAddress: "0x...", // should be same as original listing
  // token ID of the asset you want to list
  tokenId: "0", // should be same as original listing
  // how many of the asset you want to list
  quantity: 1,
  // address of the currency contract that will be used to pay for the listing
  currencyContractAddress: NATIVE_TOKEN_ADDRESS,
  // The price to pay per unit of NFTs listed.
  pricePerToken: 1.5,
  // when should the listing open up for offers
  startTimestamp: new Date(Date.now()), // can't change this if listing already active
  // how long the listing will be open for
  endTimestamp: new Date(Date.now() + 5 * 24 * 60 * 60 * 1000),
  // Whether the listing is reserved for a specific set of buyers.
  isReservedListing: false
}

const tx = await contract.directListings.updateListing(listingId, listing);
const receipt = tx.receipt; // the transaction receipt
const id = tx.id; // the id of the newly created listing

Twfeature

DirectListings

prepare: ((...args) => Promise<Transaction<TransactionResultWithId>>)
- - (...args): Promise<Transaction<TransactionResultWithId>>
  - Parameters
    - Rest ...args: [listingId: BigNumberish, listing: {
          assetContractAddress: string;
          currencyContractAddress?: string;
          endTimestamp?: number | Date;
          isReservedListing?: boolean;
          pricePerToken: string | number;
          quantity?: string | number | bigint | BigNumber;
          startTimestamp?: number | Date;
          tokenId: Object;
      }]
    Returns Promise<Transaction<TransactionResultWithId>>

Methods

`Private` applyFilter

applyFilter(listings, filter?): Promise<ListingStructOutput[]>
Parameters
- listings: ListingStructOutput[]
- Optional filter: MarketplaceFilterWithoutOfferor
Returns Promise<ListingStructOutput[]>
- Defined in packages/sdk/src/evm/core/classes/marketplacev3-direct-listings.ts:955

currencyPriceForListing

currencyPriceForListing(listingId, currencyContractAddress): Promise<BigNumberish>
Check price per token for an approved currency
Parameters
- listingId: BigNumberish
  the listing id
- currencyContractAddress: string
  currency contract address
Returns Promise<BigNumberish>
Example
```
const listingId = 0;
const currencyContractAddress = '0x1234';
const price = await contract.directListings.currencyPriceForListing(listingId, currencyContractAddress);
```
Twfeature
DirectListings
- Defined in packages/sdk/src/evm/core/classes/marketplacev3-direct-listings.ts:273

getAddress

getAddress(): string
Returns string
- Defined in packages/sdk/src/evm/core/classes/marketplacev3-direct-listings.ts:80

getAll

getAll(filter?): Promise<DirectListingV3[]>
Get all direct listings
Parameters
- Optional filter: MarketplaceFilterWithoutOfferor
  optional filter parameters
Returns Promise<DirectListingV3[]>
the Direct listing object array
Example
```
const listings = await contract.directListings.getAll();
```
Twfeature
DirectListings
- Defined in packages/sdk/src/evm/core/classes/marketplacev3-direct-listings.ts:116

getAllValid

getAllValid(filter?): Promise<DirectListingV3[]>
Get all valid direct listings
Parameters
- Optional filter: MarketplaceFilterWithoutOfferor
  optional filter parameters
Returns Promise<DirectListingV3[]>
the Direct listing object array
Remarks
A valid listing is where the listing is active, and the creator still owns & has approved Marketplace to transfer the listed NFTs.

Example
```
const listings = await contract.directListings.getAllValid();
```
Twfeature
DirectListings
- Defined in packages/sdk/src/evm/core/classes/marketplacev3-direct-listings.ts:155

getListing

getListing(listingId): Promise<DirectListingV3>
Get a single direct listing
Parameters
- listingId: BigNumberish
  the listing id
Returns Promise<DirectListingV3>
the Direct listing object
Example
```
const listingId = 0;
const listing = await contract.directListings.getListing(listingId);
```
Example
```
const listingId = 0;
const listing = await contract.directListings.getListing(listingId);
```
Twfeature
DirectListings
- Defined in packages/sdk/src/evm/core/classes/marketplacev3-direct-listings.ts:199

getTotalCount

getTotalCount(): Promise<BigNumber>
Get the total number of direct listings

Returns Promise<BigNumber>
Returns the total number of direct listings created.
Example
```
const totalListings = await contract.directListings.getTotalCount();
```
Twfeature
DirectListings
- Defined in packages/sdk/src/evm/core/classes/marketplacev3-direct-listings.ts:100

isBuyerApprovedForListing

isBuyerApprovedForListing(listingId, buyer): Promise<boolean>

Check if a buyer is approved for a specific direct listing

Parameters

listingId: BigNumberish
buyer: string

Returns Promise<boolean>

Example

const listingId = 0;
const isBuyerApproved = await contract.directListings.isBuyerApprovedForListing(listingId, "{{wallet_address}}");

@param listingId - the listing id
@param buyer - buyer address
@twfeature DirectListings

isCurrencyApprovedForListing

isCurrencyApprovedForListing(listingId, currency): Promise<boolean>
Check if a currency is approved for a specific direct listing
Parameters
- listingId: BigNumberish
  the listing id
- currency: string
  currency address
Returns Promise<boolean>
Example
```
const listingId = 0;
const currencyContractAddress = '0x1234';
const isApproved = await contract.directListings.isCurrencyApprovedForListing(listingId, currencyContractAddress);
```
Twfeature
DirectListings
- Defined in packages/sdk/src/evm/core/classes/marketplacev3-direct-listings.ts:247

`Private` validateListing

validateListing(listingId): Promise<DirectListingV3>
Throws error if listing could not be found
Parameters
- listingId: BigNumber
  Listing to check for
Returns Promise<DirectListingV3>
- Defined in packages/sdk/src/evm/core/classes/marketplacev3-direct-listings.ts:795

Class MarketplaceV3DirectListings<TContract>

Type Parameters

TContract extends DirectListingsLogic

Hierarchy

Implements

Index

Constructors

Properties

Methods

Constructors

constructor

Type Parameters

TContract extends DirectListingsLogic

Parameters

contractWrapper: ContractWrapper<TContract>

storage: ThirdwebStorage<IpfsUploadBatchOptions>

Returns MarketplaceV3DirectListings<TContract>

Properties

approveBuyerForReservedListing

Type declaration

Parameters

Rest ...args: [listingId: BigNumberish, buyer: string]

Returns Promise<TResult>

Remarks

Example

Twfeature

prepare: ((...args) => Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>)

Parameters

Rest ...args: [listingId: BigNumberish, buyer: string]

Returns Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>

approveCurrencyForListing

Type declaration

Parameters

Rest ...args: [listingId: BigNumberish, currencyContractAddress: string, pricePerTokenInCurrency: BigNumberish]

Returns Promise<TResult>

Example

Twfeature

prepare: ((...args) => Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>)

Parameters

Rest ...args: [listingId: BigNumberish, currencyContractAddress: string, pricePerTokenInCurrency: BigNumberish]

Returns Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>

buyFromListing

Type declaration

Parameters

Rest ...args: [listingId: BigNumberish, quantityDesired: BigNumberish, receiver?: string]

Returns Promise<TResult>

Remarks

Example

Twfeature

prepare: ((...args) => Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>)

Parameters

Rest ...args: [listingId: BigNumberish, quantityDesired: BigNumberish, receiver?: string]

Returns Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>

cancelListing

Type declaration

Parameters

Rest ...args: [listingId: BigNumberish]

Returns Promise<TResult>

Remarks

Example

Twfeature

prepare: ((...args) => Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>)

Parameters

Rest ...args: [listingId: BigNumberish]

Returns Promise<Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>>

Private contractWrapper

createListing

Type declaration

Parameters

Rest ...args: [listing: { assetContractAddress: string; currencyContractAddress?: string; endTimestamp?: number | Date; isReservedListing?: boolean; pricePerToken: string | number; quantity?: string | number | bigint | BigNumber; startTimestamp?: number | Date; tokenId: Object; }]

Returns Promise<TResult>

Remarks

Example

Twfeature

prepare: ((...args) => Promise<Transaction<TransactionResultWithId>>)

Parameters

Rest ...args: [listing: { assetContractAddress: string; currencyContractAddress?: string; endTimestamp?: number | Date; isReservedListing?: boolean; pricePerToken: string | number; quantity?: string | number | bigint | BigNumber; startTimestamp?: number | Date; tokenId: Object; }]

Returns Promise<Transaction<TransactionResultWithId>>

createListingsBatch

Type declaration

`Rest` ...args: [listingId: BigNumberish, buyer: string]

`Rest` ...args: [listingId: BigNumberish, buyer: string]

`Rest` ...args: [listingId: BigNumberish, currencyContractAddress: string, pricePerTokenInCurrency: BigNumberish]

`Rest` ...args: [listingId: BigNumberish, currencyContractAddress: string, pricePerTokenInCurrency: BigNumberish]

`Rest` ...args: [listingId: BigNumberish, quantityDesired: BigNumberish, receiver?: string]

`Rest` ...args: [listingId: BigNumberish, quantityDesired: BigNumberish, receiver?: string]

`Rest` ...args: [listingId: BigNumberish]

`Rest` ...args: [listingId: BigNumberish]

`Private` contractWrapper

`Rest` ...args: [listing: {
assetContractAddress: string;
currencyContractAddress?: string;
endTimestamp?: number | Date;
isReservedListing?: boolean;
pricePerToken: string | number;
quantity?: string | number | bigint | BigNumber;
startTimestamp?: number | Date;
tokenId: Object;
}]

`Rest` ...args: [listing: {
assetContractAddress: string;
currencyContractAddress?: string;
endTimestamp?: number | Date;
isReservedListing?: boolean;
pricePerToken: string | number;
quantity?: string | number | bigint | BigNumber;
startTimestamp?: number | Date;
tokenId: Object;
}]

`Rest` ...args: [listings: {
assetContractAddress: string;
currencyContractAddress?: string;
endTimestamp?: number | Date;
isReservedListing?: boolean;
pricePerToken: string | number;
quantity?: string | number | bigint | BigNumber;
startTimestamp?: number | Date;
tokenId: Object;
}[]]

`Rest` ...args: [listings: {
assetContractAddress: string;
currencyContractAddress?: string;
endTimestamp?: number | Date;
isReservedListing?: boolean;
pricePerToken: string | number;
quantity?: string | number | bigint | BigNumber;
startTimestamp?: number | Date;
tokenId: Object;
}[]]

`Rest` ...args: [listingId: BigNumberish, buyer: string]

`Rest` ...args: [listingId: BigNumberish, buyer: string]

`Rest` ...args: [listingId: BigNumberish, currencyContractAddress: string]

`Rest` ...args: [listingId: BigNumberish, currencyContractAddress: string]

`Private` storage

`Private` applyFilter

`Optional` filter: MarketplaceFilterWithoutOfferor

`Optional` filter: MarketplaceFilterWithoutOfferor