6970244998

Committed 23 Nov 2023 01:18PM UTC coverage: 43.312% (+2.4%) from 40.865%

Build # 6970244998

Build Type

Pull #2042

github

Committed by

juanmahidalgo

Commit Message

feat: add missing select token and chain events

Pull Request Pull Request #2042: feat: use squid to calculate route between two chains and tokens

Run Details

2626 of 7307 branches covered (0.0%)

Branch coverage included in aggregate %.

277 of 382 new or added lines in 20 files covered. (72.51%)

1 existing line in 1 file now uncovered.

4634 of 9455 relevant lines covered (49.01%)

23.67 hits per line

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

0.0

/webapp/src/modules/analytics/track.ts

import { PayloadAction } from 'typesafe-actions'
import { ethers } from 'ethers'
import {
  EventName,
  GetPayload
} from 'decentraland-dapps/dist/modules/analytics/types'
import {
  FETCH_TRANSACTION_FAILURE,
  FIX_REVERTED_TRANSACTION,
  REPLACE_TRANSACTION_SUCCESS,
  FetchTransactionFailureAction,
  FixRevertedTransactionAction,
  ReplaceTransactionSuccessAction
} from 'decentraland-dapps/dist/modules/transaction/actions'
import {
  GrantTokenSuccessAction,
  GRANT_TOKEN_SUCCESS,
  RevokeTokenSuccessAction,
  REVOKE_TOKEN_SUCCESS
} from 'decentraland-dapps/dist/modules/authorization/actions'
import { TransactionStatus } from 'decentraland-dapps/dist/modules/transaction/types'
import { add } from 'decentraland-dapps/dist/modules/analytics/utils'
import { capitalize } from '../../lib/text'
import {
  CREATE_ORDER_SUCCESS,
  CANCEL_ORDER_SUCCESS,
  EXECUTE_ORDER_TRANSACTION_SUBMITTED,
  CreateOrderSuccessAction,
  CancelOrderSuccessAction,
  ExecuteOrderTransactionSubmittedAction,
  ExecuteOrderWithCardSuccessAction,
  EXECUTE_ORDER_WITH_CARD_SUCCESS
} from '../order/actions'
import {
  TRANSFER_NFT_TRANSACTION_SUBMITTED,
  TransferNFTSuccessAction,
  FETCH_NFTS_SUCCESS,
  FetchNFTsSuccessAction
} from '../nft/actions'
import {
  PLACE_BID_SUCCESS,
  ACCEPT_BID_TRANSACTION_SUBMITTED,
  CANCEL_BID_SUCCESS,
  ARCHIVE_BID,
  UNARCHIVE_BID,
  PlaceBidSuccessAction,
  CancelBidSuccessAction,
  ArchiveBidAction,
  UnarchiveBidAction,
  AcceptBidTransactionSubmittedAction
} from '../bid/actions'
import {
  BuyItemSuccessAction,
  BuyItemWithCardSuccessAction,
  BUY_ITEM_SUCCESS,
  BUY_ITEM_WITH_CARD_SUCCESS,
  FetchItemsSuccessAction,
  FETCH_ITEMS_SUCCESS,
  BUY_ITEM_CROSS_CHAIN_SUCCESS,
  BuyItemCrossChainSuccessAction
} from '../item/actions'
import { SetIsTryingOnAction, SET_IS_TRYING_ON } from '../ui/preview/actions'
import { isParcel } from '../nft/utils'
import {
  AcceptRentalListingSuccessAction,
  ACCEPT_RENTAL_LISTING_SUCCESS,
  ClaimAssetSuccessAction,
  CLAIM_ASSET_SUCCESS,
  UpsertRentalSuccessAction,
  UPSERT_RENTAL_SUCCESS
} from '../rental/actions'
import { UpsertRentalOptType } from '../rental/types'
import { NFTCategory } from '@dcl/schemas'
import {
  SetPurchaseAction,
  SET_PURCHASE
} from 'decentraland-dapps/dist/modules/gateway/actions'
import { PurchaseStatus } from 'decentraland-dapps/dist/modules/gateway/types'
import * as events from '../../utils/events'
import {
  CREATE_LIST_FAILURE,
  CREATE_LIST_SUCCESS,
  CreateListFailureAction,
  CreateListSuccessAction,
  DELETE_LIST_FAILURE,
  DELETE_LIST_SUCCESS,
  DeleteListFailureAction,
  DeleteListSuccessAction,
  PICK_ITEM_FAILURE,
  PICK_ITEM_SUCCESS,
  PickItemFailureAction,
  PickItemSuccessAction,
  UNPICK_ITEM_FAILURE,
  UNPICK_ITEM_SUCCESS,
  UPDATE_LIST_FAILURE,
  UPDATE_LIST_SUCCESS,
  UnpickItemFailureAction,
  UnpickItemSuccessAction,
  UpdateListFailureAction,
  UpdateListSuccessAction
} from '../favorites/actions'
import { getCategoryInfo } from '../../utils/category'
import {
  FETCH_CREATORS_ACCOUNT_SUCCESS,
  FetchCreatorsAccountSuccessAction
} from '../account/actions'

