Discussed in #77

How is the category decided? For example this one has an "art" category. I know that the protocol doesn't have such a thing as "category", is this automatically classified by the Rarible backend?

How does one make sure their NFT gets assigned a category when minting using the protocol?

Hello,
we're using this endpoint, for example this one related to MAYC #27756:
https://ethereum-api.rarible.org/v0.1/nft/items/0x60e4d786628fea6478f785a6d7e704777c86a7c6:27756/meta

Yesterday when I've typed in the discord group, the PREVIEW section image.preview were not filled yet, but now seems working fine:

{"name":"MutantApeYachtClub #27756","attributes":[{"key":"Background","value":"M1 Aquamarine"},{"key":"Fur","value":"M1 Black"},{"key":"Mouth","value":"M1 Dumbfounded"},{"key":"Eyes","value":"M1 Robot"},{"key":"Clothes","value":"M1 Black Holes T"},{"key":"Hat","value":"M1 Bandana Blue"}],"image":{"url":{"ORIGINAL":"ipfs://ipfs/QmWqG4G6DaxD8Bi1Eeeu3JusBJ5XsVdTVT43hScZNHNbmF","BIG":"https://lh3.googleusercontent.com/69Qn4832Bw83jR7kfGbA7ixLlfrBYz2YJz6cEEJnAvCw8N8__YoKfEaiFHatFmVDwDimeVqldUWczjkYyxD4C6VnaIkHglQVU1Wu5Q","PREVIEW":"https://lh3.googleusercontent.com/69Qn4832Bw83jR7kfGbA7ixLlfrBYz2YJz6cEEJnAvCw8N8__YoKfEaiFHatFmVDwDimeVqldUWczjkYyxD4C6VnaIkHglQVU1Wu5Q=s250"},"meta":{"PREVIEW":{"type":"image/png","width":250,"height":250}}}}

May I ask how this work and how much time is needed for recover that infos? Or if is better use an alternative?
Thanks!

Hello, I am interested in deploying the Rarible Protocol on Fuse network EVM sidechain
I've already added support of Fuse network to Snapshot governance dApp and the Simple NFT example of Scaffold-eth which I've deployed on Fuse at https://fuse-nft.surge.sh
I have started by reading https://docs.rarible.org/ where I've discovered https://docs.rarible.org/starter-app to practice first on Ropsten testnet.
Then I will try to deploy locally as explained at https://github.com/rarible/protocol-contracts and will try to make starter-app work locally.

I've added other things to this Issue: #93

