10001695517

Committed 19 Jul 2024 02:41AM UTC coverage: 66.384% (-0.08%) from 66.468%

Build # 10001695517

Build Type

Pull #2270

github

Committed by

meelrossi

Commit Message

feat: show correctly bids on nfts

Pull Request Pull Request #2270: feat: show correctly bids on nfts

Run Details

2635 of 5159 branches covered (51.08%)

Branch coverage included in aggregate %.

12 of 33 new or added lines in 8 files covered. (36.36%)

1 existing line in 1 file now uncovered.

7711 of 10426 relevant lines covered (73.96%)

77.95 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

53.66

/webapp/src/modules/bid/sagas.ts

import { History } from 'history'
import { takeEvery, put, select, call, all, getContext } from 'redux-saga/effects'
import { Bid, RentalStatus, Trade, TradeCreation } from '@dcl/schemas'
import { showToast } from 'decentraland-dapps/dist/modules/toast/actions'
import { waitForTx } from 'decentraland-dapps/dist/modules/transaction/utils'
import { t } from 'decentraland-dapps/dist/modules/translation/utils'
import { sendTransaction } from 'decentraland-dapps/dist/modules/wallet/utils'
import { ContractData, ContractName, getContract as getDCLContract } from 'decentraland-transactions'
import { isErrorWithMessage } from '../../lib/error'
import * as tradeUtils from '../../utils/trades'
import { isNFT } from '../asset/utils'
import { getContract } from '../contract/selectors'
import { getIsBidsOffChainEnabled } from '../features/selectors'
import { getCurrentNFT } from '../nft/selectors'
import { getRentalById } from '../rental/selectors'
import { isRentalListingOpen, waitUntilRentalChangesStatus } from '../rental/utils'
import { locations } from '../routing/locations'
import { getBidPlacedSuccessToast } from '../toast/toasts'
import { MarketplaceAPI } from '../vendor/decentraland/marketplace/api'
import { VendorName } from '../vendor/types'
import { VendorFactory } from '../vendor/VendorFactory'
import { getWallet } from '../wallet/selectors'
import {
  PLACE_BID_REQUEST,
  PlaceBidRequestAction,
  placeBidFailure,
  placeBidSuccess,
  FETCH_BIDS_BY_ADDRESS_REQUEST,
  fetchBidsByAddressSuccess,
  fetchBidsByAddressFailure,
  FetchBidsByAddressRequestAction,
  ACCEPT_BID_REQUEST,
  CANCEL_BID_REQUEST,
  AcceptBidRequestAction,
  acceptBidSuccess,
  acceptBidFailure,
  CancelBidRequestAction,
  cancelBidSuccess,
  cancelBidFailure,
  FETCH_BIDS_BY_ASSET_REQUEST,
  FetchBidsByAssetRequestAction,
  fetchBidsByAssetSuccess,
  fetchBidsByAssetFailure,
  acceptBidtransactionSubmitted
} from './actions'
import * as bidUtils from './utils'