function track<T extends PayloadAction<string, any>>(
  actionType: string,
  eventName: string | ((action: T) => string),
  getPayload = (action: T) => action.payload
) {
  add(actionType, eventName as EventName, getPayload as GetPayload)
}

function withCategory(eventName: string, item: { category: string }) {
  const category = capitalize(item.category)
  return `${eventName} ${category}`
}

track<ExecuteOrderTransactionSubmittedAction>(
  EXECUTE_ORDER_TRANSACTION_SUBMITTED,
  ({ payload }) => withCategory(events.BUY, payload.nft),
  ({ payload }) => ({
    category: payload.nft.category,
    nft: payload.nft.id,
    price: payload.order.price,
    seller: payload.order.owner,
    buyer: payload.order.buyer,
    ...getCategoryInfo(payload.nft)
  })
)

track<ExecuteOrderWithCardSuccessAction>(
  EXECUTE_ORDER_WITH_CARD_SUCCESS,
  ({ payload }) => withCategory(events.BUY_WITH_CARD, payload.nft),
  ({ payload }) => ({
    category: payload.nft.category,
    nft: payload.nft.id,
    price: payload.purchase.nft.cryptoAmount,
    seller: payload.nft.owner,
    buyer: payload.purchase.address
  })
)

track<CreateOrderSuccessAction>(
  CREATE_ORDER_SUCCESS,
  ({ payload }) => withCategory(events.PUBLISH, payload.nft),
  ({ payload }) => ({
    category: payload.nft.category,
    tokenId: payload.nft.tokenId,
    price: payload.price
  })
)

track<CancelOrderSuccessAction>(
  CANCEL_ORDER_SUCCESS,
  ({ payload }) => withCategory(events.CANCEL_SALE, payload.nft),
  ({ payload }) => ({
    category: payload.nft.category,
    tokenId: payload.nft.tokenId,
    price: payload.order.price
  })
)

track<TransferNFTSuccessAction>(
  TRANSFER_NFT_TRANSACTION_SUBMITTED,
  ({ payload }) => withCategory(events.TRANSFER_NFT, payload.nft),
  ({ payload }) => ({
    category: payload.nft.category,
    tokenId: payload.nft.tokenId,
    to: payload.address
  })
)

track<FetchTransactionFailureAction>(FETCH_TRANSACTION_FAILURE, ({ payload }) =>
  payload.status === TransactionStatus.REVERTED
    ? events.TRANSACTION_FAILED
    : events.TRANSACTION_DROPPED
)

track<FixRevertedTransactionAction>(
  FIX_REVERTED_TRANSACTION,
  events.TRANSACTION_FIXED
)

track<ReplaceTransactionSuccessAction>(
  REPLACE_TRANSACTION_SUCCESS,
  events.TRANSACTION_REPLACED
)

track<GrantTokenSuccessAction>(GRANT_TOKEN_SUCCESS, () => events.AUTHORIZE)

track<RevokeTokenSuccessAction>(REVOKE_TOKEN_SUCCESS, () => events.UNAUTHORIZE)

track<PlaceBidSuccessAction>(
  PLACE_BID_SUCCESS,
  ({ payload }) => withCategory(events.BID, payload.nft),
  ({ payload }) => ({
    category: payload.nft.category,
    tokenId: payload.nft.tokenId,
    price: payload.price,
    bidder: payload.bidder
  })
)