But I'll open a new one here.
OctoHeadz collection ( https://opensea.io/collection/octohedz ) didn't have the metadata refreshed properly.

I'm using Rarible SDK(0.6.1) to create NFT and Sell Order.
Below is my code for Mint and Sell

// minting

const nftCollection = await sdk.apis.nftCollection.getNftCollectionById({ collection: '0xF6793dA657495ffeFF9Ee6350824910Abc21356C' })  //used mainnet contract id

if(isErc721v1Collection(nftCollection)) {
      const resp = await sdk.nft.mint({
             collection: nftCollection,
                    uri: `/ipfs/${uri}`,
                    supply: 1,
             });
      dispatch(SudoActions.setMintState('2'));
      tokenId = resp.tokenId;
 } else if(isErc721v2Collection(nftCollection)) {
         const resp = await sdk.nft.mint({
                collection: nftCollection,
                uri: `/ipfs/${uri}`,
                royalties: [],
                creators: [{ account: toAddress(accounts[0]), value: 10000 }],
                royalties: [{ account: toAddress(accounts[0]), value: formInputs.price * 100 }],
                        lazy: true,
         });
         dispatch(SudoActions.setMintState('2'));
         tokenId = resp.tokenId;
} else if(isErc721v3Collection(nftCollection)) {
         const resp = await sdk.nft.mint({
                collection: nftCollection,
                uri: `/ipfs/${uri}`,
                creators: [{ account: toAddress(accounts[0]), value: 10000 }],
                royalties: [{ account: toAddress(accounts[0]), value: formInputs.price * 100 }],
                lazy: true,
          });
          dispatch(SudoActions.setMintState('2'));
          tokenId = resp.tokenId;
}




//sell order

const token = await sdk.apis.nftItem.getNftItemById({itemId: `0xF6793dA657495ffeFF9Ee6350824910Abc21356C:${tokenId}`});    //used mainnet 

const request = {
	makeAssetType: {
		assetClass: 'ERC721',
		contract: toAddress(token.contract),
		tokenId: toBigNumber(token.tokenId),
	},
	amount: 1,
	maker: toAddress(accounts[0]),
	originFees: [],
	payouts: [],
	price: formInputs.price * 10 ** 18,
	takeAssetType: { assetClass: "ETH" },
}

const resultOrder = await sdk.order.sell(request);

After minting I tried to buy NFT using SDK as like below...

const orders = await sdk.apis.order.getSellOrdersByItem({contract: contract_id, tokenId: token_id});
let order = resp.orders[0];

switch (order.type) {
      case "RARIBLE_V1":
             await sdk.order.fill({ order, amount: 1, originFee: 0 })
             break;
      case "RARIBLE_V2":
             await sdk.order.fill({ order, amount: 1, originFee: 0 })
             break;
      case "OPEN_SEA_V1":
             await sdk.order.fill({ order, amount: 1 })
             break;
 }

But I'm getting this issue - which require too much Gas Fee in meta mask.

As you can see, NFT price is 0.1 ETH but gas fee is too high...

Please help me what I'm missing to create NFT and Buy NFT here.
Thanks

I've been having difficulty filling bids on our app and tried using the example repo to see how the logic for filling bids works. However, the logic to fill bids in the example repo doesn't work either. The code for the example repo is here:

https://github.com/rarible/example

Behavior:

When I try to fill a bid, I get an error: transfer failed
https://rinkeby.etherscan.io/tx/0x3172f1c040a606b659a150abc36a638365b6468be748a14bcc974d1f9f02debe

For trying to fill the bid here: https://rinkeby.rarible.com/token/0x6ede7f3c26975aad32a475e1021d8f6f39c89d82:21578908932561758899859799426716046057317812514208370568897978054285555924994?tab=bids

Expected Behavior:

I'm able to accept the bid and receive Rinkeby ETH for the sale.

Steps to recreate:

1. Create a new lazy mint NFT
2. Connect with a new account and create a bid
3. Reconnect with the account that created the lazy NFT and fill the bid from the previous step

I believe the bids default to using ETH. The code for bidding specifically is in src/order/bid.tsx and looks like this:

import { IRaribleSdk } from "@rarible/sdk/build/domain"
import React from "react"
import { FormWithResult } from "../common/form-with-result"
import { PrepareForm } from "./prepare-form"
import { OrderForm } from "./form"

export function Bid({ sdk }: { sdk: IRaribleSdk }) {
	return (
		<FormWithResult
			renderForm={onSubmit => <PrepareForm onSubmit={onSubmit}/>}
			process={sdk.order.bid}
		>{prepareResponse => (
			<FormWithResult
				renderForm={onSubmit => <OrderForm onSubmit={onSubmit} response={prepareResponse}/>}
				process={prepareResponse.submit}
			>{orderId => <p>{orderId}</p>}</FormWithResult>
		)}</FormWithResult>
	)
}

Please keep in mind, I did not write this code, so I have no real insight on it other than looking at it and testing for accepting bids.

The feature request is to build two factory contracts as part of the rarible repo to include a vault factory contract to initiate fractionalization of any ERC721s and another factory contract to initiate auctions of any kind.
The overall features allows the development of a fully self-contained SDK to create & deploy an NFT store with features such as bid/ask; auctions; fractionalization; mint; royalties etc. to make a wordpress+shopify equivalent for creators in the NFT community.

Users are saying placeholder images for genesis galactic kings are not displaying properly. This collection was minted through opensea

Upgradeable contracts are a point of centralized power in the rarible protocol. Obviously, having a dao mitigates risks associated but most actual contract owners are priced out of voting - maybe there should be templates available (even in factory) where upgrades are controlled by contract owners? 🔥😘😊🎉🙇‍♂️

Discussed in #12

Hello Team, we (myself and Las Vegas) recently had a lazy minted NFT get bought/minted on chain as part of a token factory collection. Everything went smoothly on Rarible side now that we generated the collection via etherscan. However, upon looking at the item in opensea, some very strange things happening. Looks like opensea is parsing very oddly and instead picking up the cover image of the collection!

Here is the item on mainnet rarible:

https://rarible.com/token/0x957144608480ab2c964afe8ba3388b0bfdac8811:23203816277389531492177214940942028241142347653428038063978490842244439867393?tab=history

and here is the same item on opensea:

https://opensea.io/assets/0x957144608480ab2c964afe8ba3388b0bfdac8811/23203816277389531492177214940942028241142347653428038063978490842244439867393

please if anybody can help figure this out would be much appreciated. Not sure if this was Rarible side or Opensea but before we reach out to Opensea wanted to cross check with Rari team first. Thank you!

Users on our platform are saying they cannot trade their Sipherian Surge NFTs. PLease make update to indexer for this collection
https://opensea.io/collection/sipheriansurge

Some users are having issues with the Voxies collection of NFTs https://opensea.io/collection/voxies on the indexer. Please help, thank you

When we try to accept the latest Bid (0.23 ETH) for this token:
https://rarible.com/token/0xd07dc4262bcdbf85190c01c996b4c06a461d2430:127893?tab=bids,
the execution of the TX is reverted (approval succeeds)

I simulated the TX in tenderly, but do not fully understand the reason why it reverts:

I can re-simulate / debug / provide more stack if required.

I'm using rarible sdk in my React.js application to minting NFT.
To integrate buy order creation, I implemented Rarible SDK module on my application...

import React, { useCallback, useState } from 'react';
import { createRaribleSdk } from "@rarible/protocol-ethereum-sdk";
import Web3 from 'web3';
const web3 = new Web3(Web3.givenProvider || "ws://localhost:8545");

const buyComponent = () => {

const createBuyOrder = useCallback(() => {
   env = 'mainnet' || 'e2e' || 'ropsten' || 'rinkeby';     //mainly using 'mainnet'
   const sdk = createRaribleSdk(new Web3Ethereum({web3: web3}), env);
  
   const resp = await sdk.apis.order.getSellOrdersByItem({contract: contactId, tokenId: tokenId});
   await sdk.order.fill(
          resp.orders[0],
          { payouts: [], originFees: [], amount: 1, infinite: true }
        ).then(a => a.build().runAll())
}, []);

return(
<ComponentContent/>
)
}

export default buyComponent;

As like above code example, I figured out functions according to the docs.

But I got this kinds of issue...

So I updated my project devDepencies with

{
        "@rarible/action": "^0.2.7",
        "@rarible/protocol-api-client": "^0.1.7",
        "@rarible/protocol-ethereum-sdk": "^0.5.1",
        "@rarible/types": "^0.1.7",
        "@rarible/utils": "^0.0.3",
        "@rarible/web3-ethereum": "0.1.21",
        "@types/node-fetch": "2.5.12",
        "@types/web3-provider-engine": "^14.0.1",
        "ethereumjs-wallet": "1.0.1",
        "tslib": "2.3.1",
        "typescript": "4.3.5",
        "web3": "1.2.11",
        "web3-provider-engine": "16.0.1"
}

And updated fill function like this...

await sdk.order.fill(
        { order: resp.orders[0], payouts: [], originFee: resp.orders[0].data.originFees, amount: 1, infinite: true},
).then(a => a.build().runAll())

But I'm getting this error

How can I fix this issue?

Hello,
is possible to add a property in the JSON, in which the metadata are included, in which is possible to see if an asset is reported/banned due to a fraudulent activities ?

Take a look at this Bored Ape, already blocked here:
https://rarible.com/token/0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d:9564?tab=details

If you could add those infos here, in this call (and in the other in which you display the metadata) would be great:

https://ethereum-api.rarible.org/v0.1/nft/items/byOwner?owner=0xfcfb7c0954f5c82d1c81214560d540897ffd9aec&includeMeta=true

Thanks in advance.
Bruckzr

Hi everyone, the NFT below:
https://rinkeby.rarible.com/token/0x9e63dbccee84fcdd0e210340bfa0e3dc67566acb:5?tab=details
doesnt pull the metadata on Rinkeby, is it normal? @eduardstal suggested it might be related to the Indexer on Discord

I checked the SC on etherscan (Rinkeby)
https://rinkeby.etherscan.io/address/0x9e63dbCCeE84FCdd0E210340BFa0e3Dc67566aCb#readContract
and the URI is correct
ipfs://QmUdNQ63os5Gdh4FLfnsZ2CL2tKuQ8NRkRnwkNsJCETS9B/5.json

thanks for your help!

implement react hook to easily fetch data about NFT.
For example,
`
const { name, image } = useNft(contract, tokenId)
...

`

Hello, I have a strange problem using Rarepress, when ppl mint my lazy mint NFT.... the files (json, svg) disapears ... end up with a broken pic symbol ... I don't want to scam ppl so any help would be nice
I can recover .svg file upload it to http://nft.storage or pinata but not the .json generated on fly randomly...
the only way to recover it is to request your .. DB ...
this is an exemple of this strange behaviour :

https://rarible.com/token/0xf6793da657495ffeff9ee6350824910abc21356c:57984983039294568831114628287511357542976396324737856656918550448730070452499?tab=details

Best regards !!
Hope you'll understand my issue .. so lame ...

Issue posted by buddy#9879 in #dev-general, discord

Discussed in #86

Please update this collection for our users. Images are not correct. https://opensea.io/collection/cyberkongz

Hi, the indexer seems not be loading this full collection properly. https://opensea.io/collection/fewocious-x-rtfkt
Please update as some of our users are waiting on this. Thank you very much

I’m getting an error where nfts aren’t being transferred for sell orders and funds aren't being transferred to nft creoter - is there any issue with sdk / api right now? - code here - https://github.com/Screensaver-world/RaribleProtocol-Interface/blob/be238a4e8bbdfaea84ce0aeff7afbdf9ad124f29/src/pages/mint.tsx#L62

So after lazy minting sell order Is made using sdk (raribleSDK.order.sell)

Sell order request has this format:

  const request: SellRequest = {
      makeAssetType: {
        assetClass: 'ERC721',
        contract: toAddress(CONTRACT_ID),
        tokenId: toBigNumber(token.tokenId),
      },
      amount: 1,
      maker: toAddress(address),
      originFees: [],
      payouts: [],
      price: web3.utils.toWei(data.price.replace(',', '')).toString(),
      takeAssetType: { assetClass: data['price-currency'] },
    };

when matching order:

order/orders/${hash}/prepareTx - this endpoint is called with body provided below (maker is buyer’s address, amount is always 1)

{
    maker,
    amount,
    payouts: [],
    originFees: [],
  }

result is extracted and passed to web3.eth.sendTransaction(tx);

Hello,

Just notice that using your protocol only "ipfs pin add" on your local IPFS node without actually pinning it on the entire IPFS nodes don't really know if it ever pin it on your local IPFS Node...

It seems you use IPFS only for synchronizing and then the files are immediately deleted from Rarible’s IPFS node, and cached on Rarible’s CDN instead.

Are you working on it ?

Best regards

Royalties should always be paid out regardless of if it is the first sale or not. This is important if you are trying to split royalties amongst various creators or people who need to be paid out.

I'm trying to create a sell order from my front-end client on an RFC1155 token I own and I'm getting the following error:

{
  "code": "INCORRECT_LAZY_ASSET",
  "message": "Invalid signatures for creators [0x28d431d565b97815473a4773634acbfc1f12421b] for lazy asset on make side",
  "status": 400
}

Here's the code:

const orderBuilder = await raribleSdk.order.sell({
  makeAssetType: {
    assetClass: 'ERC1155',
    contract: toAddress(
      config.get('myown1155contractaddress')
    ),
    tokenId: toBigNumber(
      extractTokenIdFromItemId(nft.previewNft.itemId)
    ),
  },
  maker: toAddress(ownership.owner.ethAddress),
  amount: quantity,
  price: getValues('price'),
  payouts: [],
  originFees: [
    {
      account: toAddress(config.get('myownaddress')),
      value: 250,
    },
  ],
  takeAssetType: { assetClass: 'ETH' },
});

and here's the request I see in the browser:

{
  "maker": "0x28d431d565b97815473a4773634acbfc1f12421b",
  "make": {
    "assetType": {
      "@type": "ERC1155",
      "contract": "0x927b2ed99edd05a1fbef4de4e1775ada0901d4c2",
      "tokenId": "18467429459816144863947812166421793754398676185957064781363011930739185811472",
      "uri": "/ipfs/QmSsKPRpMwUHNT7fJDJQ3nRsBAJBNskeatbYhNtTKr9uL8",
      "creators": [
        {
          "account": "0x28d431d565b97815473a4773634acbfc1f12421b",
          "value": 10000
        }
      ],
      "royalties": [
        {
          "account": "0x28d431d565b97815473a4773634acbfc1f12421b",
          "value": 500
        },
        {
          "account": "0xee5f8c3e15b2d9280f060f01fc08c2f2f3b4476b",
          "value": 1000
        }
      ],
      "signatures": [
      "0x107899f9ff79bad2c9659c6154d661c5badf20daea4e6f5bcb820d5fe946674e47cb524e0f53842d1df04304ff65da14343a8cb2b5e2cc2b3f87c2f47d3face01c"
      ],
      "supply": "10",
      "assetClass": "ERC721_LAZY"
    },
    "value": "2"
  },
  "take": { "assetType": { "assetClass": "ETH" }, "value": "2" },
  "type": "RARIBLE_V2",
  "data": {
    "dataType": "RARIBLE_V2_DATA_V1",
    "payouts": [],
    "originFees": [
      { "account": "0x28d431d565b97815473a4773634acbfc1f12421b", "value": 250 }
    ]
  },
  "salt": "34945805662674558592829447995129376213206409534291223948514422231105297539999",
  "signature": "0x24bda6f87871cc6fbac173e60aa46b95847a42c1ac7097c5b59bb346289dd1a367272f444f15009d4d875570e154d51aabd1235ea44b3d635af46b20e87d6ee11b"
}

I'm 100% sure I own the NFT, so I'm not sure how the signature could be wrong. I set all this up by following the README on this repo and on the protocol-example repo. Am I sending wrong params when calling order.sell?

I do see "assetClass": "ERC721_LAZY" in the request body, which does seem completely wrong since I'm dealing with an 1155.

I think this one is pretty urgent as it prevents users from completing their purchases on both rinkeby and mainnet. Seems to be same issue impacting both.

There seems to be an issue with purchasing an NFT that was lazy minted into a custom Token Factory collection. Whether you try to purchase using API or rarible.com, the result is the same which is the contract throws an error.

An indicative item is here on rinkeby:

https://rinkeby.rarible.com/token/0x2c3b60c71d52a4a68aa7913909eb49adff47b641:11

it is part of this collection which was created via rinkeby.rarible.com UI for create a collection:

https://rinkeby.rarible.com/one2all

Hello, some users have said that they cannot see their Gen.Art NFTs are not displaying or showing up.
Please update this collection on the indexer https://opensea.io/collection/gen-dot-art Thank you

Discussed in #115

I've got an issue where a lazy minted NFT from Rarible ended up with a null creator on OpenSea after it was purchased and actually minted.

The expected behavior would be for it to show up in the OpenSea account for that user as the creator.

Rarible:
https://rarible.com/token/0xb66a603f4cfe17e3d27b87a8bfcad319856518b8:95765504400613452714159102908317164126071985149556277575149904226646891692033?tab=bids

OpenSea:
https://opensea.io/assets/0xb66a603f4cfe17e3d27b87a8bfcad319856518b8/95765504400613452714159102908317164126071985149556277575149904226646891692033

Etherscan:
https://etherscan.io/tx/0x3bdf52280d9c7dffec9cad23d6228a89583dff21db26ad50ee7cf39b5dc219e1

I just looked back at one of our first posts and it even got assigned to a totally random creator in OpenSea. https://discord.com/channels/846402262443491328/846458744560549968/860987953344807012

So overall, this happens randomly if it's this random creator or an empty creator.

Items that have been removed from Rarible.com are still being pulled by the indexer APIs.
(ie. Rarible | cocoNFT page)

You can see the cocoNFT page is pulling all of this info in from the protocol. It's a copyminter. I believe items like these should not appear in the indexer as the majority of them are either illegal activity and/or copyrighted material. If they are all being reported back to Rarible and removed, why make every user of the protocol redo that work and remove it from their platform?

Or a compromise would be some sort of flag on the API response such as hidden: true that way you can signify it's hidden on Rarible.com or something. Even an endpoint parameter where you can say you don't want any hidden items to be return in the response would be amazing. It'd be up to the consumer of the API to decide if they want to have Rarible.com controlling this field. If they don't they don't need to filter on that hidden flag and can just consume everything and have their own policies of hiding content.

Update to Original Post: the "cocoNFT Link" will no longer work. We built in our own hiding capability, but we have to hide individual posts as they crop up.

Hey,

We're integrating Rarible as a DAOHaus boost to allow DAOs to create sell/bid orders through proposals that can execute arbitrary contract calls using a Gnosis Safe "Minion". Everything seems to work fine when encoding and creating/posting orders through the minion. However, when trying to fill/execute an order through the Rarible UI, the following error is being raised: Execution reverted: ECDSA: invalid signature length, which seems odd as the maker address is a Gnosis Safe account. This kind of exception should be raised only if the signer is an EOA account but we signed the order using the Safe & EIP1271.

Here's an example of a sell order listed by a Gnosis Safe (0x40fad45a745b8026c7a...0a14) that fails when someone tries to fill that order:

• Collectible: https://rinkeby.rarible.com/token/0xb2f2950721ea31f835e46d4d7e431dd7af765367:0
• Order metadata: https://ipfs.io/ipfs/QmYBWWTG55XJLCD7nhPWLqtWH2NUny9DtjwZ86ERWABidS

I built a stack trace of the possible path within the contracts that makes the transaction throw an exception:

• Break 1: https://github.com/rarible/protocol-contracts/blob/7ae346d2181d2ffad7ccf02fb613c6af940ba057/exchange-v2/contracts/ExchangeV2Core.sol#L40
• Break 2: https://github.com/rarible/protocol-contracts/blob/7ae346d2181d2ffad7ccf02fb613c6af940ba057/exchange-v2/contracts/ExchangeV2Core.sol#L94
• Break 3: https://github.com/rarible/protocol-contracts/blob/7ae346d2181d2ffad7ccf02fb613c6af940ba057/exchange-v2/contracts/OrderValidator.sol#L25
• The ECDSA: invalid signature length error should appear only if the maker address is an EOA account
  https://github.com/rarible/protocol-contracts/blob/7ae346d2181d2ffad7ccf02fb613c6af940ba057/exchange-v2/contracts/OrderValidator.sol#L32

And here's a stack trace of the possible path within your SDK:

• Fill order https://github.com/rarible/protocol-ethereum-sdk/blob/fbf66a7e3a82e3f25ca0a4135b21f590e1da4bfc/packages/protocol-ethereum-sdk/src/order/fill-order/index.ts#L28
• Send Tx https://github.com/rarible/protocol-ethereum-sdk/blob/fbf66a7e3a82e3f25ca0a4135b21f590e1da4bfc/packages/protocol-ethereum-sdk/src/order/fill-order/index.ts#L80
• Call matchOrders on ExchangeV2: https://github.com/rarible/protocol-ethereum-sdk/blob/cda44c0eb84be3b805f57a3926e7016f134eaf38/packages/protocol-ethereum-sdk/src/order/fill-order/rarible-v2.ts#L46
  • Here's where I think the issue resides. Might be a wrong assignment of the maker address on the Left order

There is some issue while installing npm package @rarible/protocol-ethereum-sdk. I am getting error as '@rarible/utils@^0.0.7' is not in the npm registry. It was specified as a dependency of '@rarible/protocol-ethereum-sdk'.
Also the Npm site is showing error while visiting the page.

Context

We updated the DAO eip1271 interface to match how Gnosis has implemented it. However there is now an incompatabilty with the rarible API.

Rarible expects the EIP1271 signature to be 132 chars long (like 0xabc....def).

But Gnosis requires that the DAO's signature is a 0 length bytes array 0x.

Request

Could Rarible update the API so that "0x" signatures are not rejected by the schema validator? They will resolve the proper magic value on the isValidSignature call using the msg hash

Link to isValidSignature in Gnosis contracts: https://github.com/gnosis/safe-contracts/blob/34c87b783dfd04ff09ef7c358c3182c3c151e086/contracts/handler/CompatibilityFallbackHandler.sol#L32

Example request body to Rarible orders API that we would like to see succeed:

{
    "type": "RARIBLE_V2",
    "maker": "0x744222844bFeCC77156297a6427B5876A6769e19",
    "make": {
        "assetType": {
            "assetClass": "ERC721",
            "contract": "0xcfa14f6DC737b8f9e0fC39f05Bf3d903aC5D4575",
            "tokenId": 1
        },
        "value": "1"
    },
    "take": {
        "assetType": {
            "assetClass": "ETH"
        },
        "value": "1000000000000000000"
    },
    "data": {
        "dataType": "RARIBLE_V2_DATA_V1",
        "payouts": [],
        "originFees": []
    },
    "salt": "5422",
    "signature": "0x" // NOTE - 0 length signature
}

We would like to alert our users when an NFT is sold. This way we could send them a congratulatory email or something of that nature. This could be possible by having a webhook callback parameter in the sell order.

I uploaded the yaml spec to https://editor.swagger.io/, there are two errors:

Can you check it?

Hello Team, this is to document the request that we put in discord to manually remove a couple dozen stranded NFT's. This is related to #120 but in advance of that fix would be great to have these removed from rarible.com this week so we can proceed with minting a new collection for some existing buyers.

The stranded NFT's were a result of lazy minting to a UI generated collection. These are listed below. There are two additional NFT's that we want to burn and have actually burned one but it is still showing up in the indexer. any guidance on those two would also be much appreciated. Thank you!

Here is a list of the goats that need to be deleted:
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:79
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:80
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:81
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:82
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:83
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:84
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:85
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:86
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:87
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:88
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:89
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:90
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:91
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:92
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:93
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:94
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:95
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:96
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:97
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:98
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:99
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:100
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:101
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:102
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:103
https://rarible.com/token/0x9381114151db9ac55e935b2ae619c0bde6aa7223:104

This NFT was lazy minted to a token factory collection but was bought/minted on chain and then burned intentionally due to some faulty metadata. It doesn't seem to be disappearing from the indexer
https://rarible.com/token/0x957144608480ab2c964afe8ba3388b0bfdac8811:23203816277389531492177214940942028241142347653428038063978490842244439867394

And this one, but only after its owner burns it, we are waiting on confirmation that manual deletion is needed/possible before asking this buyer to burn:
https://rarible.com/token/0x957144608480ab2c964afe8ba3388b0bfdac8811:23203816277389531492177214940942028241142347653428038063978490842244439867393

Discussed in #60

Discussed in #106

{
    "tokenId": "51853873187524799243313032258623492611584136611923237689466576623960428904452",
    "signature": {
        "v": 28,
        "r": "0xe77b3fac57f71600d5f5017a3ff99f5ec00c32d4c3910078c2cc4af1be18acd6",
        "s": "0x77b647c58d87f59b3bc8fcb25c96861f79cc35dd475dc9f91ee75ee2a9eee259"
    }
}

Hello,
as suggested by @eduardstal we've used this endpoint: https://rarible.com/marketplace/api/v4/items/

We found an issue on a couple of assets, for example this one:
https://rarible.com/marketplace/api/v4/items/0x0938E3F7AC6D7f674FeD551c93f363109bda3AF9:761

{"code":"UnknownError","message":"E11000 duplicate key error collection: rarible.item index: token_1_tokenId_1 dup key: { token: "0x0938e3f7ac6d7f674fed551c93f363109bda3af9", tokenId: "761" }; nested exception is com.mongodb.MongoWriteException: E11000 duplicate key error collection: rarible.item index: token_1_tokenId_1 dup key: { token: "0x0938e3f7ac6d7f674fed551c93f363109bda3af9", tokenId: "761" }"}

Could you please check?

Thanks,
Bruckzr

Yes, I've added the code used from this repo and created a new issue in the protocol repo.

@Jshanks21
Could you share the code you trying to use?

Also, you can't make bids in ETH (only in WETH)
We should throw an error now if you try to do it (will add this error when you try to call SDK)

Originally posted by @evgenynacu in rarible/example#1 (comment)

I am using the transfer method with the updated package. I am getting a successful response through the transfer method, But eventually failing at etherscan.
Here is the Etherscan Link with the status code.

https://rinkeby.etherscan.io/tx/0xd6386ad21db56cd039cf19340cf8a59f2b9193e7229a892bce618c249e25b5bc

https://discord.com/channels/846402262443491328/887455535610343454/887793079044698152

I followed the instructions here to add Royalties to an external collection:

https://docs.rarible.org/asset/royalties-on-a-external-collection

Here is the transaction:

https://etherscan.io/tx/0xb5f625595fed64d629818401b61342d1f0443867fa866fe588d442f36804f834

But it has been days, and it is not reflected in the API:

https://ethereum-api.rarible.org/v0.1/nft/items/0x819327e005a3ed85f7b634e195b8f25d4a2a45f8:35739319466029867409935893104794648465119721019613204601875682368845852747852?includeMeta=true

Did I do something wrong, or is there a bug?

Discussed in #142 @tanishqsh

Error: Transaction has been reverted by the EVM:
Error: Transaction has been reverted by the EVM:
{
  "blockHash": "0xc4ca0ca1837d03ce0d3ac94d4746e5ae7f84ae5c9f7fb47d3f81243769d2dbf9",
  "blockNumber": 11298400,
  "contractAddress": null,
  "cumulativeGasUsed": 375369,
  "effectiveGasPrice": "0x9502f909",
  "from": "0x4ec03e45bc4a600fee319250acfa3131207b0807",
  "gasUsed": 33282,
  "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
  "status": false,
  "to": "0x6a94ac200342ac823f909f142a65232e2f052183",
  "transactionHash": "0xab3a0a19051b8d7681cb07e0c08915b093bd1e12ab7c3d03d444cb29aee177dc",
  "transactionIndex": 9,
  "type": "0x2",
  "events": {}
}

function mint(nft) {
		const sampleURI = '/ipfs/QmYgvjcGzWW6ruxcEKb69gLHEMetfFKw93Ffvaa2cqeqU3';
		const RARIBLE_ERC_1155_ROPSTEN_ADDRESS = '0x6a94aC200342AC823F909F142a65232E2f052183';

		async function mintNow() {
			let loadingID = toast.loading('Minting please wait');
			const minter = currentUser?.publicAddress;

			const path = `https://ethereum-api-dev.rarible.org/v0.1/nft/collections/${RARIBLE_ERC_1155_ROPSTEN_ADDRESS}/generate_token_id?minter=${minter}`;

			// console.log('path', path);
			console.log('path', path);

			// get the next available token ID from the contrat
			const response = await axios.get(path);
			console.log('response', response);

			// set the user address from which to send the transaction
			const fromAddress = currentUser?.publicAddress;
			console.log('fromAddress', fromAddress);


			// store the id in the variable
			const tokenId = response.data.tokenId;
			console.log('TokenID', tokenId);
			console.log(typeof tokenId);

			// get the contract initialized
			console.log('JSON:', abi);
			const contract = new web3.eth.Contract([abi], RARIBLE_ERC_1155_ROPSTEN_ADDRESS);

			// use web3 to get the balance
			const balance = await web3.eth.getBalance(fromAddress);
			console.log('Balance', balance);

			const tx = contract.methods
				.mintAndTransfer(
					[tokenId, sampleURI, 1, [[fromAddress, 10000]], [[fromAddress, 1000]], ['0x']],
					fromAddress, 1
				)
				.send({ from: fromAddress })
				.on('transactionHash', function (hash) {
					console.log('hash', hash);
				})
				.on('confirmation', function (confirmationNumber, receipt) {
					console.log('confirmation', confirmationNumber, receipt);
				})
				.on('receipt', function (receipt) {
					// receipt example
					console.log(receipt);
				})
				.on('error', function (error) {
					console.log(error);
				});

			toast.dismiss(loadingID);
		}
		mintNow();
	}
		

Post to the rinkby lazy mint fails with 500 internal server error

Body of Post to ethereum-api-staging.rarible.org/v0.1/nft/mints:
{"@type":"ERC721","contract":"0xf565108F208136B1AffD55d19A6236b6b6b9786D","tokenURI":"/ipfs/QmQMid5Nbaqi8M4FNho2aBPDyixU4JozX2Rx2LoijHWheg","uri":"/ipfs/QmQMid5Nbaqi8M4FNho2aBPDyixU4JozX2Rx2LoijHWheg","tokenId":"51853873187524799243313032258623492611584136611923237689466576623960428904451","creators":[{"account":"0x72A4408DA42DE870499c1841D0e4a49f864e34ba","value":10000}],"royalties":[{"account":"0x72A4408DA42DE870499c1841D0e4a49f864e34ba","value":20000}],"signatures":["0xed332bffa0de8d64a9ea456b2af82dfb81b683adc2b1f11c5b90fb53004f6edd10ac667f2bb7aeab55b70ade99b1cd253094958932d487cacd6a61b461d04ce92c"]}

Initialized Rarible on rinkeby (chain ID: 4) with basePath https://ethereum-api-staging.rarible.org/
Collection Address: 0xf565108F208136B1AffD55d19A6236b6b6b9786D - https://rinkeby.rarible.com/collection/0xf565108F208136B1AffD55d19A6236b6b6b9786D
Minter Wallet address: 0x72A4408DA42DE870499c1841D0e4a49f864e34ba

Suspects

• I still have a bad signature?
• Or the collection from the token factory has not properly been deployed?