11248409678

Committed 09 Oct 2024 04:46AM UTC coverage: 66.525% (-0.009%) from 66.534%

Build # 11248409678

Build Type

Pull #2305

github

Committed by

meelrossi

Commit Message

feat: add remove listing on update

Pull Request Pull Request #2305: feat: add remove listing on update

Run Details

2684 of 5227 branches covered (51.35%)

Branch coverage included in aggregate %.

7 of 15 new or added lines in 4 files covered. (46.67%)

1 existing line in 1 file now uncovered.

7829 of 10576 relevant lines covered (74.03%)

77.91 hits per line

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

94.44

/webapp/src/modules/order/actions.ts

import { action } from 'typesafe-actions'
import { Order, OrderFilters } from '@dcl/schemas'
import { NFTPurchase } from 'decentraland-dapps/dist/modules/gateway/types'
import {
  buildTransactionPayload,
  buildTransactionWithFromPayload,
  buildTransactionWithReceiptPayload
} from 'decentraland-dapps/dist/modules/transaction/utils'
import { ErrorCode } from 'decentraland-transactions'
import { formatWeiMANA } from '../../lib/mana'
import { getAssetName } from '../asset/utils'
import { NFT } from '../nft/types'
import { LegacyOrderFragment } from './types'

// Create Order (aka Sell)

export const CREATE_ORDER_REQUEST = '[Request] Create Order'
export const CREATE_ORDER_SUCCESS = '[Success] Create Order'
export const CREATE_ORDER_FAILURE = '[Failure] Create Order'

export const createOrderRequest = (nft: NFT, price: number, expiresAt: number) => action(CREATE_ORDER_REQUEST, { nft, price, expiresAt })
export const createOrderSuccess = (nft: NFT, price: number, expiresAt: number, txHash?: string) =>
  action(CREATE_ORDER_SUCCESS, {
    nft,
    price,
    expiresAt,
    ...(txHash
      ? buildTransactionPayload(nft.chainId, txHash, {
          tokenId: nft.tokenId,
          contractAddress: nft.contractAddress,
          network: nft.network,
          name: getAssetName(nft),
          price
        })
      : {})
  })
export const createOrderFailure = (nft: NFT, price: number, expiresAt: number, error: string, errorCode?: ErrorCode) =>
  action(CREATE_ORDER_FAILURE, { nft, price, expiresAt, error, errorCode })

export type CreateOrderRequestAction = ReturnType<typeof createOrderRequest>
export type CreateOrderSuccessAction = ReturnType<typeof createOrderSuccess>
export type CreateOrderFailureAction = ReturnType<typeof createOrderFailure>

// Execute Order (aka Buy)

export const EXECUTE_ORDER_REQUEST = '[Request] Execute Order'
export const EXECUTE_ORDER_SUCCESS = '[Success] Execute Order'
export const EXECUTE_ORDER_FAILURE = '[Failure] Execute Order'
export const EXECUTE_ORDER_TRANSACTION_SUBMITTED = '[Submitted transaction] Execute Order'

export const executeOrderRequest = (order: Order, nft: NFT, fingerprint?: string, silent?: boolean) =>
  action(EXECUTE_ORDER_REQUEST, { order, nft, fingerprint, silent })
export const executeOrderTransactionSubmitted = (order: Order, nft: NFT, txHash: string) =>
  action(EXECUTE_ORDER_TRANSACTION_SUBMITTED, {
    order,
    nft,
    ...buildTransactionWithReceiptPayload(nft.chainId, txHash, {
      tokenId: nft.tokenId,
      contractAddress: nft.contractAddress,
      network: nft.network,
      name: getAssetName(nft),
      price: formatWeiMANA(order.price)
    })
  })
export const executeOrderSuccess = (txHash: string, nft: NFT) => action(EXECUTE_ORDER_SUCCESS, { txHash, nft })
export const executeOrderFailure = (order: Order, nft: NFT, error: string, errorCode?: ErrorCode, silent?: boolean) =>
  action(EXECUTE_ORDER_FAILURE, { order, nft, error, errorCode, silent })

export type ExecuteOrderRequestAction = ReturnType<typeof executeOrderRequest>
export type ExecuteOrderSuccessAction = ReturnType<typeof executeOrderSuccess>
export type ExecuteOrderTransactionSubmittedAction = ReturnType<typeof executeOrderTransactionSubmitted>
export type ExecuteOrderFailureAction = ReturnType<typeof executeOrderFailure>

// Execute Order With Card (aka Buy with Card)
export const EXECUTE_ORDER_WITH_CARD_REQUEST = '[Request] Execute Order With Card'
export const EXECUTE_ORDER_WITH_CARD_SUCCESS = '[Success] Execute Order With Card'
export const EXECUTE_ORDER_WITH_CARD_FAILURE = '[Failure] Execute Order With Card'

