# Configure a marketplace

### Prerequisites

Before getting started, make sure you have the following ready:

* [Create a Ternoa](/getting-started/wallets/ternoa-wallet.md) account with [Alphanet CAPS](broken://pages/ej9gceaLIhCN2PgUBh42)
* Install and set up your editor of choice (we will use Visual Studio Code \[VSC] in this tutorial)
* Install [NodeJS v.14+](https://nodejs.org/en/download/) & NPM
* [Install & initialize Ternoa-JS](/build-1/javascript/ternoa-js-library-utilities/installation-and-initialization.md)

### How to set the marketplace configuration on-chain?

This function updates the marketplace configuration on the Ternoa chain. It returns an object promise containing the MarketplaceConfigSetEvent provided by the Ternoa blockchain.

{% hint style="info" %}
Use your own account by updating the `//TernoaTestAccount` with your account seed when retrieving the keyring from the example below. **Replace the variables** according to your needs. The params of this extrinsic need to be provided in a specific format.&#x20;
{% endhint %}

To avoid any error, we strongly recommend you construct your params using the helpers we provide:

* **formatMarketplaceFee()** for both commission and listing fee.
* **formatMarketplaceAccountList()** for the account list.
* **formatMarketplaceOffchainData()** for the off-chain data.
* **formatMarketplaceCollectionList()** for the collection list.

```typescript
import {
    setMarketplaceConfiguration,
    initializeApi,
    getKeyringFromSeed,
    WaitUntil,
} from "ternoa-js";

//First import the helpers for every parameter you need. Helpers expect the values (strings, number, boolean (..)) and return the corresponding expected object.
import {
    formatMarketplaceFee,
    formatMarketplaceAccountList,
    formatMarketplaceOffchainData,
    formatMarketplaceCollectionList,
} from "ternoa-js/marketplace/utils";

const createContract = async () => {
    try {
        await initializeApi();
        const keyring = await getKeyringFromSeed("//TernoaTestAccount");
        const marketplaceId = //to be updated
        const offchainDataHash = //to be updated
        const collectionId = //to be updated
        const address = //to be updated

        // Here you create some constants with each helper and value you want. We use some random values:
        const formattedCommissionFee = formatMarketplaceFee(
            "set",
            "percentage",
            10
        );
        const formattedListingFee = formatMarketplaceFee("set", "flat", 100);
        const formattedAccountList = formatMarketplaceAccountList("set", [
            address,
        ]);
        const formattedOffchainData = formatMarketplaceOffchainData(
            "set",
            offchainDataHash
        );
        const formattedCollectionList = formatMarketplaceCollectionList(
            "set",
            [collectionId]
        );
        // Provide each const one by one as parameters in our function below:
        const mpEvent = await setMarketplaceConfiguration(
            marketplaceId,
            formattedCommissionFee,
            formattedListingFee,
            formattedAccountList,
            formattedOffchainData,
            formattedCollectionList,
            keyring,
            WaitUntil.BlockInclusion
        );

        console.log(`Marketplace: ${mpEvent.nftId} correctly updated`);
    } catch (e) {
        console.error(e);
    }
};
```

#### The expected params

The expected parameters for updating a marketplace are objects under a specific format. The best practice and the easiest way to create the parameters is to use the formatters we provide.

```markdown
Each of the parameters of the marketplace need one of the following types:
`Noop`: No Operation, nothing changes. Noop is set by default for each of the parameters.
`Remove`: Current data will be deleted.
`Set`: An object that updates the parameters value.

Param's detail:
`id`: Marketplace Id of the marketplace to update.
`commissionFee`:
The commission when an NFT is sold on the marketplace: it can be set as flat (in Big Number format) or as a percentage (in per mill format). Without using formatters, you can use the convertMarketplaceFee() function. Commission Fee and Listing Fee require a data type (flat or percentage) under format: { [MarketplaceConfigAction.Set]: { setFeeType: number || BN}}.
Again, the best practice is to use here the formatMarketplaceFee().
`listingFee`:
Fee when an NFT is added for sale to the marketplace: it can be set as flat (in Big Number format) or as a percentage (in per mill format). Without using formatters, you can use the convertMarketplaceFee() function. Commission Fee and Listing Fee require a data type (flat or percentage) under format: { [MarketplaceConfigAction.Set]: { setFeeType: number || BN}}.
Again, the best practice is to use here the formatMarketplaceFee().
`accountList`: A list of accounts: if the marketplace kind is private, it allows these accounts to sell NFT. If the marketplace kind is public, it bans these accounts from selling NFT. AccountList requires an array of string: { [MarketplaceConfigAction.Set]: string[]}. Again, the best practice is to use here the formatMarketplaceAccountList().
`offchainData`: Off-chain-related marketplace metadata. Can be an IPFS Hash, an URL, or plain text. OffChainData requires a string: { [MarketplaceConfigAction.Set]: string}.
Again, the best practice is to use here the formatMarketplaceOffchainData().
`collectionList`:A list of Collection Id: same as accountList, if the marketplace kind is private, the list is a whitelist and if the marketplace is public, the list bans the collection to be listed. CollectionList requires an array of numbers: { [MarketplaceConfigAction.Set]: number[]}. Again, the best practice is to use here the formatMarketplaceCollectionList().
`keyring`: The provided keyring (containing the address) will be used to sign the transaction and pay the execution fee.
`waitUntil`: WaitUntil defines at which point we want to get the results of the transaction execution: BlockInclusion or BlockFinalization.
```

#### Response

The response provided from the blockchain event includes all the information below according to the parameters provided when updating the marketplace.

```markdown
`marketplaceId`: the updated marketplace id.
`commissionFeeType`: If updated, the commission fee type: Flat or Percentage.
`commissionFee`: The commission fee value as a Big Number or a per mill.
`commissionFeeRounded`: The commission fee value as a number.
`listingFeeType`: If updated, the listing fee type: Flat or Percentage.
`listingFee`: The listing fee value as a Big Number or a per mill.
`listingFeeRounded`: The listing fee value as a number.
`accountList`: If available, the list of addresses.
`offchainData`: If available, the off-chain metadata (a string).
`collectionList`: If available, the list of collection id.
```

### Support

If you face any trouble, feel free to reach out to our community engineers in our [Discord](https://discord.gg/fUmBkPpnRu).


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.ternoa.network/build-1/javascript/nft-features-and-pallets/sale-your-nft/marketplace/configure-a-marketplace.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