track<AcceptBidTransactionSubmittedAction>(
  ACCEPT_BID_TRANSACTION_SUBMITTED,
  events.ACCEPT_BID,
  ({ payload }) => ({
    tokenId: payload.bid.tokenId,
    bidId: payload.bid.id,
    bidder: payload.bid.bidder,
    seller: payload.bid.seller
  })
)

track<CancelBidSuccessAction>(
  CANCEL_BID_SUCCESS,
  events.CANCEL_BID,
  ({ payload }) => ({
    tokenId: payload.bid.tokenId,
    bidId: payload.bid.id,
    bidder: payload.bid.bidder
  })
)

track<ArchiveBidAction>(ARCHIVE_BID, events.ARCHIVE_BID, ({ payload }) => ({
  tokenId: payload.bid.tokenId,
  bidId: payload.bid.id,
  price: payload.bid.price
}))

track<UnarchiveBidAction>(
  UNARCHIVE_BID,
  events.UNARCHIVE_BID,
  ({ payload }) => ({
    tokenId: payload.bid.tokenId,
    bidId: payload.bid.id,
    price: payload.bid.price
  })
)

track<FetchNFTsSuccessAction>(
  FETCH_NFTS_SUCCESS,
  events.FETCH_NFTS,
  ({ payload }) => ({
    ...payload.options.params,
    view: payload.options.view,
    vendor: payload.options.vendor,
    count: payload.count
  })
)

track<FetchItemsSuccessAction>(
  FETCH_ITEMS_SUCCESS,
  events.FETCH_ITEMS,
  ({ payload }) => ({
    options: payload.options,
    total: payload.total
  })
)

track<BuyItemSuccessAction>(
  BUY_ITEM_SUCCESS,
  events.BUY_ITEM,
  ({ payload }) => ({
    itemId: payload.item.itemId,
    contractAddress: payload.item.contractAddress,
    rarity: payload.item.rarity,
    network: payload.item.network,
    chainId: payload.item.chainId,
    price: Number(ethers.utils.formatEther(payload.item.price)),
    data: payload.item.data
  })
)

track<BuyItemCrossChainSuccessAction>(
  BUY_ITEM_CROSS_CHAIN_SUCCESS,
  events.BUY_ITEM_CROSS_CHAIN,
  ({ payload }) => ({
    fromToken: payload.route.route.params.fromToken,
    fromChain: payload.route.route.params.fromChain,
    itemId: payload.item.itemId,
    contractAddress: payload.item.contractAddress,
    rarity: payload.item.rarity,
    network: payload.item.network,
    chainId: payload.item.chainId,
    price: Number(ethers.utils.formatEther(payload.item.price)),
    data: payload.item.data
  })
)

track<BuyItemWithCardSuccessAction>(
  BUY_ITEM_WITH_CARD_SUCCESS,
  events.BUY_ITEM_WITH_CARD,
  ({ payload }) => ({
    itemId: payload.item.itemId,
    contractAddress: payload.item.contractAddress,
    rarity: payload.item.rarity,
    network: payload.item.network,
    chainId: payload.item.chainId,
    price: payload.purchase.nft.cryptoAmount,
    data: payload.item.data,
    purchase: payload.purchase
  })
)

track<SetIsTryingOnAction>(
  SET_IS_TRYING_ON,
  events.TOGGLE_PREVIEW_MODE,
  ({ payload }) => ({
    mode: payload.value ? 'avatar' : 'wearable'
  })
)

track<UpsertRentalSuccessAction>(
  UPSERT_RENTAL_SUCCESS,
  events.UPSERT_LAND_RENTAL,
  ({ payload: { nft, operationType, rental } }) => ({
    nftId: nft.id,
    assetType: isParcel(nft) ? NFTCategory.PARCEL : NFTCategory.ESTATE,
    rentalId: rental.id,
    pricePerDay: rental.periods[0].pricePerDay, // we're accepting just one price per day for all periods
    operation: operationType === UpsertRentalOptType.EDIT ? 'edit' : 'create',
    periods: rental.periods.map(period => period.maxDays).join(','), // maxDays is going to tell the duration for now
    experiesAt: rental.expiration
  })
)