export const executeOrderWithCardRequest = (nft: NFT) => action(EXECUTE_ORDER_WITH_CARD_REQUEST, { nft })

export const executeOrderWithCardSuccess = (purchase: NFTPurchase, nft: NFT, txHash: string) =>
  action(EXECUTE_ORDER_WITH_CARD_SUCCESS, {
    purchase,
    nft,
    ...buildTransactionWithFromPayload(nft.chainId, txHash, purchase.address, {
      tokenId: nft.tokenId,
      contractAddress: nft.contractAddress,
      network: nft.network,
      name: getAssetName(nft),
      price: purchase.nft.cryptoAmount.toString()
    })
  })
export const executeOrderWithCardFailure = (error: string) => action(EXECUTE_ORDER_WITH_CARD_FAILURE, { error })

export type ExecuteOrderWithCardRequestAction = ReturnType<typeof executeOrderWithCardRequest>
export type ExecuteOrderWithCardSuccessAction = ReturnType<typeof executeOrderWithCardSuccess>
export type ExecuteOrderWithCardFailureAction = ReturnType<typeof executeOrderWithCardFailure>

// Cancel Order (aka Cancel Sale)

export const CANCEL_ORDER_REQUEST = '[Request] Cancel Order'
export const CANCEL_ORDER_SUCCESS_TX = '[Success] Cancel Order Tx'
export const CANCEL_ORDER_SUCCESS = '[Success] Cancel Order'
export const CANCEL_ORDER_FAILURE = '[Failure] Cancel Order'

export const cancelOrderRequest = (order: Order, nft: NFT, skipRedirection?: boolean) =>
  action(CANCEL_ORDER_REQUEST, { order, nft, skipRedirection })
export const cancelOrderSuccessTx = (order: Order, nft: NFT, txHash: string) =>
  action(CANCEL_ORDER_SUCCESS_TX, {
    order,
    nft,
    ...buildTransactionPayload(nft.chainId, txHash, {
      tokenId: nft.tokenId,
      contractAddress: nft.contractAddress,
      network: nft.network,
      name: getAssetName(nft),
      price: formatWeiMANA(order.price)
    })
  })

export const cancelOrderSuccess = (order: Order, nft: NFT, txHash: string, skipRedirection?: boolean) =>
  action(CANCEL_ORDER_SUCCESS, {
    order,
    nft,
    skipRedirection,
    ...buildTransactionPayload(nft.chainId, txHash, {
      tokenId: nft.tokenId,
      contractAddress: nft.contractAddress,
      network: nft.network,
      name: getAssetName(nft),
      price: formatWeiMANA(order.price)
    })
  })

export const cancelOrderFailure = (order: Order, nft: NFT, error: string, errorCode?: ErrorCode) =>
  action(CANCEL_ORDER_FAILURE, { order, nft, error, errorCode })

export type CancelOrderRequestAction = ReturnType<typeof cancelOrderRequest>
export type CancelOrderSuccessAction = ReturnType<typeof cancelOrderSuccess>
export type CancelOrderFailureAction = ReturnType<typeof cancelOrderFailure>

export const CLEAR_ORDER_ERRORS = 'Clear Order Errors'

export const clearOrderErrors = () => action(CLEAR_ORDER_ERRORS)

export type ClearOrderErrorsAction = ReturnType<typeof clearOrderErrors>

// Fetch orders
export const FETCH_LEGACY_ORDERS_REQUEST = '[Request] Fetch Legacy Orders'
export const FETCH_LEGACY_ORDERS_SUCCESS = '[Success] Fetch Legacy Orders'
export const FETCH_LEGACY_ORDERS_FAILURE = '[Failure] Fetch Legacy Orders'

export const fetchOrdersRequest = (address: string, filters?: OrderFilters) => action(FETCH_LEGACY_ORDERS_REQUEST, { address, filters })

export const fetchOrdersSuccess = (orders: LegacyOrderFragment[]) =>
  action(FETCH_LEGACY_ORDERS_SUCCESS, {
    orders
  })

export const fetchOrdersFailure = (address: string, error: string, errorCode?: ErrorCode) =>
  action(FETCH_LEGACY_ORDERS_FAILURE, { address, error, errorCode })

export type FetchLegacyOrdersRequestAction = ReturnType<typeof fetchOrdersRequest>
export type FetchLegacyOrdersSuccessAction = ReturnType<typeof fetchOrdersSuccess>
export type FetchLegacyOrdersFailureAction = ReturnType<typeof fetchOrdersFailure>

