Bad Request with Creating Opensea Listing

[0xAskar]

Hi, I'm trying to create a listing using seaport api. However, I've been staring at my code for a while now, and can't list this nft. I created parameters and generated the signature. Not sure why I'm getting a 400 bad request. Any help would be appreciated. Here's my code:

Edit: added consideration for original creator and subtracted that from the first consideration. I am still getting a 400 bad request error though.

Edit 2: removed code in question, code in answer more relevant and helpful

[0xAskar]

Ok, after a while of trying to figure out a possible way to list on Opensea and help, I found a way to list assets on Opensea.

1. The structure is creating a order structure that is compatible with the signOrder from Seaport which generates the signature from the user.
2. Then, send that order and signature into the api route https://api.opensea.io/v2/orders/ethereum/seaport/listings.

Important Notes: However, the structure of order requires slightly different types for some of the parameters of the order. So, you can see in the code below the changes made. In order to list on Opensea, the Opensea fee and creator fee need to included and subtracted from the original listing price. The counter isn't supposed to be included as part of the parameters in the first order structure for seaport, but then it needs to be included for the api in the same structure.

Learn more about signOrder and the structure of orderParameters.

Pro: it works. Con: requires API key, relies on Opensea Api.

Code:

export async function listNFT(contract_address, token_id, listing_price, endTimeSeconds) {
        // create seaport instance 
        const provider = new ethers.providers.Web3Provider(window.ethereum);
        const seaport = new Seaport(provider);
        // get seller and prices
        let seller = await getBuyer()
        let royalty_info = await getRoyaltyInfo(contract_address)
        let prices = calculatePrices(listing_price, royalty_info.royalty_fee)
        if (prices === -1) {return}
        // create the parameters for the order
        let new_parameters = {
            offerer: seller,
            offer: [
                {
                    itemType: 2,
                    token: contract_address,
                    identifierOrCriteria: token_id,
                    startAmount: "1",
                    endAmount: "1"
                }],
            consideration: [
                {
                    itemType: 0,
                    token: "0x0000000000000000000000000000000000000000",
                    identifierOrCriteria: "0",
                    startAmount: prices.listing_profit,
                    endAmount: prices.listing_profit,
                    recipient: seller 
                },
                {
                    itemType: 0,
                    token: "0x0000000000000000000000000000000000000000",
                    identifierOrCriteria: "0",
                    startAmount: prices.opensea_fee,
                    endAmount: prices.opensea_fee,
                    recipient: "0x8De9C5A032463C561423387a9648c5C7BCC5BC90" 
                },
                {
                    itemType: 0,
                    token: "0x0000000000000000000000000000000000000000",
                    identifierOrCriteria: "0",
                    startAmount: prices.royalty_fee,
                    endAmount: prices.royalty_fee,
                    recipient: royalty_info.royalty_address 
                }],
            startTime: ethers.BigNumber.from((Math.floor(new Date().getTime() / 1000)).toString()),
            endTime: ethers.BigNumber.from((Math.floor((new Date().getTime() / 1000) + 60*60*endTimeSeconds)).toString()),
            orderType: 2,
            zone: "0x004C00500000aD104D7DBd00e3ae0A5C00560C00",
            zoneHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
            salt: "30158852458975423",
            conduitKey: "0x0000007b02230091a7ed01230072f7006a004d60a8d4e71d599b8104250f0000",
            totalOriginalConsiderationItems: ethers.BigNumber.from("3"),
        }
        const getSign = async(parameters) => {
            let counter = 0
            let signature = await seaport.signOrder(parameters, counter)
            parameters["counter"] = counter
            return {
                parameters: parameters, 
                signature: signature
            }
        }
        const sendToApi = async(order) => {
            let api_params = order["parameters"]
            api_params.startTime = api_params.startTime.toString()
            api_params.endTime = api_params.endTime.toString()
            api_params.totalOriginalConsiderationItems = api_params.totalOriginalConsiderationItems.toNumber()
            order["parameters"] = api_params
            const options = {
                method: 'POST',
                headers: {
                Accept: 'application/json',
                'X-API-KEY': process.env.NEXT_PUBLIC_OPENSEAS_API_KEY,
                'Content-Type': 'application/json'
                },
                body: JSON.stringify(order)
            };
            fetch('https://api.opensea.io/v2/orders/ethereum/seaport/listings', options)
            .then(response => response.json())
            .then(response => console.log(response))
            .catch(err => console.error(err));
        }
        let order = await getSign(new_parameters)
        await sendToApi(order)

[ajaybha]

Dear @0xAskar
I am trying something similar - to create a listing on Opensea testnet and would like to take your sample code and change it for Polygon Mumbai & Opensea v2 testnet.

I had been trying to get more info about this case earlier here - so this discussion & your work is really helpful.

I am wondering if you can help explain the network specific addresses you have used in the code sample above and where I could find the polygon Mumbai specific ones.

TIA,
Ajay

[0xAskar]

Hi @ajaybha, unforunately, I have not used those other testnets. However, in their Discord, some people may be able to help. I'm sorry I can help more on this issue. I found those network specific addresses from asking in the Discord and from examples from their Seaport Docs

[qnft-mjb]

@0xAskar Hey, this ticket was super helpful in clarifying that seaport order vs the opensea order. Spent a good chunk of time trying to figure out why my createOrders w/ seaport were just showing up on opensea. Was curious though, could you give a little more detail on how you calculate consideration 2 and 3 - You hand in returns, but what calculation is in that function? Also how do you determine item 2 recipient? I've seen 0x0000a26b00c1f0df003000390027140000faa719 as the fee address ?

[0xAskar]

Glad to see it helped. So, I had a custom function that I used to calculate the price. Let me know if that works for you. The address 0x8De9C5A032463C561423387a9648c5C7BCC5BC90 is the fee address that is required in order for your listing to show on Opensea as that worked for me. I looked up your address and mine, and it looks like both addresses seem to be fee addreses. (Go to etherscan and click on internal transactions). So maybe they have multiple?

This should just be a global variable. I'm working on community docs, if you think that would be helpful to have. Let me know, also let me know if you have any other questions.

function calculatePrices(listing_price, royalty) {
        try {
            let opensea_fee = (listing_price * 0.025).toFixed(18)
            let royalty_fee = (listing_price / (1/(royalty / 100 / 100))).toFixed(18) // 100 cause percent comes in *100
            let listing_profit = ethers.utils.parseEther(String((listing_price - opensea_fee - royalty_fee).toFixed(18)))
            return {
                listing_profit: listing_profit.toString(),
                royalty_fee: ethers.utils.parseEther(String(royalty_fee)).toString(),
                opensea_fee: ethers.utils.parseEther(String(opensea_fee)).toString()
            }
        }
        catch (error) {
            alert("Error: Listing Price")
            console.log(error)
            return -1
        }
    }
    ```

[qnft-mjb]

Thanks for your function description! I discovered I'd you getCollection you can access the fee and royalty address as well as the fee and royal basis points which you can use to calculate the actual payouts!

I'm now using seaport-js createOrder and getting what appears to be a perfect order model. When using opensea API to try to list that offer order I'm getting a 500 error message "we encountered a problem processing your request, please try again later" which isn't helpful and super frustrating...

Someone on discord suggested there could be an issue with the signature but I can't figure it out, you haven't ran into anything like this is your attempts have you? (I saw your other issue thread about listing)

[0xAskar]

That's dope! Could you provide an example how you used getCollection and calculate the basis points?

The 500 error I did get once. This was when I was JSON.stringify the parameters and signature already after it has already been stringified. So, double check the types and structures of your order and more importantly your signature that they're not double stringed or, that you did appropriately stringify the content.

[qnft-mjb]

@0xAskar the 500 error is solved. Such a dumb mistake... I was taking the returned order object and updating it. (changing the conduitKey to opensea's) - so the order I was submitting didn't match the signed order... conduitKey is an optional arg of seaport.createOrder. .... 🤦‍♂️

Then I got errors with the fees I was calculating, but solved that faster. Took the above mentioned basis points and write new objects of type Fee imported from seaport. That object interface just takes a recipient and basis points. List them in your consideration array and submit order and boom! 💥

function to get basis points

private async getConsiderations( collection: string) {

    const collectionUrl = `${this.CONFIG.API_URL}/v1/collection/${collection}`;
    const response = await axios.get<any>(collectionUrl, {
      headers: { 'X-API-KEY': this.CONFIG.API_KEY },
    });

    const collectionObject = response.data.collection
    const feeAddresses = Object.keys(collectionObject.fees?.opensea_fees)
    const openseaAddress = feeAddresses[0]
    const royaltyAddress = collectionObject.payout_address
    

    return {
      royaltyPayout: royaltyAddress,
      royaltyBasis: collectionObject.dev_seller_fee_basis_points,
      feePayout: openseaAddress,
      feeBasis: collectionObject.opensea_seller_fee_basis_points
    }
  }

creating order

const OSfee: Fee = {
      recipient: considerations.feePayout,
      basisPoints: considerations.feeBasis
    }
    const royalties: Fee = {
      recipient: considerations.royaltyPayout,
      basisPoints: considerations.royaltyBasis
    }

    const { executeAllActions } = await this.seaport_v2.createOrder(
      {
        conduitKey: '0x0000007b02230091a7ed01230072f7006a004d60a8d4e71d599b8104250f0000',
        offer: [
          {
            amount: amountInWei.toString(),
            token: WrappedEthContract.address,
          },
        ],
        consideration: [
          tokenOnBid
        ],
        fees: [
          OSfee,
          royalties
        ],
        endTime: Math.round(Date.now() / 1000 + 60 * expireMinutes).toString()
      },
      offerer,
    );
    const order = await executeAllActions();

Hope this helps!

[UmerKhanWazir]

@0xAskar All the errors from my side are solved and now it gives this error "We encountered an exception while processing your request. Please try again later." with error:500
I am currently sending the request from the opensea documentation section where opensea has this feature of sending request. Need help here.

[UmerKhanWazir]

@0xAskar All the errors from my side are solved and now it gives this error "We encountered an exception while processing your request. Please try again later." with error:500 I am currently sending the request from the opensea documentation section where opensea has this feature of sending request. Need help here.

Solved just had to convert the starttime and endtime in seconds instead of miliseconds/nanoseconds

[wainesiro]

How did you make the signature. I am using the same and it shows me invalid signature even though everything else is correct