track<ClaimAssetSuccessAction>(
  CLAIM_ASSET_SUCCESS,
  events.CLAIM_LAND_RENTAL,
  ({ payload: { nft, rental } }) => ({
    nftId: nft.id,
    rentalId: rental.id
  })
)

track<AcceptRentalListingSuccessAction>(
  ACCEPT_RENTAL_LISTING_SUCCESS,
  events.RENT_LAND,
  ({ payload: { periodIndexChosen, rental, nft } }) => ({
    nftId: rental.nftId,
    assetType: isParcel(nft) ? NFTCategory.PARCEL : NFTCategory.ESTATE,
    rentalId: rental.id,
    pricePerDay: rental.periods[periodIndexChosen].pricePerDay,
    duration: rental.periods[periodIndexChosen].maxDays
  })
)

track<SetPurchaseAction>(
  SET_PURCHASE,
  action =>
    action.payload.purchase.status === PurchaseStatus.CANCELLED
      ? events.PURCHASED_CANCELLED
      : action.payload.purchase.status === PurchaseStatus.COMPLETE
      ? events.PURCHASED_COMPLETE
      : action.payload.purchase.status === PurchaseStatus.REFUNDED
      ? events.PURCHASED_REFUNDED
      : action.payload.purchase.status === PurchaseStatus.FAILED
      ? events.PURCHASED_FAILED
      : events.PURCHASED_STARTED,
  action => action.payload.purchase
)

track<PickItemSuccessAction>(
  PICK_ITEM_SUCCESS,
  events.PICK_ITEM,
  ({ payload: { item, listId } }) => ({
    item,
    listId
  })
)

track<PickItemFailureAction>(
  PICK_ITEM_FAILURE,
  events.PICK_ITEM,
  ({ payload: { item, listId, error } }) => ({
    item,
    listId,
    error
  })
)

track<UnpickItemSuccessAction>(
  UNPICK_ITEM_SUCCESS,
  events.UNPICK_ITEM,
  ({ payload: { item, listId } }) => ({
    item,
    listId
  })
)

track<UnpickItemFailureAction>(
  UNPICK_ITEM_FAILURE,
  events.UNPICK_ITEM,
  ({ payload: { item, listId, error } }) => ({
    item,
    listId,
    error
  })
)

track<CreateListSuccessAction>(
  CREATE_LIST_SUCCESS,
  events.CREATE_LIST,
  ({ payload: { list } }) => ({
    list
  })
)

track<CreateListFailureAction>(
  CREATE_LIST_FAILURE,
  events.CREATE_LIST,
  ({ payload: { error } }) => ({
    error
  })
)

track<UpdateListSuccessAction>(
  UPDATE_LIST_SUCCESS,
  events.UPDATE_LIST,
  ({ payload: { list } }) => ({
    list
  })
)

track<UpdateListFailureAction>(
  UPDATE_LIST_FAILURE,
  events.UPDATE_LIST,
  ({ payload: { id, error } }) => ({
    id,
    error
  })
)

track<DeleteListSuccessAction>(
  DELETE_LIST_SUCCESS,
  events.DELETE_LIST,
  ({ payload: { list } }) => ({
    list
  })
)

track<DeleteListFailureAction>(
  DELETE_LIST_FAILURE,
  events.DELETE_LIST,
  ({ payload: { list, error } }) => ({
    list,
    error
  })
)

track<FetchCreatorsAccountSuccessAction>(
  FETCH_CREATORS_ACCOUNT_SUCCESS,
  events.SEARCH_RESULT,
  ({ payload: { creatorAccounts, search, searchUUID } }) => ({
    tab: 'creators',
    searchTerm: search,
    searchUUID,
    creators: creatorAccounts.map(creator => creator.address)
  })
)