1	import { action } from 'typesafe-actions'	45✔
2	import { Order, OrderFilters } from '@dcl/schemas'
3	import { NFTPurchase } from 'decentraland-dapps/dist/modules/gateway/types'
4	import {
5	buildTransactionPayload,
6	buildTransactionWithFromPayload,
7	buildTransactionWithReceiptPayload
8	} from 'decentraland-dapps/dist/modules/transaction/utils'	45✔
9	import { ErrorCode } from 'decentraland-transactions'
10	import { formatWeiMANA } from '../../lib/mana'	45✔
11	import { getAssetName } from '../asset/utils'	45✔
12	import { NFT } from '../nft/types'
13	import { LegacyOrderFragment } from './types'
14
15	// Create Order (aka Sell)
16
17	export const CREATE_ORDER_REQUEST = '[Request] Create Order'	2,519✔
18	export const CREATE_ORDER_SUCCESS = '[Success] Create Order'	2,814✔
19	export const CREATE_ORDER_FAILURE = '[Failure] Create Order'	2,241✔
20
21	export const createOrderRequest = (nft: NFT, price: number, expiresAt: number) => action(CREATE_ORDER_REQUEST, { nft, price, expiresAt })	45✔
22	export const createOrderSuccess = (nft: NFT, price: number, expiresAt: number, txHash?: string) =>	45✔
23	action(CREATE_ORDER_SUCCESS, {	5✔
24	nft,
25	price,
26	expiresAt,
27	...(txHash	5✔
28	? buildTransactionPayload(nft.chainId, txHash, {
29	tokenId: nft.tokenId,
30	contractAddress: nft.contractAddress,
31	network: nft.network,
32	name: getAssetName(nft),
33	price
34	})
35	: {})
36	})
37	export const createOrderFailure = (nft: NFT, price: number, expiresAt: number, error: string, errorCode?: ErrorCode) =>	45✔
38	action(CREATE_ORDER_FAILURE, { nft, price, expiresAt, error, errorCode })	2✔
39
40	export type CreateOrderRequestAction = ReturnType<typeof createOrderRequest>
41	export type CreateOrderSuccessAction = ReturnType<typeof createOrderSuccess>
42	export type CreateOrderFailureAction = ReturnType<typeof createOrderFailure>
43
44	// Execute Order (aka Buy)
45
46	export const EXECUTE_ORDER_REQUEST = '[Request] Execute Order'	2,518✔
47	export const EXECUTE_ORDER_SUCCESS = '[Success] Execute Order'	2,539✔
48	export const EXECUTE_ORDER_FAILURE = '[Failure] Execute Order'	2,508✔
49	export const EXECUTE_ORDER_TRANSACTION_SUBMITTED = '[Submitted transaction] Execute Order'	45✔
50
51	export const executeOrderRequest = (order: Order, nft: NFT, fingerprint?: string, silent?: boolean) =>	45✔
52	action(EXECUTE_ORDER_REQUEST, { order, nft, fingerprint, silent })	9✔
53	export const executeOrderTransactionSubmitted = (order: Order, nft: NFT, txHash: string) =>	45✔
54	action(EXECUTE_ORDER_TRANSACTION_SUBMITTED, {	5✔
55	order,
56	nft,
57	...buildTransactionWithReceiptPayload(nft.chainId, txHash, {
58	tokenId: nft.tokenId,
59	contractAddress: nft.contractAddress,
60	network: nft.network,
61	name: getAssetName(nft),
62	price: formatWeiMANA(order.price)
63	})
64	})
65	export const executeOrderSuccess = (txHash: string, nft: NFT) => action(EXECUTE_ORDER_SUCCESS, { txHash, nft })	45✔
66	export const executeOrderFailure = (order: Order, nft: NFT, error: string, errorCode?: ErrorCode, silent?: boolean) =>	45✔
67	action(EXECUTE_ORDER_FAILURE, { order, nft, error, errorCode, silent })	9✔
68
69	export type ExecuteOrderRequestAction = ReturnType<typeof executeOrderRequest>
70	export type ExecuteOrderSuccessAction = ReturnType<typeof executeOrderSuccess>
71	export type ExecuteOrderTransactionSubmittedAction = ReturnType<typeof executeOrderTransactionSubmitted>
72	export type ExecuteOrderFailureAction = ReturnType<typeof executeOrderFailure>
73
74	// Execute Order With Card (aka Buy with Card)
75	export const EXECUTE_ORDER_WITH_CARD_REQUEST = '[Request] Execute Order With Card'	2,514✔
76	export const EXECUTE_ORDER_WITH_CARD_SUCCESS = '[Success] Execute Order With Card'	2,244✔
77	export const EXECUTE_ORDER_WITH_CARD_FAILURE = '[Failure] Execute Order With Card'	2,507✔
78
79	export const executeOrderWithCardRequest = (nft: NFT) => action(EXECUTE_ORDER_WITH_CARD_REQUEST, { nft })	45✔
80
81	export const executeOrderWithCardSuccess = (purchase: NFTPurchase, nft: NFT, txHash: string) =>	45✔
82	action(EXECUTE_ORDER_WITH_CARD_SUCCESS, {	4✔
83	purchase,
84	nft,
85	...buildTransactionWithFromPayload(nft.chainId, txHash, purchase.address, {
86	tokenId: nft.tokenId,
87	contractAddress: nft.contractAddress,
88	network: nft.network,
89	name: getAssetName(nft),
90	price: purchase.nft.cryptoAmount.toString()
91	})
92	})
93	export const executeOrderWithCardFailure = (error: string) => action(EXECUTE_ORDER_WITH_CARD_FAILURE, { error })	45✔
94
95	export type ExecuteOrderWithCardRequestAction = ReturnType<typeof executeOrderWithCardRequest>
96	export type ExecuteOrderWithCardSuccessAction = ReturnType<typeof executeOrderWithCardSuccess>
97	export type ExecuteOrderWithCardFailureAction = ReturnType<typeof executeOrderWithCardFailure>
98
99	// Cancel Order (aka Cancel Sale)
100
101	export const CANCEL_ORDER_REQUEST = '[Request] Cancel Order'	2,513✔
102	export const CANCEL_ORDER_SUCCESS_TX = '[Success] Cancel Order Tx'	45✔
103	export const CANCEL_ORDER_SUCCESS = '[Success] Cancel Order'	2,537✔
104	export const CANCEL_ORDER_FAILURE = '[Failure] Cancel Order'	2,238✔
105
106	export const cancelOrderRequest = (order: Order, nft: NFT, skipRedirection?: boolean) =>	45✔
107	action(CANCEL_ORDER_REQUEST, { order, nft, skipRedirection })	3✔
108	export const cancelOrderSuccessTx = (order: Order, nft: NFT, txHash: string) =>	45✔
NEW 109	action(CANCEL_ORDER_SUCCESS_TX, {	×
110	order,
111	nft,
112	...buildTransactionPayload(nft.chainId, txHash, {
113	tokenId: nft.tokenId,
114	contractAddress: nft.contractAddress,
115	network: nft.network,
116	name: getAssetName(nft),
117	price: formatWeiMANA(order.price)
118	})
119	})
120
121	export const cancelOrderSuccess = (order: Order, nft: NFT, txHash: string, skipRedirection?: boolean) =>	45✔
122	action(CANCEL_ORDER_SUCCESS, {	5✔
123	order,
124	nft,
125	skipRedirection,
126	...buildTransactionPayload(nft.chainId, txHash, {
127	tokenId: nft.tokenId,
128	contractAddress: nft.contractAddress,
129	network: nft.network,
130	name: getAssetName(nft),
131	price: formatWeiMANA(order.price)
132	})
133	})
134
135	export const cancelOrderFailure = (order: Order, nft: NFT, error: string, errorCode?: ErrorCode) =>	45✔
136	action(CANCEL_ORDER_FAILURE, { order, nft, error, errorCode })	2✔
137
138	export type CancelOrderRequestAction = ReturnType<typeof cancelOrderRequest>
139	export type CancelOrderSuccessAction = ReturnType<typeof cancelOrderSuccess>
140	export type CancelOrderFailureAction = ReturnType<typeof cancelOrderFailure>
141
142	export const CLEAR_ORDER_ERRORS = 'Clear Order Errors'	2,233✔
143
144	export const clearOrderErrors = () => action(CLEAR_ORDER_ERRORS)	45✔
145
146	export type ClearOrderErrorsAction = ReturnType<typeof clearOrderErrors>
147
148	// Fetch orders
149	export const FETCH_LEGACY_ORDERS_REQUEST = '[Request] Fetch Legacy Orders'	2,511✔
150	export const FETCH_LEGACY_ORDERS_SUCCESS = '[Success] Fetch Legacy Orders'	2,233✔
151	export const FETCH_LEGACY_ORDERS_FAILURE = '[Failure] Fetch Legacy Orders'	2,238✔
152
153	export const fetchOrdersRequest = (address: string, filters?: OrderFilters) => action(FETCH_LEGACY_ORDERS_REQUEST, { address, filters })	45✔
154
155	export const fetchOrdersSuccess = (orders: LegacyOrderFragment[]) =>	45✔
156	action(FETCH_LEGACY_ORDERS_SUCCESS, {	×
157	orders
158	})
159
160	export const fetchOrdersFailure = (address: string, error: string, errorCode?: ErrorCode) =>	45✔
161	action(FETCH_LEGACY_ORDERS_FAILURE, { address, error, errorCode })	×
162
163	export type FetchLegacyOrdersRequestAction = ReturnType<typeof fetchOrdersRequest>
164	export type FetchLegacyOrdersSuccessAction = ReturnType<typeof fetchOrdersSuccess>
165	export type FetchLegacyOrdersFailureAction = ReturnType<typeof fetchOrdersFailure>

decentraland / marketplace / 11248409678

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