10009215276

Committed 19 Jul 2024 01:53PM UTC coverage: 66.57% (-0.1%) from 66.682%

Build # 10009215276

Build Type

push

github

Committed by

web-flow

Commit Message

feat: add accept trade flow (#2268)

Run Details

2639 of 5152 branches covered (51.22%)

Branch coverage included in aggregate %.

71 of 128 new or added lines in 11 files covered. (55.47%)

3 existing lines in 2 files now uncovered.

7726 of 10418 relevant lines covered (74.16%)

77.83 hits per line

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

43.48

/webapp/src/modules/bid/utils.ts

import { ethers, BigNumber } from 'ethers'
import { Bid, TradeAssetType, TradeCreation, TradeType } from '@dcl/schemas'
import { BidTrade } from '@dcl/schemas/dist/dapps/bid'
import { getNetworkProvider, getSigner } from 'decentraland-dapps/dist/lib/eth'
import { t } from 'decentraland-dapps/dist/modules/translation/utils'
import { ContractName, getContract } from 'decentraland-transactions'
import { isErrorWithMessage } from '../../lib/error'
import { getOffChainMarketplaceContract, getTradeSignature } from '../../utils/trades'
import { Item } from '../item/types'
import { NFT } from '../nft/types'

export async function isInsufficientMANA(bid: Bid) {
  try {
    const provider = await getNetworkProvider(bid.chainId)
    const contract = getContract(ContractName.MANAToken, bid.chainId)
    const mana = new ethers.Contract(contract.address, contract.abi, new ethers.providers.Web3Provider(provider))
    const balanceRaw = (await mana.balanceOf(bid.bidder)) as BigNumber
    const balance = parseFloat(ethers.utils.formatEther(balanceRaw))
    const price = parseFloat(ethers.utils.formatEther(bid.price))

    return balance < price
  } catch (error) {
    console.warn(isErrorWithMessage(error) ? error.message : t('global.unknown_error'))
  }
  return false
}

export function checkFingerprint(bid: Bid, fingerprint: string | undefined) {
  if (fingerprint && bid.fingerprint) {
    return fingerprint === bid.fingerprint
  }
  return true
}

export function toBidObject(bids: Bid[]) {
  return bids.reduce(
    (obj, bid) => {
      obj[bid.id] = bid
      return obj
    },
    {} as Record<string, Bid>
  )
}

export async function createBidTrade(asset: NFT | Item, price: number, expiresAt: number, fingerprint?: string): Promise<TradeCreation> {
  const signer = await getSigner()
  const address = await signer.getAddress()
  const marketplaceContract = await getOffChainMarketplaceContract(asset.chainId)
  const manaContract = getContract(ContractName.MANAToken, asset.chainId)
  const contractSignatureIndex = (await marketplaceContract.contractSignatureIndex()) as BigNumber
  const signerSignatureIndex = (await marketplaceContract.signerSignatureIndex(address)) as BigNumber

  const tradeToSign: Omit<TradeCreation, 'signature'> = {
    signer: address,
    network: asset.network,
    chainId: asset.chainId,
    type: TradeType.BID,
    checks: {
      uses: 1,
      allowedRoot: '0x',
      contractSignatureIndex: contractSignatureIndex.toNumber(),
      signerSignatureIndex: signerSignatureIndex.toNumber(),
      effective: Date.now(),
      expiration: expiresAt,
      externalChecks: [],
      salt: '0x'
    },
    sent: [
      {
        assetType: TradeAssetType.ERC20,
        contractAddress: manaContract.address,
        amount: ethers.utils.parseEther(price.toString()).toString(),
        extra: ''
      }
    ],
    received: [
      {
        contractAddress: asset.contractAddress,
        extra: fingerprint || '',
        beneficiary: address,
        ...('tokenId' in asset
          ? { assetType: TradeAssetType.ERC721, tokenId: asset.tokenId }
          : { assetType: TradeAssetType.COLLECTION_ITEM, itemId: asset.itemId })
      }
    ]
  }

  return { ...tradeToSign, signature: await getTradeSignature(tradeToSign) }
}

export function isBidTrade(bid: Bid): bid is BidTrade {
  return 'tradeId' in bid
}

1	import { ethers, BigNumber } from 'ethers'	37✔
2	import { Bid, TradeAssetType, TradeCreation, TradeType } from '@dcl/schemas'	37✔
3	import { BidTrade } from '@dcl/schemas/dist/dapps/bid'
4	import { getNetworkProvider, getSigner } from 'decentraland-dapps/dist/lib/eth'	37✔
5	import { t } from 'decentraland-dapps/dist/modules/translation/utils'	37✔
6	import { ContractName, getContract } from 'decentraland-transactions'	37✔
7	import { isErrorWithMessage } from '../../lib/error'	37✔
8	import { getOffChainMarketplaceContract, getTradeSignature } from '../../utils/trades'	37✔
9	import { Item } from '../item/types'
10	import { NFT } from '../nft/types'
11
12	export async function isInsufficientMANA(bid: Bid) {	×
13	try {	×
14	const provider = await getNetworkProvider(bid.chainId)	×
15	const contract = getContract(ContractName.MANAToken, bid.chainId)	×
16	const mana = new ethers.Contract(contract.address, contract.abi, new ethers.providers.Web3Provider(provider))	×
17	const balanceRaw = (await mana.balanceOf(bid.bidder)) as BigNumber	×
18	const balance = parseFloat(ethers.utils.formatEther(balanceRaw))	×
19	const price = parseFloat(ethers.utils.formatEther(bid.price))	×
20
21	return balance < price	×
22	} catch (error) {
23	console.warn(isErrorWithMessage(error) ? error.message : t('global.unknown_error'))	×
24	}
25	return false	×
26	}
27
28	export function checkFingerprint(bid: Bid, fingerprint: string \| undefined) {	×
29	if (fingerprint && bid.fingerprint) {	×
30	return fingerprint === bid.fingerprint	×
31	}
32	return true	×
33	}
34
35	export function toBidObject(bids: Bid[]) {	×
36	return bids.reduce(	×
37	(obj, bid) => {
38	obj[bid.id] = bid	×
39	return obj	×
40	},
41	{} as Record<string, Bid>
42	)
43	}
44
45	export async function createBidTrade(asset: NFT \| Item, price: number, expiresAt: number, fingerprint?: string): Promise<TradeCreation> {	27✔
46	const signer = await getSigner()	3✔
47	const address = await signer.getAddress()	3✔
48	const marketplaceContract = await getOffChainMarketplaceContract(asset.chainId)	3✔
49	const manaContract = getContract(ContractName.MANAToken, asset.chainId)	3✔
50	const contractSignatureIndex = (await marketplaceContract.contractSignatureIndex()) as BigNumber	3✔
51	const signerSignatureIndex = (await marketplaceContract.signerSignatureIndex(address)) as BigNumber	3✔
52
53	const tradeToSign: Omit<TradeCreation, 'signature'> = {	3✔
54	signer: address,
55	network: asset.network,
56	chainId: asset.chainId,
57	type: TradeType.BID,
58	checks: {
59	uses: 1,
60	allowedRoot: '0x',
61	contractSignatureIndex: contractSignatureIndex.toNumber(),
62	signerSignatureIndex: signerSignatureIndex.toNumber(),
63	effective: Date.now(),
64	expiration: expiresAt,
65	externalChecks: [],
66	salt: '0x'
67	},
68	sent: [
69	{
70	assetType: TradeAssetType.ERC20,
71	contractAddress: manaContract.address,
72	amount: ethers.utils.parseEther(price.toString()).toString(),
73	extra: ''
74	}
75	],
76	received: [
77	{
78	contractAddress: asset.contractAddress,
79	extra: fingerprint \|\| '',	5✔
80	beneficiary: address,
81	...('tokenId' in asset	3✔
82	? { assetType: TradeAssetType.ERC721, tokenId: asset.tokenId }
83	: { assetType: TradeAssetType.COLLECTION_ITEM, itemId: asset.itemId })
84	}
85	]
86	}
87
88	return { ...tradeToSign, signature: await getTradeSignature(tradeToSign) }	3✔
89	}
90
NEW 91	export function isBidTrade(bid: Bid): bid is BidTrade {	×
NEW 92	return 'tradeId' in bid	×
93	}

decentraland / marketplace / 10009215276

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