1	import { PayloadAction } from 'typesafe-actions'
2	import { ethers } from 'ethers'
3	import {
4	EventName,
5	GetPayload
6	} from 'decentraland-dapps/dist/modules/analytics/types'
7	import {
8	FETCH_TRANSACTION_FAILURE,
9	FIX_REVERTED_TRANSACTION,
10	REPLACE_TRANSACTION_SUCCESS,
11	FetchTransactionFailureAction,
12	FixRevertedTransactionAction,
13	ReplaceTransactionSuccessAction
14	} from 'decentraland-dapps/dist/modules/transaction/actions'
15	import {
16	GrantTokenSuccessAction,
17	GRANT_TOKEN_SUCCESS,
18	RevokeTokenSuccessAction,
19	REVOKE_TOKEN_SUCCESS
20	} from 'decentraland-dapps/dist/modules/authorization/actions'
21	import { TransactionStatus } from 'decentraland-dapps/dist/modules/transaction/types'
22	import { add } from 'decentraland-dapps/dist/modules/analytics/utils'
23	import { capitalize } from '../../lib/text'
24	import {
25	CREATE_ORDER_SUCCESS,
26	CANCEL_ORDER_SUCCESS,
27	EXECUTE_ORDER_TRANSACTION_SUBMITTED,
28	CreateOrderSuccessAction,
29	CancelOrderSuccessAction,
30	ExecuteOrderTransactionSubmittedAction,
31	ExecuteOrderWithCardSuccessAction,
32	EXECUTE_ORDER_WITH_CARD_SUCCESS
33	} from '../order/actions'
34	import {
35	TRANSFER_NFT_TRANSACTION_SUBMITTED,
36	TransferNFTSuccessAction,
37	FETCH_NFTS_SUCCESS,
38	FetchNFTsSuccessAction
39	} from '../nft/actions'
40	import {
41	PLACE_BID_SUCCESS,
42	ACCEPT_BID_TRANSACTION_SUBMITTED,
43	CANCEL_BID_SUCCESS,
44	ARCHIVE_BID,
45	UNARCHIVE_BID,
46	PlaceBidSuccessAction,
47	CancelBidSuccessAction,
48	ArchiveBidAction,
49	UnarchiveBidAction,
50	AcceptBidTransactionSubmittedAction
51	} from '../bid/actions'
52	import {
53	BuyItemSuccessAction,
54	BuyItemWithCardSuccessAction,
55	BUY_ITEM_SUCCESS,
56	BUY_ITEM_WITH_CARD_SUCCESS,
57	FetchItemsSuccessAction,
58	FETCH_ITEMS_SUCCESS,
59	BUY_ITEM_CROSS_CHAIN_SUCCESS,
60	BuyItemCrossChainSuccessAction
61	} from '../item/actions'
62	import { SetIsTryingOnAction, SET_IS_TRYING_ON } from '../ui/preview/actions'
63	import { isParcel } from '../nft/utils'
64	import {
65	AcceptRentalListingSuccessAction,
66	ACCEPT_RENTAL_LISTING_SUCCESS,
67	ClaimAssetSuccessAction,
68	CLAIM_ASSET_SUCCESS,
69	UpsertRentalSuccessAction,
70	UPSERT_RENTAL_SUCCESS
71	} from '../rental/actions'
72	import { UpsertRentalOptType } from '../rental/types'
73	import { NFTCategory } from '@dcl/schemas'
74	import {
75	SetPurchaseAction,
76	SET_PURCHASE
77	} from 'decentraland-dapps/dist/modules/gateway/actions'
78	import { PurchaseStatus } from 'decentraland-dapps/dist/modules/gateway/types'
79	import * as events from '../../utils/events'
80	import {
81	CREATE_LIST_FAILURE,
82	CREATE_LIST_SUCCESS,
83	CreateListFailureAction,
84	CreateListSuccessAction,
85	DELETE_LIST_FAILURE,
86	DELETE_LIST_SUCCESS,
87	DeleteListFailureAction,
88	DeleteListSuccessAction,
89	PICK_ITEM_FAILURE,
90	PICK_ITEM_SUCCESS,
91	PickItemFailureAction,
92	PickItemSuccessAction,
93	UNPICK_ITEM_FAILURE,
94	UNPICK_ITEM_SUCCESS,
95	UPDATE_LIST_FAILURE,
96	UPDATE_LIST_SUCCESS,
97	UnpickItemFailureAction,
98	UnpickItemSuccessAction,
99	UpdateListFailureAction,
100	UpdateListSuccessAction
101	} from '../favorites/actions'
102	import { getCategoryInfo } from '../../utils/category'
103	import {
104	FETCH_CREATORS_ACCOUNT_SUCCESS,
105	FetchCreatorsAccountSuccessAction
106	} from '../account/actions'
107
108	function track<T extends PayloadAction<string, any>>(
109	actionType: string,
110	eventName: string \| ((action: T) => string),
111	getPayload = (action: T) => action.payload	×
112	) {
113	add(actionType, eventName as EventName, getPayload as GetPayload)	×
114	}
115
116	function withCategory(eventName: string, item: { category: string }) {
117	const category = capitalize(item.category)	×
118	return `${eventName} ${category}`	×
119	}
120
121	track<ExecuteOrderTransactionSubmittedAction>(	×
122	EXECUTE_ORDER_TRANSACTION_SUBMITTED,
123	({ payload }) => withCategory(events.BUY, payload.nft),	×
124	({ payload }) => ({	×
125	category: payload.nft.category,
126	nft: payload.nft.id,
127	price: payload.order.price,
128	seller: payload.order.owner,
129	buyer: payload.order.buyer,
130	...getCategoryInfo(payload.nft)
131	})
132	)
133
134	track<ExecuteOrderWithCardSuccessAction>(	×
135	EXECUTE_ORDER_WITH_CARD_SUCCESS,
136	({ payload }) => withCategory(events.BUY_WITH_CARD, payload.nft),	×
137	({ payload }) => ({	×
138	category: payload.nft.category,
139	nft: payload.nft.id,
140	price: payload.purchase.nft.cryptoAmount,
141	seller: payload.nft.owner,
142	buyer: payload.purchase.address
143	})
144	)
145
146	track<CreateOrderSuccessAction>(	×
147	CREATE_ORDER_SUCCESS,
148	({ payload }) => withCategory(events.PUBLISH, payload.nft),	×
149	({ payload }) => ({	×
150	category: payload.nft.category,
151	tokenId: payload.nft.tokenId,
152	price: payload.price
153	})
154	)
155
156	track<CancelOrderSuccessAction>(	×
157	CANCEL_ORDER_SUCCESS,
158	({ payload }) => withCategory(events.CANCEL_SALE, payload.nft),	×
159	({ payload }) => ({	×
160	category: payload.nft.category,
161	tokenId: payload.nft.tokenId,
162	price: payload.order.price
163	})
164	)
165
166	track<TransferNFTSuccessAction>(	×
167	TRANSFER_NFT_TRANSACTION_SUBMITTED,
168	({ payload }) => withCategory(events.TRANSFER_NFT, payload.nft),	×
169	({ payload }) => ({	×
170	category: payload.nft.category,
171	tokenId: payload.nft.tokenId,
172	to: payload.address
173	})
174	)
175
176	track<FetchTransactionFailureAction>(FETCH_TRANSACTION_FAILURE, ({ payload }) =>	×
177	payload.status === TransactionStatus.REVERTED	×
178	? events.TRANSACTION_FAILED
179	: events.TRANSACTION_DROPPED
180	)
181
182	track<FixRevertedTransactionAction>(	×
183	FIX_REVERTED_TRANSACTION,
184	events.TRANSACTION_FIXED
185	)
186
187	track<ReplaceTransactionSuccessAction>(	×
188	REPLACE_TRANSACTION_SUCCESS,
189	events.TRANSACTION_REPLACED
190	)
191
192	track<GrantTokenSuccessAction>(GRANT_TOKEN_SUCCESS, () => events.AUTHORIZE)	×
193
194	track<RevokeTokenSuccessAction>(REVOKE_TOKEN_SUCCESS, () => events.UNAUTHORIZE)	×
195
196	track<PlaceBidSuccessAction>(	×
197	PLACE_BID_SUCCESS,
198	({ payload }) => withCategory(events.BID, payload.nft),	×
199	({ payload }) => ({	×
200	category: payload.nft.category,
201	tokenId: payload.nft.tokenId,
202	price: payload.price,
203	bidder: payload.bidder
204	})
205	)
206
207	track<AcceptBidTransactionSubmittedAction>(	×
208	ACCEPT_BID_TRANSACTION_SUBMITTED,
209	events.ACCEPT_BID,
210	({ payload }) => ({	×
211	tokenId: payload.bid.tokenId,
212	bidId: payload.bid.id,
213	bidder: payload.bid.bidder,
214	seller: payload.bid.seller
215	})
216	)
217
218	track<CancelBidSuccessAction>(	×
219	CANCEL_BID_SUCCESS,
220	events.CANCEL_BID,
221	({ payload }) => ({	×
222	tokenId: payload.bid.tokenId,
223	bidId: payload.bid.id,
224	bidder: payload.bid.bidder
225	})
226	)
227
228	track<ArchiveBidAction>(ARCHIVE_BID, events.ARCHIVE_BID, ({ payload }) => ({	×
229	tokenId: payload.bid.tokenId,
230	bidId: payload.bid.id,
231	price: payload.bid.price
232	}))
233
234	track<UnarchiveBidAction>(	×
235	UNARCHIVE_BID,
236	events.UNARCHIVE_BID,
237	({ payload }) => ({	×
238	tokenId: payload.bid.tokenId,
239	bidId: payload.bid.id,
240	price: payload.bid.price
241	})
242	)
243
244	track<FetchNFTsSuccessAction>(	×
245	FETCH_NFTS_SUCCESS,
246	events.FETCH_NFTS,
247	({ payload }) => ({	×
248	...payload.options.params,
249	view: payload.options.view,
250	vendor: payload.options.vendor,
251	count: payload.count
252	})
253	)
254
255	track<FetchItemsSuccessAction>(	×
256	FETCH_ITEMS_SUCCESS,
257	events.FETCH_ITEMS,
258	({ payload }) => ({	×
259	options: payload.options,
260	total: payload.total
261	})
262	)
263
264	track<BuyItemSuccessAction>(	×
265	BUY_ITEM_SUCCESS,
266	events.BUY_ITEM,
267	({ payload }) => ({	×
268	itemId: payload.item.itemId,
269	contractAddress: payload.item.contractAddress,
270	rarity: payload.item.rarity,
271	network: payload.item.network,
272	chainId: payload.item.chainId,
273	price: Number(ethers.utils.formatEther(payload.item.price)),
274	data: payload.item.data
275	})
276	)
277
NEW 278	track<BuyItemCrossChainSuccessAction>(	×
279	BUY_ITEM_CROSS_CHAIN_SUCCESS,
280	events.BUY_ITEM_CROSS_CHAIN,
NEW 281	({ payload }) => ({	×
282	fromToken: payload.route.route.params.fromToken,
283	fromChain: payload.route.route.params.fromChain,
284	itemId: payload.item.itemId,
285	contractAddress: payload.item.contractAddress,
286	rarity: payload.item.rarity,
287	network: payload.item.network,
288	chainId: payload.item.chainId,
289	price: Number(ethers.utils.formatEther(payload.item.price)),
290	data: payload.item.data
291	})
292	)
293
UNCOV 294	track<BuyItemWithCardSuccessAction>(	×
295	BUY_ITEM_WITH_CARD_SUCCESS,
296	events.BUY_ITEM_WITH_CARD,
297	({ payload }) => ({	×
298	itemId: payload.item.itemId,
299	contractAddress: payload.item.contractAddress,
300	rarity: payload.item.rarity,
301	network: payload.item.network,
302	chainId: payload.item.chainId,
303	price: payload.purchase.nft.cryptoAmount,
304	data: payload.item.data,
305	purchase: payload.purchase
306	})
307	)
308
309	track<SetIsTryingOnAction>(	×
310	SET_IS_TRYING_ON,
311	events.TOGGLE_PREVIEW_MODE,
312	({ payload }) => ({	×
313	mode: payload.value ? 'avatar' : 'wearable'	×
314	})
315	)
316
317	track<UpsertRentalSuccessAction>(	×
318	UPSERT_RENTAL_SUCCESS,
319	events.UPSERT_LAND_RENTAL,
320	({ payload: { nft, operationType, rental } }) => ({	×
321	nftId: nft.id,
322	assetType: isParcel(nft) ? NFTCategory.PARCEL : NFTCategory.ESTATE,	×
323	rentalId: rental.id,
324	pricePerDay: rental.periods[0].pricePerDay, // we're accepting just one price per day for all periods
325	operation: operationType === UpsertRentalOptType.EDIT ? 'edit' : 'create',	×
326	periods: rental.periods.map(period => period.maxDays).join(','), // maxDays is going to tell the duration for now	×
327	experiesAt: rental.expiration
328	})
329	)
330
331	track<ClaimAssetSuccessAction>(	×
332	CLAIM_ASSET_SUCCESS,
333	events.CLAIM_LAND_RENTAL,
334	({ payload: { nft, rental } }) => ({	×
335	nftId: nft.id,
336	rentalId: rental.id
337	})
338	)
339
340	track<AcceptRentalListingSuccessAction>(	×
341	ACCEPT_RENTAL_LISTING_SUCCESS,
342	events.RENT_LAND,
343	({ payload: { periodIndexChosen, rental, nft } }) => ({	×
344	nftId: rental.nftId,
345	assetType: isParcel(nft) ? NFTCategory.PARCEL : NFTCategory.ESTATE,	×
346	rentalId: rental.id,
347	pricePerDay: rental.periods[periodIndexChosen].pricePerDay,
348	duration: rental.periods[periodIndexChosen].maxDays
349	})
350	)
351
352	track<SetPurchaseAction>(	×
353	SET_PURCHASE,
354	action =>
355	action.payload.purchase.status === PurchaseStatus.CANCELLED	×
356	? events.PURCHASED_CANCELLED
357	: action.payload.purchase.status === PurchaseStatus.COMPLETE	×
358	? events.PURCHASED_COMPLETE
359	: action.payload.purchase.status === PurchaseStatus.REFUNDED	×
360	? events.PURCHASED_REFUNDED
361	: action.payload.purchase.status === PurchaseStatus.FAILED	×
362	? events.PURCHASED_FAILED
363	: events.PURCHASED_STARTED,
364	action => action.payload.purchase	×
365	)
366
367	track<PickItemSuccessAction>(	×
368	PICK_ITEM_SUCCESS,
369	events.PICK_ITEM,
370	({ payload: { item, listId } }) => ({	×
371	item,
372	listId
373	})
374	)
375
376	track<PickItemFailureAction>(	×
377	PICK_ITEM_FAILURE,
378	events.PICK_ITEM,
379	({ payload: { item, listId, error } }) => ({	×
380	item,
381	listId,
382	error
383	})
384	)
385
386	track<UnpickItemSuccessAction>(	×
387	UNPICK_ITEM_SUCCESS,
388	events.UNPICK_ITEM,
389	({ payload: { item, listId } }) => ({	×
390	item,
391	listId
392	})
393	)
394
395	track<UnpickItemFailureAction>(	×
396	UNPICK_ITEM_FAILURE,
397	events.UNPICK_ITEM,
398	({ payload: { item, listId, error } }) => ({	×
399	item,
400	listId,
401	error
402	})
403	)
404
405	track<CreateListSuccessAction>(	×
406	CREATE_LIST_SUCCESS,
407	events.CREATE_LIST,
408	({ payload: { list } }) => ({	×
409	list
410	})
411	)
412
413	track<CreateListFailureAction>(	×
414	CREATE_LIST_FAILURE,
415	events.CREATE_LIST,
416	({ payload: { error } }) => ({	×
417	error
418	})
419	)
420
421	track<UpdateListSuccessAction>(	×
422	UPDATE_LIST_SUCCESS,
423	events.UPDATE_LIST,
424	({ payload: { list } }) => ({	×
425	list
426	})
427	)
428
429	track<UpdateListFailureAction>(	×
430	UPDATE_LIST_FAILURE,
431	events.UPDATE_LIST,
432	({ payload: { id, error } }) => ({	×
433	id,
434	error
435	})
436	)
437
438	track<DeleteListSuccessAction>(	×
439	DELETE_LIST_SUCCESS,
440	events.DELETE_LIST,
441	({ payload: { list } }) => ({	×
442	list
443	})
444	)
445
446	track<DeleteListFailureAction>(	×
447	DELETE_LIST_FAILURE,
448	events.DELETE_LIST,
449	({ payload: { list, error } }) => ({	×
450	list,
451	error
452	})
453	)
454
455	track<FetchCreatorsAccountSuccessAction>(	×
456	FETCH_CREATORS_ACCOUNT_SUCCESS,
457	events.SEARCH_RESULT,
458	({ payload: { creatorAccounts, search, searchUUID } }) => ({	×
459	tab: 'creators',
460	searchTerm: search,
461	searchUUID,
462	creators: creatorAccounts.map(creator => creator.address)	×
463	})
464	)

decentraland / marketplace / 6970244998

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