export function* bidSaga(marketplaceAPI: MarketplaceAPI) {
  yield takeEvery(PLACE_BID_REQUEST, handlePlaceBidRequest)
  yield takeEvery(ACCEPT_BID_REQUEST, handleAcceptBidRequest)
  yield takeEvery(CANCEL_BID_REQUEST, handleCancelBidRequest)
  yield takeEvery(FETCH_BIDS_BY_ADDRESS_REQUEST, handleFetchBidsByAddressRequest)
  yield takeEvery(FETCH_BIDS_BY_ASSET_REQUEST, handleFetchBidsByAssetRequest)

  function* handlePlaceBidRequest(action: PlaceBidRequestAction) {
    const { asset, price, expiresAt, fingerprint } = action.payload
    try {
      const wallet = (yield select(getWallet)) as ReturnType<typeof getWallet>
      if (!wallet) {
        throw new Error("Can't place a bid without a wallet")
      }

      const isBidsOffchainEnabled: boolean = yield select(getIsBidsOffChainEnabled)

      if (isBidsOffchainEnabled) {
        const history: History = yield getContext('history')
        const trade: TradeCreation = yield call([bidUtils, 'createBidTrade'], asset, price, expiresAt, fingerprint)
        yield call([marketplaceAPI, 'addTrade'], trade)
        yield put(placeBidSuccess(asset, price, expiresAt, asset.chainId, wallet.address, fingerprint))
        yield put(showToast(getBidPlacedSuccessToast(asset)))
        history.push(
          isNFT(asset) ? locations.nft(asset.contractAddress, asset.tokenId) : locations.item(asset.contractAddress, asset.itemId)
        )
      } else {
        if (isNFT(asset)) {
          const { bidService } = VendorFactory.build(asset.vendor)

          if (!bidService) {
            throw new Error("Couldn't find a valid bid service for vendor")
          }
          const txHash = (yield call([bidService, 'place'], wallet, asset, price, expiresAt, fingerprint)) as Awaited<
            ReturnType<typeof bidService.place>
          >
          yield put(placeBidSuccess(asset, price, expiresAt, asset.chainId, wallet.address, fingerprint, txHash))
        } else {
          throw new Error('Only NFTs are supported for bidding')
        }
      }
    } catch (error) {
      yield put(
        placeBidFailure(asset, price, expiresAt, isErrorWithMessage(error) ? error.message : t('global.unknown_error'), fingerprint)
      )
    }
  }

  function* handleAcceptBidRequest(action: AcceptBidRequestAction) {
    const { bid } = action.payload
    let txHash = ''
    try {
      const isBidsOffchainEnabled: boolean = yield select(getIsBidsOffChainEnabled)
      if ('tradeId' in bid) {
        if (isBidsOffchainEnabled) {
          const trade: Trade = yield call([marketplaceAPI, 'fetchTrade'], bid.tradeId)
          const tradeToAccept = tradeUtils.getTradeToAccept(trade)
          const offchainMarketplaceContract: ContractData = yield call(getDCLContract, ContractName.OffChainMarketplace, trade.chainId)
          txHash = yield call(
            sendTransaction as (contract: ContractData, contractMethodName: string, ...contractArguments: any[]) => Promise<string>,
            offchainMarketplaceContract,
            'function accept(Trade[] calldata _trades) external;',
            [tradeToAccept]
          )
        } else {
          throw new Error('not able to accept offchain bids')
        }
      } else {
        const contract = (yield select(getContract, {
          address: bid.contractAddress
        })) as ReturnType<typeof getContract>
        if (!contract || !contract.vendor) {
          throw new Error(
            contract
              ? `Couldn't find a valid vendor for contract ${contract?.address}`
              : `Couldn't find a valid vendor for contract ${bid.contractAddress}`
          )
        }
        const vendor = (yield call([VendorFactory, 'build'], contract.vendor)) as ReturnType<typeof VendorFactory.build>
        if (!vendor.bidService) {
          throw new Error("Couldn't find a valid bid service for vendor")
        }

        const wallet = (yield select(getWallet)) as ReturnType<typeof getWallet>
        txHash = (yield call([vendor.bidService, 'accept'], wallet, bid)) as Awaited<ReturnType<typeof vendor.bidService.accept>>
      }

      yield put(acceptBidtransactionSubmitted(bid, txHash))
      const nft = (yield select(getCurrentNFT)) as ReturnType<typeof getCurrentNFT>
      if (nft?.openRentalId) {
        yield call(waitForTx, txHash)
        const rental = (yield select(getRentalById, nft.openRentalId)) as ReturnType<typeof getRentalById>
        if (isRentalListingOpen(rental)) {
          yield call(waitUntilRentalChangesStatus, nft, RentalStatus.CANCELLED)
        }
      }

      yield put(acceptBidSuccess(bid))
    } catch (error) {
      yield put(acceptBidFailure(bid, isErrorWithMessage(error) ? error.message : t('global.unknown_error')))
    }
  }

  function* handleCancelBidRequest(action: CancelBidRequestAction) {
    const { bid } = action.payload
    try {
      const contract = (yield select(getContract, {
        address: bid.contractAddress
      })) as ReturnType<typeof getContract>

      if (!contract || !contract.vendor) {
        throw new Error(`Couldn't find a valid vendor for contract ${contract?.address}`)
      }
      const { bidService } = VendorFactory.build(contract.vendor)
      if (!bidService) {
        throw new Error("Couldn't find a valid bid service for vendor")
      }

      const wallet = (yield select(getWallet)) as ReturnType<typeof getWallet>
      const txHash = (yield call([bidService, 'cancel'], wallet, bid)) as Awaited<ReturnType<typeof bidService.cancel>>

      yield put(cancelBidSuccess(bid, txHash))
    } catch (error) {
      yield put(cancelBidFailure(bid, isErrorWithMessage(error) ? error.message : t('global.unknown_error')))
    }
  }

  function* handleFetchBidsByAddressRequest(action: FetchBidsByAddressRequestAction) {
    const { address } = action.payload
    try {
      let sellerBids: Bid[] = []
      let bidderBids: Bid[] = []

      const isBidsOffchainEnabled: boolean = yield select(getIsBidsOffChainEnabled)
      if (isBidsOffchainEnabled) {
        const bids = (yield all([
          call([marketplaceAPI, 'fetchBids'], { seller: address }),
          call([marketplaceAPI, 'fetchBids'], { bidder: address })
        ])) as [Awaited<ReturnType<typeof marketplaceAPI.fetchBids>>, Awaited<ReturnType<typeof marketplaceAPI.fetchBids>>]
        sellerBids = bids[0].results
        bidderBids = bids[1].results
      } else {
        for (const vendorName of Object.values(VendorName)) {
          const { bidService } = VendorFactory.build(vendorName)
          if (bidService === undefined) {
            continue
          }

          const bids = (yield all([call([bidService, 'fetchBySeller'], address), call([bidService, 'fetchByBidder'], address)])) as [
            Awaited<ReturnType<typeof bidService.fetchBySeller>>,
            Awaited<ReturnType<typeof bidService.fetchByBidder>>
          ]
          sellerBids = sellerBids.concat(bids[0])
          bidderBids = bidderBids.concat(bids[1])
        }
      }
      yield put(fetchBidsByAddressSuccess(address, sellerBids, bidderBids))
    } catch (error) {
      yield put(fetchBidsByAddressFailure(address, isErrorWithMessage(error) ? error.message : t('global.unknown_error')))
    }
  }

  function* handleFetchBidsByAssetRequest(action: FetchBidsByAssetRequestAction) {
    const { asset } = action.payload
    let bids: Bid[] = []
    try {
      const isBidsOffchainEnabled: boolean = yield select(getIsBidsOffChainEnabled)
      if (isBidsOffchainEnabled) {
        const response: Awaited<ReturnType<typeof marketplaceAPI.fetchBids>> = yield call([marketplaceAPI, 'fetchBids'], {
          contractAddress: asset.contractAddress,
          ...(isNFT(asset) ? { tokenId: asset.tokenId } : { itemId: asset.itemId })
        })
        bids = response.results
      } else if (isNFT(asset)) {
        const { bidService } = VendorFactory.build(asset.vendor)
        if (!bidService) {
          throw new Error("Couldn't find a valid bid service for vendor")
        }

        bids = (yield call([bidService, 'fetchByNFT'], asset)) as Awaited<ReturnType<typeof bidService.fetchByNFT>>
      }

      yield put(fetchBidsByAssetSuccess(asset, bids))
    } catch (error) {
      yield put(fetchBidsByAssetFailure(asset, isErrorWithMessage(error) ? error.message : t('global.unknown_error')))
    }
  }
}

