10032223872

Committed 21 Jul 2024 11:42PM UTC coverage: 66.605% (+0.04%) from 66.57%

Build # 10032223872

Build Type

push

github

Committed by

web-flow

Commit Message

feat: add cancel bids logic (#2269)

Run Details

2644 of 5155 branches covered (51.29%)

Branch coverage included in aggregate %.

48 of 62 new or added lines in 7 files covered. (77.42%)

14 existing lines in 6 files now uncovered.

7745 of 10443 relevant lines covered (74.16%)

77.64 hits per line

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

70.0

/webapp/src/modules/vendor/decentraland/BidService.ts

import { parseUnits } from '@ethersproject/units'
import { Bid, GetBidsParameters, ListingStatus, Network } from '@dcl/schemas'
import { Wallet } from 'decentraland-dapps/dist/modules/wallet/types'
import { sendTransaction } from 'decentraland-dapps/dist/modules/wallet/utils'
import { ContractData, ContractName, getContract } from 'decentraland-transactions'
import { NFT } from '../../nft/types'
import { BidService as BidServiceInterface } from '../services'
import { VendorName } from '../types'
import { bidAPI } from './bid/api'
import { marketplaceAPI } from './marketplace/api'
import { getERC721ContractData } from './utils'

export class BidService implements BidServiceInterface<VendorName.DECENTRALAND> {
  async fetchBySeller(seller: string) {
    const bids = await bidAPI.fetchBySeller(seller)
    return bids.data
  }

  async fetchByBidder(bidder: string) {
    const bids = await bidAPI.fetchByBidder(bidder)
    return bids.data
  }

  async fetchByNFT(nft: NFT, status: ListingStatus = ListingStatus.OPEN) {
    const bids = await bidAPI.fetchByNFT(nft.contractAddress, nft.tokenId, status)
    return bids.data
  }

  async fetchBids(parameters: GetBidsParameters = {}) {
    return marketplaceAPI.fetchBids(parameters)
  }

  async place(wallet: Wallet | null, nft: NFT, price: number, expiresAt: number, fingerprint?: string) {
    if (!wallet) {
      throw new Error('Invalid address. Wallet must be connected.')
    }

    const priceInWei = parseUnits(price.toString(), 'ether')
    const expiresIn = Math.round((expiresAt - Date.now()) / 1000)

    switch (nft.network) {
      case Network.ETHEREUM: {
        const contract: ContractData = getContract(ContractName.Bid, nft.chainId)

        if (fingerprint) {
          return sendTransaction(
            contract,
            'placeBid(address,uint256,uint256,uint256,bytes)',
            nft.contractAddress,
            nft.tokenId,
            priceInWei,
            expiresIn,
            fingerprint
          )
        }

        return sendTransaction(
          contract,
          'placeBid(address,uint256,uint256,uint256)',
          nft.contractAddress,
          nft.tokenId,
          priceInWei,
          expiresIn
        )
      }
      case Network.MATIC: {
        const contract: ContractData = getContract(ContractName.BidV2, nft.chainId)
        return sendTransaction(
          contract,
          'placeBid(address,uint256,uint256,uint256)',
          nft.contractAddress,
          nft.tokenId,
          priceInWei,
          expiresIn
        )
      }
    }
  }

  async accept(wallet: Wallet | null, bid: Bid) {
    if (!wallet) {
      throw new Error('Invalid address. Wallet must be connected.')
    }

    if (!('bidAddress' in bid)) {
      throw new Error('BidService does not support offchain bids')
    }

    const contract: ContractData = getERC721ContractData(bid)

    return sendTransaction(
      contract,
      'safeTransferFrom(address,address,uint256,bytes)',
      wallet.address,
      bid.bidAddress,
      bid.tokenId,
      bid.blockchainId
    )
  }

  async cancel(wallet: Wallet | null, bid: Bid) {
    if (!wallet) {
      throw new Error('Invalid address. Wallet must be connected.')
    }

    if (!('bidAddress' in bid)) {
      throw new Error('BidService does not support offchain bids')
    }

    const contract: ContractData =
      bid.network === Network.ETHEREUM ? getContract(ContractName.Bid, bid.chainId) : getContract(ContractName.BidV2, bid.chainId)
    return sendTransaction(contract, 'cancelBid(address,uint256)', bid.contractAddress, bid.tokenId)
  }
}

1	import { parseUnits } from '@ethersproject/units'	84✔
2	import { Bid, GetBidsParameters, ListingStatus, Network } from '@dcl/schemas'	84✔
3	import { Wallet } from 'decentraland-dapps/dist/modules/wallet/types'
4	import { sendTransaction } from 'decentraland-dapps/dist/modules/wallet/utils'	84✔
5	import { ContractData, ContractName, getContract } from 'decentraland-transactions'	84✔
6	import { NFT } from '../../nft/types'
7	import { BidService as BidServiceInterface } from '../services'
8	import { VendorName } from '../types'
9	import { bidAPI } from './bid/api'	84✔
10	import { marketplaceAPI } from './marketplace/api'	84✔
11	import { getERC721ContractData } from './utils'	84✔
12
13	export class BidService implements BidServiceInterface<VendorName.DECENTRALAND> {	311✔
14	async fetchBySeller(seller: string) {
15	const bids = await bidAPI.fetchBySeller(seller)	×
16	return bids.data	×
17	}
18
19	async fetchByBidder(bidder: string) {
20	const bids = await bidAPI.fetchByBidder(bidder)	×
21	return bids.data	×
22	}
23
24	async fetchByNFT(nft: NFT, status: ListingStatus = ListingStatus.OPEN) {	×
25	const bids = await bidAPI.fetchByNFT(nft.contractAddress, nft.tokenId, status)	×
26	return bids.data	×
27	}
28
29	async fetchBids(parameters: GetBidsParameters = {}) {	×
NEW 30	return marketplaceAPI.fetchBids(parameters)	×
31	}
32
33	async place(wallet: Wallet \| null, nft: NFT, price: number, expiresAt: number, fingerprint?: string) {
34	if (!wallet) {	3✔
35	throw new Error('Invalid address. Wallet must be connected.')	1✔
36	}
37
38	const priceInWei = parseUnits(price.toString(), 'ether')	2✔
39	const expiresIn = Math.round((expiresAt - Date.now()) / 1000)	2✔
40
41	switch (nft.network) {	2✔
42	case Network.ETHEREUM: {
43	const contract: ContractData = getContract(ContractName.Bid, nft.chainId)	1✔
44
45	if (fingerprint) {	1!
46	return sendTransaction(	×
47	contract,
48	'placeBid(address,uint256,uint256,uint256,bytes)',
49	nft.contractAddress,
50	nft.tokenId,
51	priceInWei,
52	expiresIn,
53	fingerprint
54	)
55	}
56
57	return sendTransaction(	1✔
58	contract,
59	'placeBid(address,uint256,uint256,uint256)',
60	nft.contractAddress,
61	nft.tokenId,
62	priceInWei,
63	expiresIn
64	)
65	}
66	case Network.MATIC: {
67	const contract: ContractData = getContract(ContractName.BidV2, nft.chainId)	1✔
68	return sendTransaction(	1✔
69	contract,
70	'placeBid(address,uint256,uint256,uint256)',
71	nft.contractAddress,
72	nft.tokenId,
73	priceInWei,
74	expiresIn
75	)
76	}
77	}
78	}
79
80	async accept(wallet: Wallet \| null, bid: Bid) {
81	if (!wallet) {	3✔
82	throw new Error('Invalid address. Wallet must be connected.')	1✔
83	}
84
85	if (!('bidAddress' in bid)) {	2!
86	throw new Error('BidService does not support offchain bids')	×
87	}
88
89	const contract: ContractData = getERC721ContractData(bid)	2✔
90
91	return sendTransaction(	2✔
92	contract,
93	'safeTransferFrom(address,address,uint256,bytes)',
94	wallet.address,
95	bid.bidAddress,
96	bid.tokenId,
97	bid.blockchainId
98	)
99	}
100
101	async cancel(wallet: Wallet \| null, bid: Bid) {
102	if (!wallet) {	3✔
103	throw new Error('Invalid address. Wallet must be connected.')	1✔
104	}
105
106	if (!('bidAddress' in bid)) {	2!
107	throw new Error('BidService does not support offchain bids')	×
108	}
109
110	const contract: ContractData =
111	bid.network === Network.ETHEREUM ? getContract(ContractName.Bid, bid.chainId) : getContract(ContractName.BidV2, bid.chainId)	2✔
112	return sendTransaction(contract, 'cancelBid(address,uint256)', bid.contractAddress, bid.tokenId)	2✔
113	}
114	}

decentraland / marketplace / 10032223872

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