1	import { History } from 'history'
2	import { takeEvery, put, select, call, all, getContext } from 'redux-saga/effects'	32✔
3	import { Bid, RentalStatus, Trade, TradeCreation } from '@dcl/schemas'	32✔
4	import { showToast } from 'decentraland-dapps/dist/modules/toast/actions'	32✔
5	import { waitForTx } from 'decentraland-dapps/dist/modules/transaction/utils'	32✔
6	import { t } from 'decentraland-dapps/dist/modules/translation/utils'	32✔
7	import { sendTransaction } from 'decentraland-dapps/dist/modules/wallet/utils'	32✔
8	import { ContractData, ContractName, getContract as getDCLContract } from 'decentraland-transactions'	32✔
9	import { isErrorWithMessage } from '../../lib/error'	32✔
10	import * as tradeUtils from '../../utils/trades'	32✔
11	import { isNFT } from '../asset/utils'	32✔
12	import { getContract } from '../contract/selectors'	32✔
13	import { getIsBidsOffChainEnabled } from '../features/selectors'	32✔
14	import { getCurrentNFT } from '../nft/selectors'	32✔
15	import { getRentalById } from '../rental/selectors'	32✔
16	import { isRentalListingOpen, waitUntilRentalChangesStatus } from '../rental/utils'	32✔
17	import { locations } from '../routing/locations'	32✔
18	import { getBidPlacedSuccessToast } from '../toast/toasts'	32✔
19	import { MarketplaceAPI } from '../vendor/decentraland/marketplace/api'
20	import { VendorName } from '../vendor/types'	32✔
21	import { VendorFactory } from '../vendor/VendorFactory'	32✔
22	import { getWallet } from '../wallet/selectors'	32✔
23	import {
24	PLACE_BID_REQUEST,
25	PlaceBidRequestAction,
26	placeBidFailure,
27	placeBidSuccess,
28	FETCH_BIDS_BY_ADDRESS_REQUEST,
29	fetchBidsByAddressSuccess,
30	fetchBidsByAddressFailure,
31	FetchBidsByAddressRequestAction,
32	ACCEPT_BID_REQUEST,
33	CANCEL_BID_REQUEST,
34	AcceptBidRequestAction,
35	acceptBidSuccess,
36	acceptBidFailure,
37	CancelBidRequestAction,
38	cancelBidSuccess,
39	cancelBidFailure,
40	FETCH_BIDS_BY_ASSET_REQUEST,
41	FetchBidsByAssetRequestAction,
42	fetchBidsByAssetSuccess,
43	fetchBidsByAssetFailure,
44	acceptBidtransactionSubmitted
45	} from './actions'	32✔
46	import * as bidUtils from './utils'	32✔
47
48	export function* bidSaga(marketplaceAPI: MarketplaceAPI) {	264✔
49	yield takeEvery(PLACE_BID_REQUEST, handlePlaceBidRequest)	264✔
50	yield takeEvery(ACCEPT_BID_REQUEST, handleAcceptBidRequest)	264✔
51	yield takeEvery(CANCEL_BID_REQUEST, handleCancelBidRequest)	264✔
52	yield takeEvery(FETCH_BIDS_BY_ADDRESS_REQUEST, handleFetchBidsByAddressRequest)	264✔
53	yield takeEvery(FETCH_BIDS_BY_ASSET_REQUEST, handleFetchBidsByAssetRequest)	264✔
54
55	function* handlePlaceBidRequest(action: PlaceBidRequestAction) {
56	const { asset, price, expiresAt, fingerprint } = action.payload	6✔
57	try {	6✔
58	const wallet = (yield select(getWallet)) as ReturnType<typeof getWallet>	6✔
59	if (!wallet) {	6!
60	throw new Error("Can't place a bid without a wallet")	×
61	}
62
63	const isBidsOffchainEnabled: boolean = yield select(getIsBidsOffChainEnabled)	6✔
64
65	if (isBidsOffchainEnabled) {	6✔
66	const history: History = yield getContext('history')	4✔
67	const trade: TradeCreation = yield call([bidUtils, 'createBidTrade'], asset, price, expiresAt, fingerprint)	4✔
68	yield call([marketplaceAPI, 'addTrade'], trade)	4✔
69	yield put(placeBidSuccess(asset, price, expiresAt, asset.chainId, wallet.address, fingerprint))	2✔
70	yield put(showToast(getBidPlacedSuccessToast(asset)))	2✔
71	history.push(	2✔
72	isNFT(asset) ? locations.nft(asset.contractAddress, asset.tokenId) : locations.item(asset.contractAddress, asset.itemId)	×
73	)
74	} else {
75	if (isNFT(asset)) {	2✔
76	const { bidService } = VendorFactory.build(asset.vendor)	1✔
77
78	if (!bidService) {	1!
79	throw new Error("Couldn't find a valid bid service for vendor")	×
80	}
81	const txHash = (yield call([bidService, 'place'], wallet, asset, price, expiresAt, fingerprint)) as Awaited<	1✔
82	ReturnType<typeof bidService.place>
83	>
84	yield put(placeBidSuccess(asset, price, expiresAt, asset.chainId, wallet.address, fingerprint, txHash))	1✔
85	} else {
86	throw new Error('Only NFTs are supported for bidding')	1✔
87	}
88	}
89	} catch (error) {
90	yield put(	5✔
91	placeBidFailure(asset, price, expiresAt, isErrorWithMessage(error) ? error.message : t('global.unknown_error'), fingerprint)	5!
92	)
93	}
94	}
95
96	function* handleAcceptBidRequest(action: AcceptBidRequestAction) {
97	const { bid } = action.payload	8✔
98	let txHash = ''	8✔
99	try {	8✔
100	const isBidsOffchainEnabled: boolean = yield select(getIsBidsOffChainEnabled)	8✔
101	if ('tradeId' in bid) {	8✔
102	if (isBidsOffchainEnabled) {	2!
103	const trade: Trade = yield call([marketplaceAPI, 'fetchTrade'], bid.tradeId)	2✔
104	const tradeToAccept = tradeUtils.getTradeToAccept(trade)	1✔
105	const offchainMarketplaceContract: ContractData = yield call(getDCLContract, ContractName.OffChainMarketplace, trade.chainId)	1✔
106	txHash = yield call(	1✔
107	sendTransaction as (contract: ContractData, contractMethodName: string, ...contractArguments: any[]) => Promise<string>,
108	offchainMarketplaceContract,
109	'function accept(Trade[] calldata _trades) external;',
110	[tradeToAccept]
111	)
112	} else {
113	throw new Error('not able to accept offchain bids')	×
114	}
115	} else {
116	const contract = (yield select(getContract, {	6✔
117	address: bid.contractAddress
118	})) as ReturnType<typeof getContract>
119	if (!contract \|\| !contract.vendor) {	6✔
120	throw new Error(	1✔
121	contract	1!
122	? `Couldn't find a valid vendor for contract ${contract?.address}`
123	: `Couldn't find a valid vendor for contract ${bid.contractAddress}`
124	)
125	}
126	const vendor = (yield call([VendorFactory, 'build'], contract.vendor)) as ReturnType<typeof VendorFactory.build>	5✔
127	if (!vendor.bidService) {	4!
128	throw new Error("Couldn't find a valid bid service for vendor")	×
129	}
130
131	const wallet = (yield select(getWallet)) as ReturnType<typeof getWallet>	4✔
132	txHash = (yield call([vendor.bidService, 'accept'], wallet, bid)) as Awaited<ReturnType<typeof vendor.bidService.accept>>	4✔
133	}
134
135	yield put(acceptBidtransactionSubmitted(bid, txHash))	4✔
136	const nft = (yield select(getCurrentNFT)) as ReturnType<typeof getCurrentNFT>	4✔
137	if (nft?.openRentalId) {	4✔
138	yield call(waitForTx, txHash)	2✔
139	const rental = (yield select(getRentalById, nft.openRentalId)) as ReturnType<typeof getRentalById>	1✔
140	if (isRentalListingOpen(rental)) {	1✔
141	yield call(waitUntilRentalChangesStatus, nft, RentalStatus.CANCELLED)	1✔
142	}
143	}
144
145	yield put(acceptBidSuccess(bid))	3✔
146	} catch (error) {
147	yield put(acceptBidFailure(bid, isErrorWithMessage(error) ? error.message : t('global.unknown_error')))	5!
148	}
149	}
150
151	function* handleCancelBidRequest(action: CancelBidRequestAction) {
152	const { bid } = action.payload	×
153	try {	×
154	const contract = (yield select(getContract, {	×
155	address: bid.contractAddress
156	})) as ReturnType<typeof getContract>
157
158	if (!contract \|\| !contract.vendor) {	×
159	throw new Error(`Couldn't find a valid vendor for contract ${contract?.address}`)	×
160	}
161	const { bidService } = VendorFactory.build(contract.vendor)	×
162	if (!bidService) {	×
163	throw new Error("Couldn't find a valid bid service for vendor")	×
164	}
165
166	const wallet = (yield select(getWallet)) as ReturnType<typeof getWallet>	×
167	const txHash = (yield call([bidService, 'cancel'], wallet, bid)) as Awaited<ReturnType<typeof bidService.cancel>>	×
168
169	yield put(cancelBidSuccess(bid, txHash))	×
170	} catch (error) {
171	yield put(cancelBidFailure(bid, isErrorWithMessage(error) ? error.message : t('global.unknown_error')))	×
172	}
173	}
174
175	function* handleFetchBidsByAddressRequest(action: FetchBidsByAddressRequestAction) {
176	const { address } = action.payload	×
177	try {	×
178	let sellerBids: Bid[] = []	×
179	let bidderBids: Bid[] = []	×
180
181	const isBidsOffchainEnabled: boolean = yield select(getIsBidsOffChainEnabled)	×
182	if (isBidsOffchainEnabled) {	×
183	const bids = (yield all([	×
184	call([marketplaceAPI, 'fetchBids'], { seller: address }),
185	call([marketplaceAPI, 'fetchBids'], { bidder: address })
186	])) as [Awaited<ReturnType<typeof marketplaceAPI.fetchBids>>, Awaited<ReturnType<typeof marketplaceAPI.fetchBids>>]
187	sellerBids = bids[0].results	×
188	bidderBids = bids[1].results	×
189	} else {
190	for (const vendorName of Object.values(VendorName)) {	×
191	const { bidService } = VendorFactory.build(vendorName)	×
192	if (bidService === undefined) {	×
193	continue	×
194	}
195
196	const bids = (yield all([call([bidService, 'fetchBySeller'], address), call([bidService, 'fetchByBidder'], address)])) as [	×
197	Awaited<ReturnType<typeof bidService.fetchBySeller>>,
198	Awaited<ReturnType<typeof bidService.fetchByBidder>>
199	]
200	sellerBids = sellerBids.concat(bids[0])	×
201	bidderBids = bidderBids.concat(bids[1])	×
202	}
203	}
204	yield put(fetchBidsByAddressSuccess(address, sellerBids, bidderBids))	×
205	} catch (error) {
206	yield put(fetchBidsByAddressFailure(address, isErrorWithMessage(error) ? error.message : t('global.unknown_error')))	×
207	}
208	}
209
210	function* handleFetchBidsByAssetRequest(action: FetchBidsByAssetRequestAction) {
NEW 211	const { asset } = action.payload	×
NEW 212	let bids: Bid[] = []	×
213	try {	×
NEW 214	const isBidsOffchainEnabled: boolean = yield select(getIsBidsOffChainEnabled)	×
NEW 215	if (isBidsOffchainEnabled) {	×
NEW 216	const response: Awaited<ReturnType<typeof marketplaceAPI.fetchBids>> = yield call([marketplaceAPI, 'fetchBids'], {	×
217	contractAddress: asset.contractAddress,
218	...(isNFT(asset) ? { tokenId: asset.tokenId } : { itemId: asset.itemId })	×
219	})
NEW 220	bids = response.results	×
NEW 221	} else if (isNFT(asset)) {	×
NEW 222	const { bidService } = VendorFactory.build(asset.vendor)	×
NEW 223	if (!bidService) {	×
NEW 224	throw new Error("Couldn't find a valid bid service for vendor")	×
225	}
226
NEW 227	bids = (yield call([bidService, 'fetchByNFT'], asset)) as Awaited<ReturnType<typeof bidService.fetchByNFT>>	×
228	}
229
NEW 230	yield put(fetchBidsByAssetSuccess(asset, bids))	×
231	} catch (error) {
NEW 232	yield put(fetchBidsByAssetFailure(asset, isErrorWithMessage(error) ? error.message : t('global.unknown_error')))	×
233	}
234	}
235	}

decentraland / marketplace / 10001695517

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous