-
-
+ content={{
+ Complete: (
+
+ ),
+ }}
+ />
);
};
diff --git a/libs/deal-ticket/src/components/deal-ticket/time-in-force-selector.tsx b/libs/deal-ticket/src/components/deal-ticket/time-in-force-selector.tsx
index d6fb9a958..02da4fa0b 100644
--- a/libs/deal-ticket/src/components/deal-ticket/time-in-force-selector.tsx
+++ b/libs/deal-ticket/src/components/deal-ticket/time-in-force-selector.tsx
@@ -2,6 +2,7 @@ import { useEffect, useState } from 'react';
import { FormGroup, Select } from '@vegaprotocol/ui-toolkit';
import { Schema } from '@vegaprotocol/types';
import { t } from '@vegaprotocol/react-helpers';
+import { timeInForceLabel } from '@vegaprotocol/orders';
interface TimeInForceSelectorProps {
value: Schema.OrderTimeInForce;
@@ -9,26 +10,6 @@ interface TimeInForceSelectorProps {
onSelect: (tif: Schema.OrderTimeInForce) => void;
}
-// More detail in https://docs.vega.xyz/docs/mainnet/graphql/enums/order-time-in-force
-export const timeInForceLabel = (tif: string) => {
- switch (tif) {
- case Schema.OrderTimeInForce.TIME_IN_FORCE_GTC:
- return t(`Good 'til Cancelled (GTC)`);
- case Schema.OrderTimeInForce.TIME_IN_FORCE_IOC:
- return t('Immediate or Cancel (IOC)');
- case Schema.OrderTimeInForce.TIME_IN_FORCE_FOK:
- return t('Fill or Kill (FOK)');
- case Schema.OrderTimeInForce.TIME_IN_FORCE_GTT:
- return t(`Good 'til Time (GTT)`);
- case Schema.OrderTimeInForce.TIME_IN_FORCE_GFN:
- return t('Good for Normal (GFN)');
- case Schema.OrderTimeInForce.TIME_IN_FORCE_GFA:
- return t('Good for Auction (GFA)');
- default:
- return t(tif);
- }
-};
-
type PossibleOrderKeys = Exclude<
Schema.OrderType,
Schema.OrderType.TYPE_NETWORK
diff --git a/libs/orders/src/lib/components/order-list/order-list.tsx b/libs/orders/src/lib/components/order-list/order-list.tsx
index aae945363..0237f3f19 100644
--- a/libs/orders/src/lib/components/order-list/order-list.tsx
+++ b/libs/orders/src/lib/components/order-list/order-list.tsx
@@ -62,20 +62,26 @@ export const OrderList = forwardRef
(
-
+ content={{
+ Complete: (
+
-
+ content={{
+ Complete: (
+ {
},
});
- waitForOrderEvent(args.orderId, pubKey, (cancelledOrder) => {
- setCancelledOrder(cancelledOrder);
- setComplete();
- });
+ const cancelledOrder = await waitForOrderEvent(args.orderId, pubKey);
+ setCancelledOrder(cancelledOrder);
+ setComplete();
} catch (e) {
Sentry.captureException(e);
return;
diff --git a/libs/orders/src/lib/order-hooks/use-order-edit.tsx b/libs/orders/src/lib/order-hooks/use-order-edit.tsx
index b4dc5879e..597984b1e 100644
--- a/libs/orders/src/lib/order-hooks/use-order-edit.tsx
+++ b/libs/orders/src/lib/order-hooks/use-order-edit.tsx
@@ -54,10 +54,9 @@ export const useOrderEdit = (order: Order | null) => {
},
});
- waitForOrderEvent(order.id, pubKey, (updatedOrder) => {
- setUpdatedOrder(updatedOrder);
- setComplete();
- });
+ const updatedOrder = await waitForOrderEvent(order.id, pubKey);
+ setUpdatedOrder(updatedOrder);
+ setComplete();
} catch (e) {
Sentry.captureException(e);
return;
diff --git a/libs/orders/src/lib/order-hooks/use-order-event.ts b/libs/orders/src/lib/order-hooks/use-order-event.ts
index 88f0191ae..a929e4dee 100644
--- a/libs/orders/src/lib/order-hooks/use-order-event.ts
+++ b/libs/orders/src/lib/order-hooks/use-order-event.ts
@@ -8,44 +8,48 @@ import type {
} from './';
import type { Subscription } from 'zen-observable-ts';
import type { VegaTxState } from '@vegaprotocol/wallet';
+import { BusEventType } from '@vegaprotocol/types';
+
+type WaitFunc = (
+ orderId: string,
+ partyId: string
+) => Promise;
export const useOrderEvent = (transaction: VegaTxState) => {
const client = useApolloClient();
const subRef = useRef(null);
- const waitForOrderEvent = useCallback(
- (
- id: string,
- partyId: string,
- callback: (order: OrderEvent_busEvents_event_Order) => void
- ) => {
- subRef.current = client
- .subscribe({
- query: ORDER_EVENT_SUB,
- variables: { partyId },
- })
- .subscribe(({ data }) => {
- if (!data?.busEvents?.length) {
- return;
- }
-
- // No types available for the subscription result
- const matchingOrderEvent = data.busEvents.find((e) => {
- if (e.event.__typename !== 'Order') {
- return false;
+ const waitForOrderEvent = useCallback(
+ (id: string, partyId: string) => {
+ return new Promise((resolve) => {
+ subRef.current = client
+ .subscribe({
+ query: ORDER_EVENT_SUB,
+ variables: { partyId },
+ })
+ .subscribe(({ data }) => {
+ if (!data?.busEvents?.length) {
+ return;
}
- return e.event.id === id;
- });
+ // No types available for the subscription result
+ const matchingOrderEvent = data.busEvents.find((e) => {
+ if (e.event.__typename !== BusEventType.Order) {
+ return false;
+ }
- if (
- matchingOrderEvent &&
- matchingOrderEvent.event.__typename === 'Order'
- ) {
- callback(matchingOrderEvent.event);
- subRef.current?.unsubscribe();
- }
- });
+ return e.event.id === id;
+ });
+
+ if (
+ matchingOrderEvent &&
+ matchingOrderEvent.event.__typename === BusEventType.Order
+ ) {
+ resolve(matchingOrderEvent.event);
+ subRef.current?.unsubscribe();
+ }
+ });
+ });
},
[client]
);
diff --git a/libs/orders/src/lib/order-hooks/use-order-submit.tsx b/libs/orders/src/lib/order-hooks/use-order-submit.tsx
index fc81db4f9..16d001126 100644
--- a/libs/orders/src/lib/order-hooks/use-order-submit.tsx
+++ b/libs/orders/src/lib/order-hooks/use-order-submit.tsx
@@ -132,10 +132,9 @@ export const useOrderSubmit = () => {
if (res) {
const orderId = determineId(res.signature);
if (orderId) {
- waitForOrderEvent(orderId, pubKey, (order) => {
- setFinalizedOrder(order);
- setComplete();
- });
+ const order = await waitForOrderEvent(orderId, pubKey);
+ setFinalizedOrder(order);
+ setComplete();
}
}
} catch (e) {
diff --git a/libs/orders/src/lib/utils.ts b/libs/orders/src/lib/utils.ts
new file mode 100644
index 000000000..9ec50833c
--- /dev/null
+++ b/libs/orders/src/lib/utils.ts
@@ -0,0 +1,22 @@
+import { t } from '@vegaprotocol/react-helpers';
+import { OrderTimeInForce } from '@vegaprotocol/types';
+
+// More detail in https://docs.vega.xyz/docs/mainnet/graphql/enums/order-time-in-force
+export const timeInForceLabel = (tif: string) => {
+ switch (tif) {
+ case OrderTimeInForce.TIME_IN_FORCE_GTC:
+ return t(`Good 'til Cancelled (GTC)`);
+ case OrderTimeInForce.TIME_IN_FORCE_IOC:
+ return t('Immediate or Cancel (IOC)');
+ case OrderTimeInForce.TIME_IN_FORCE_FOK:
+ return t('Fill or Kill (FOK)');
+ case OrderTimeInForce.TIME_IN_FORCE_GTT:
+ return t(`Good 'til Time (GTT)`);
+ case OrderTimeInForce.TIME_IN_FORCE_GFN:
+ return t('Good for Normal (GFN)');
+ case OrderTimeInForce.TIME_IN_FORCE_GFA:
+ return t('Good for Auction (GFA)');
+ default:
+ return t(tif);
+ }
+};
diff --git a/libs/positions/jest.config.ts b/libs/positions/jest.config.ts
index 71b7ab0cd..9eac173db 100644
--- a/libs/positions/jest.config.ts
+++ b/libs/positions/jest.config.ts
@@ -2,13 +2,8 @@
export default {
displayName: 'positions',
preset: '../../jest.preset.js',
- globals: {
- 'ts-jest': {
- tsconfig: '/tsconfig.spec.json',
- },
- },
transform: {
- '^.+\\.[tj]sx?$': 'ts-jest',
+ '^.+\\.[tj]sx?$': 'babel-jest',
},
moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx'],
coverageDirectory: '../../coverage/libs/positions',
diff --git a/libs/positions/src/index.ts b/libs/positions/src/index.ts
index db59b5136..aae70eaf6 100644
--- a/libs/positions/src/index.ts
+++ b/libs/positions/src/index.ts
@@ -3,6 +3,5 @@ export * from './lib/positions-container';
export * from './lib/positions-data-providers';
export * from './lib/positions-table';
export * from './lib/use-close-position';
-export * from './lib/use-position-event';
export * from './lib/use-positions-data';
export * from './lib/use-positions-assets';
diff --git a/libs/positions/src/lib/close-position-dialog/complete.tsx b/libs/positions/src/lib/close-position-dialog/complete.tsx
new file mode 100644
index 000000000..4ead9d4e6
--- /dev/null
+++ b/libs/positions/src/lib/close-position-dialog/complete.tsx
@@ -0,0 +1,108 @@
+import { useEnvironment } from '@vegaprotocol/environment';
+import type { OrderEvent_busEvents_event_Order } from '@vegaprotocol/orders';
+import { t, truncateByChars } from '@vegaprotocol/react-helpers';
+import { OrderRejectionReasonMapping, OrderStatus } from '@vegaprotocol/types';
+import { Link } from '@vegaprotocol/ui-toolkit';
+import type { TransactionResult, VegaTxState } from '@vegaprotocol/wallet';
+import type { ClosingOrder as IClosingOrder } from '../use-close-position';
+import { useRequestClosePositionData } from '../use-request-close-position-data';
+import { ClosingOrder } from './shared';
+
+interface CompleteProps {
+ partyId: string;
+ transaction: VegaTxState;
+ transactionResult?: TransactionResult;
+ closingOrder?: IClosingOrder;
+ closingOrderResult?: OrderEvent_busEvents_event_Order;
+}
+
+export const Complete = ({
+ partyId,
+ transaction,
+ transactionResult,
+ closingOrder,
+ closingOrderResult,
+}: CompleteProps) => {
+ const { VEGA_EXPLORER_URL } = useEnvironment();
+
+ if (!transactionResult || !closingOrderResult) return null;
+
+ return (
+ <>
+ {closingOrderResult.status === OrderStatus.STATUS_FILLED &&
+ transactionResult.status ? (
+ {t('Transaction')}
+
+
+
+ )}
+
+ );
+};
+
+const Success = ({
+ partyId,
+ order,
+}: {
+ partyId: string;
+ order?: IClosingOrder;
+}) => {
+ const { market, marketData, orders } = useRequestClosePositionData(
+ order?.marketId,
+ partyId
+ );
+
+ if (!market || !marketData || !orders) {
+ return {t('Loading...')}
;
+ }
+
+ if (!order) {
+ return (
+ {t('Could retrieve closing order')}
+ );
+ }
+ return (
+ <>
+ {t('Position closed')}
+
+ {reason ? (
+
{reason}
+ ) : (
+
+ {t('Transaction failed')}: {transactionResult.error}
+
+ )}
+
{t('Loading...')}
;
+ }
+
+ if (!order) {
+ return (
+ {t('Could not create closing order')}
+ );
+ }
+
+ return (
+ <>
+ {t('Position to be closed')}
+
+
{t('Orders to be closed')}
+ {
+ return [
+
+ );
+};
+
+interface BasicTableProps {
+ headers: ReactNode[];
+ rows: ReactNode[][];
+}
+
+const BasicTable = ({ headers, rows }: BasicTableProps) => {
+ return (
+
+
+
+ {headers.map((h, i) => (
+
+ {h}
+
+ ))}
+
+
+
+ {rows.map((cells, i) => (
+
+ {cells.map((c, i) => (
+
+ {c}
+
+ ))}
+
+ ))}
+
+
+ );
+};
diff --git a/libs/positions/src/lib/positions-manager.tsx b/libs/positions/src/lib/positions-manager.tsx
index 5e66f9713..31231a292 100644
--- a/libs/positions/src/lib/positions-manager.tsx
+++ b/libs/positions/src/lib/positions-manager.tsx
@@ -1,24 +1,28 @@
-import { useCallback, useRef } from 'react';
-import { AsyncRenderer } from '@vegaprotocol/ui-toolkit';
-import type { Position } from './positions-data-providers';
-import { PositionsTable, useClosePosition, usePositionsData } from '../';
+import { useRef } from 'react';
+import { AsyncRenderer, Icon, Intent } from '@vegaprotocol/ui-toolkit';
+import { useClosePosition, usePositionsData, PositionsTable } from '../';
import type { AgGridReact } from 'ag-grid-react';
+import { Requested } from './close-position-dialog/requested';
+import { Complete } from './close-position-dialog/complete';
+import type { TransactionResult } from '@vegaprotocol/wallet';
+import { t } from '@vegaprotocol/react-helpers';
interface PositionsManagerProps {
partyId: string;
}
export const PositionsManager = ({ partyId }: PositionsManagerProps) => {
- const { submit, Dialog } = useClosePosition();
- const onClose = useCallback(
- (position: Position) => {
- submit(position);
- },
- [submit]
- );
-
const gridRef = useRef(null);
const { data, error, loading, getRows } = usePositionsData(partyId, gridRef);
+ const {
+ submit,
+ closingOrder,
+ closingOrderResult,
+ transaction,
+ transactionResult,
+ Dialog,
+ } = useClosePosition();
+
return (
<>
@@ -29,13 +33,66 @@ export const PositionsManager = ({ partyId }: PositionsManagerProps) => {
rowModelType={data?.length ? 'infinite' : 'clientSide'}
rowData={data?.length ? undefined : []}
datasource={{ getRows }}
- onClose={onClose}
+ onClose={(position) => submit(position)}
/>
-
-
- Your position was not closed! This is still not implemented.
-
+ ) {
+ const mockTransactionResult: MockedResponse = {
+ request: {
+ query: TransactionEventDocument,
+ variables: {
+ partyId: context?.pubKey || '',
+ },
+ },
+ result: {
+ data: {
+ busEvents: [
+ {
+ type: Types.BusEventType.TransactionResult,
+ event: txResult,
+ __typename: 'BusEvent',
+ },
+ ] as TransactionEventSubscription['busEvents'],
+ },
+ },
+ };
+ const mockOrderResult: MockedResponse = {
+ request: {
+ query: ORDER_EVENT_SUB,
+ variables: {
+ partyId: context?.pubKey || '',
+ },
+ },
+ result: {
+ data: {
+ busEvents: [
+ {
+ type: BusEventType.Order,
+ event: {
+ type: OrderType.TYPE_LIMIT,
+ id: '2fca514cebf9f465ae31ecb4c5721e3a6f5f260425ded887ca50ba15b81a5d50',
+ status: OrderStatus.STATUS_ACTIVE,
+ rejectionReason: null,
+ createdAt: '2022-07-05T14:25:47.815283706Z',
+ expiresAt: '2022-07-05T14:25:47.815283706Z',
+ size: '10',
+ price: '300000',
+ timeInForce: OrderTimeInForce.TIME_IN_FORCE_GTC,
+ side: Side.SIDE_BUY,
+ market: {
+ id: 'market-id',
+ decimalPlaces: 5,
+ positionDecimalPlaces: 0,
+ tradableInstrument: {
+ __typename: 'TradableInstrument',
+ instrument: {
+ name: 'UNIDAI Monthly (30 Jun 2022)',
+ __typename: 'Instrument',
+ },
+ },
+ __typename: 'Market',
+ },
+ __typename: 'Order',
+ },
+ __typename: 'BusEvent',
+ },
+ ],
+ },
+ },
+ };
+
+ const wrapper = ({ children }: { children: ReactNode }) => (
+
+
+ {children}
+
+
+ );
+ return renderHook(() => useClosePosition(), { wrapper });
+}
+
+describe('useClosePosition', () => {
+ const txResponse = {
+ signature:
+ 'cfe592d169f87d0671dd447751036d0dddc165b9c4b65e5a5060e2bbadd1aa726d4cbe9d3c3b327bcb0bff4f83999592619a2493f9bbd251fae99ce7ce766909',
+ transactionHash: '0x123',
+ };
+
+ it('doesnt send the tx if there is no open volume', () => {
+ const mockSend = jest.fn();
+ const { result } = setup({ sendTx: mockSend });
+ expect(result.current).toEqual({
+ submit: expect.any(Function),
+ transaction: initialState,
+ Dialog: expect.any(Function),
+ });
+ result.current.submit({ marketId: 'test-market', openVolume: '0' });
+ expect(mockSend).not.toBeCalled();
+ expect(result.current.transaction.status).toEqual(VegaTxStatus.Default);
+ });
+
+ it('doesnt send the tx if there is no pubkey', () => {
+ const mockSend = jest.fn();
+ const { result } = setup({ sendTx: mockSend, pubKey: null });
+ result.current.submit({ marketId: 'test-market', openVolume: '1000' });
+ expect(mockSend).not.toBeCalled();
+ expect(result.current.transaction.status).toEqual(VegaTxStatus.Default);
+ });
+
+ it('closes long positions', async () => {
+ const marketId = 'test-market';
+ const openVolume = '1000';
+ const mockSend = jest.fn().mockResolvedValue(txResponse);
+ const { result } = setup({ sendTx: mockSend, pubKey });
+
+ act(() => {
+ result.current.submit({ marketId, openVolume });
+ });
+
+ expect(mockSend).toBeCalledWith(defaultWalletContext.pubKey, {
+ batchMarketInstructions: {
+ cancellations: [
+ {
+ marketId,
+ orderId: '',
+ },
+ ],
+ submissions: [
+ {
+ marketId,
+ type: OrderType.TYPE_MARKET,
+ timeInForce: OrderTimeInForce.TIME_IN_FORCE_FOK,
+ side: Side.SIDE_SELL,
+ size: openVolume,
+ },
+ ],
+ },
+ });
+
+ expect(result.current.transaction.status).toEqual(VegaTxStatus.Requested);
+
+ await waitFor(() => {
+ expect(result.current.transaction).toEqual({
+ status: VegaTxStatus.Complete,
+ signature: txResponse.signature,
+ txHash: txResponse.transactionHash,
+ dialogOpen: true,
+ error: null,
+ });
+ expect(result.current.transactionResult).toEqual(txResult);
+ });
+ });
+
+ it('closes short positions', async () => {
+ const marketId = 'test-market';
+ const openVolume = '-1000';
+ const mockSend = jest.fn().mockResolvedValue(txResponse);
+ const { result } = setup({ sendTx: mockSend, pubKey });
+
+ act(() => {
+ result.current.submit({ marketId, openVolume });
+ });
+
+ expect(mockSend).toBeCalledWith(defaultWalletContext.pubKey, {
+ batchMarketInstructions: {
+ cancellations: [
+ {
+ marketId,
+ orderId: '',
+ },
+ ],
+ submissions: [
+ {
+ marketId,
+ type: OrderType.TYPE_MARKET,
+ timeInForce: OrderTimeInForce.TIME_IN_FORCE_FOK,
+ side: Side.SIDE_BUY,
+ size: openVolume.replace('-', ''),
+ },
+ ],
+ },
+ });
+
+ expect(result.current.transaction.status).toEqual(VegaTxStatus.Requested);
+
+ await waitFor(() => {
+ expect(result.current.transaction).toEqual({
+ status: VegaTxStatus.Complete,
+ signature: txResponse.signature,
+ txHash: txResponse.transactionHash,
+ dialogOpen: true,
+ error: null,
+ });
+ expect(result.current.transactionResult).toEqual(txResult);
+ });
+ });
+});
diff --git a/libs/positions/src/lib/use-close-position.ts b/libs/positions/src/lib/use-close-position.ts
index f2959f550..467a9d1f8 100644
--- a/libs/positions/src/lib/use-close-position.ts
+++ b/libs/positions/src/lib/use-close-position.ts
@@ -1,61 +1,105 @@
-import { useCallback } from 'react';
-import { useVegaWallet } from '@vegaprotocol/wallet';
-import { useVegaTransaction, determineId } from '@vegaprotocol/wallet';
+import { useCallback, useState } from 'react';
+import type { TransactionResult } from '@vegaprotocol/wallet';
+import { determineId } from '@vegaprotocol/wallet';
+import { useVegaWallet, useTransactionResult } from '@vegaprotocol/wallet';
+import { useVegaTransaction } from '@vegaprotocol/wallet';
import * as Sentry from '@sentry/react';
-import { usePositionEvent } from '../';
-import type { Position } from '../';
+import { OrderTimeInForce, OrderType, Side } from '@vegaprotocol/types';
+import { useOrderEvent } from '@vegaprotocol/orders';
+import type { OrderEvent_busEvents_event_Order } from '@vegaprotocol/orders';
+
+export interface ClosingOrder {
+ marketId: string;
+ type: OrderType.TYPE_MARKET;
+ timeInForce: OrderTimeInForce.TIME_IN_FORCE_FOK;
+ side: Side;
+ size: string;
+}
export const useClosePosition = () => {
const { pubKey } = useVegaWallet();
-
- const {
- send,
- transaction,
- reset: resetTransaction,
- setComplete,
- Dialog,
- } = useVegaTransaction();
- const waitForPositionEvent = usePositionEvent(transaction);
-
- const reset = useCallback(() => {
- resetTransaction();
- }, [resetTransaction]);
+ const { send, transaction, setComplete, Dialog } = useVegaTransaction();
+ const [closingOrder, setClosingOrder] = useState();
+ const [closingOrderResult, setClosingOrderResult] =
+ useState();
+ const [transactionResult, setTransactionResult] =
+ useState();
+ const waitForTransactionResult = useTransactionResult();
+ const waitForOrder = useOrderEvent(transaction);
const submit = useCallback(
- async (position: Position) => {
- if (!pubKey || position.openVolume === '0') {
+ async ({
+ marketId,
+ openVolume,
+ }: {
+ marketId: string;
+ openVolume: string;
+ }) => {
+ if (!pubKey || openVolume === '0') {
return;
}
- try {
- const res = await send(pubKey, {
- orderCancellation: {
- marketId: position.marketId,
- orderId: '',
- },
- });
+ setTransactionResult(undefined);
+ setClosingOrder(undefined);
- if (res?.signature) {
- const resId = determineId(res.signature);
- if (resId) {
- waitForPositionEvent(resId, pubKey, () => {
- setComplete();
- });
- }
+ try {
+ // figure out if opsition is long or short and make side the opposite
+ const side = openVolume.startsWith('-')
+ ? Side.SIDE_BUY
+ : Side.SIDE_SELL;
+
+ // volume could be prefixed with '-' if position is short, remove it
+ const size = openVolume.replace('-', '');
+ const closingOrder = {
+ marketId: marketId,
+ type: OrderType.TYPE_MARKET as const,
+ timeInForce: OrderTimeInForce.TIME_IN_FORCE_FOK as const,
+ side,
+ size,
+ };
+
+ setClosingOrder(closingOrder);
+
+ const command = {
+ batchMarketInstructions: {
+ cancellations: [
+ {
+ marketId,
+ orderId: '', // omit order id to cancel all active orders
+ },
+ ],
+ submissions: [closingOrder],
+ },
+ };
+
+ const res = await send(pubKey, command);
+
+ if (res) {
+ const orderId = determineId(res.signature);
+ const [txResult, orderResult] = await Promise.all([
+ waitForTransactionResult(res.transactionHash, pubKey),
+ waitForOrder(orderId, pubKey),
+ ]);
+ setTransactionResult(txResult);
+ setClosingOrderResult(orderResult);
+ setComplete();
}
+
return res;
} catch (e) {
Sentry.captureException(e);
return;
}
},
- [pubKey, send, setComplete, waitForPositionEvent]
+ [pubKey, send, setComplete, waitForTransactionResult, waitForOrder]
);
return {
transaction,
- Dialog,
+ transactionResult,
submit,
- reset,
+ closingOrder,
+ closingOrderResult,
+ Dialog,
};
};
diff --git a/libs/positions/src/lib/use-position-event.ts b/libs/positions/src/lib/use-position-event.ts
deleted file mode 100644
index 75cf0924e..000000000
--- a/libs/positions/src/lib/use-position-event.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import type { VegaTxState } from '@vegaprotocol/wallet';
-import { useCallback } from 'react';
-
-// this should be replaced by implementation of busEvents listener when it will be available
-export const usePositionEvent = (transaction: VegaTxState) => {
- const waitForOrderEvent = useCallback(
- (id: string, partyId: string, callback: () => void) => {
- Promise.resolve().then(() => {
- callback();
- });
- },
- []
- );
- return waitForOrderEvent;
-};
diff --git a/libs/positions/src/lib/use-request-close-position-data.ts b/libs/positions/src/lib/use-request-close-position-data.ts
new file mode 100644
index 000000000..7ff41e033
--- /dev/null
+++ b/libs/positions/src/lib/use-request-close-position-data.ts
@@ -0,0 +1,58 @@
+import { marketDataProvider, marketProvider } from '@vegaprotocol/market-list';
+import { isOrderActive, ordersWithMarketProvider } from '@vegaprotocol/orders';
+import { useDataProvider } from '@vegaprotocol/react-helpers';
+import { useMemo } from 'react';
+
+export const useRequestClosePositionData = (
+ marketId?: string,
+ partyId?: string
+) => {
+ const marketVariables = useMemo(() => ({ marketId }), [marketId]);
+ const orderVariables = useMemo(() => ({ partyId }), [partyId]);
+ const { data: market, loading: marketLoading } = useDataProvider({
+ dataProvider: marketProvider,
+ variables: marketVariables,
+ skip: !marketId,
+ });
+ const { data: marketData, loading: marketDataLoading } = useDataProvider({
+ dataProvider: marketDataProvider,
+ variables: marketVariables,
+ });
+ const { data: orderData, loading: orderDataLoading } = useDataProvider({
+ dataProvider: ordersWithMarketProvider,
+ variables: orderVariables,
+ });
+
+ const orders = useMemo(() => {
+ if (!orderData || !market) return [];
+ return (
+ orderData
+ .filter((o) => {
+ // Filter out orders not on market for position
+ if (
+ !o ||
+ !o.node ||
+ !o.node.market ||
+ o.node.market.id !== market.id
+ ) {
+ return false;
+ }
+
+ if (!isOrderActive(o.node.status)) {
+ return false;
+ }
+
+ return true;
+ })
+ // @ts-ignore o is never null as its been filtered out above
+ .map((o) => o.node)
+ );
+ }, [orderData, market]);
+
+ return {
+ market,
+ marketData,
+ orders,
+ loading: marketLoading || marketDataLoading || orderDataLoading,
+ };
+};
diff --git a/libs/positions/tsconfig.spec.json b/libs/positions/tsconfig.spec.json
index 3ce050074..3da863401 100644
--- a/libs/positions/tsconfig.spec.json
+++ b/libs/positions/tsconfig.spec.json
@@ -2,22 +2,19 @@
"extends": "./tsconfig.json",
"compilerOptions": {
"outDir": "../../dist/out-tsc",
- "types": ["node"]
+ "module": "commonjs",
+ "types": ["jest", "node", "@testing-library/jest-dom"]
},
- "files": [
- "../../node_modules/@nrwl/react/typings/cssmodule.d.ts",
- "../../node_modules/@nrwl/next/typings/image.d.ts"
- ],
- "exclude": [
- "**/*.spec.ts",
+ "include": [
"**/*.test.ts",
- "**/*.spec.tsx",
+ "**/*.spec.ts",
"**/*.test.tsx",
- "**/*.spec.js",
+ "**/*.spec.tsx",
"**/*.test.js",
- "**/*.spec.jsx",
+ "**/*.spec.js",
"**/*.test.jsx",
+ "**/*.spec.jsx",
+ "**/*.d.ts",
"jest.config.ts"
- ],
- "include": ["**/*.js", "**/*.jsx", "**/*.ts", "**/*.tsx"]
+ ]
}
diff --git a/libs/wallet/src/TransactionResult.graphql b/libs/wallet/src/TransactionResult.graphql
new file mode 100644
index 000000000..7d4f928ee
--- /dev/null
+++ b/libs/wallet/src/TransactionResult.graphql
@@ -0,0 +1,13 @@
+subscription TransactionEvent($partyId: ID!) {
+ busEvents(partyId: $partyId, batchSize: 0, types: [TransactionResult]) {
+ type
+ event {
+ ... on TransactionResult {
+ partyId
+ hash
+ status
+ error
+ }
+ }
+ }
+}
diff --git a/libs/wallet/src/__generated___/TransactionResult.ts b/libs/wallet/src/__generated___/TransactionResult.ts
new file mode 100644
index 000000000..0175c41c3
--- /dev/null
+++ b/libs/wallet/src/__generated___/TransactionResult.ts
@@ -0,0 +1,51 @@
+import { Schema as Types } from '@vegaprotocol/types';
+
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {} as const;
+export type TransactionEventSubscriptionVariables = Types.Exact<{
+ partyId: Types.Scalars['ID'];
+}>;
+
+
+export type TransactionEventSubscription = { __typename?: 'Subscription', busEvents?: Array<{ __typename?: 'BusEvent', type: Types.BusEventType, event: { __typename?: 'Account' } | { __typename?: 'Asset' } | { __typename?: 'AuctionEvent' } | { __typename?: 'Deposit' } | { __typename?: 'LiquidityProvision' } | { __typename?: 'LossSocialization' } | { __typename?: 'MarginLevels' } | { __typename?: 'Market' } | { __typename?: 'MarketData' } | { __typename?: 'MarketEvent' } | { __typename?: 'MarketTick' } | { __typename?: 'NodeSignature' } | { __typename?: 'OracleSpec' } | { __typename?: 'Order' } | { __typename?: 'Party' } | { __typename?: 'PositionResolution' } | { __typename?: 'Proposal' } | { __typename?: 'RiskFactor' } | { __typename?: 'SettleDistressed' } | { __typename?: 'SettlePosition' } | { __typename?: 'TimeUpdate' } | { __typename?: 'Trade' } | { __typename?: 'TransactionResult', partyId: string, hash: string, status: boolean, error?: string | null } | { __typename?: 'TransferResponses' } | { __typename?: 'Vote' } | { __typename?: 'Withdrawal' } }> | null };
+
+
+export const TransactionEventDocument = gql`
+ subscription TransactionEvent($partyId: ID!) {
+ busEvents(partyId: $partyId, batchSize: 0, types: [TransactionResult]) {
+ type
+ event {
+ ... on TransactionResult {
+ partyId
+ hash
+ status
+ error
+ }
+ }
+ }
+}
+ `;
+
+/**
+ * __useTransactionEventSubscription__
+ *
+ * To run a query within a React component, call `useTransactionEventSubscription` and pass it any options that fit your needs.
+ * When your component renders, `useTransactionEventSubscription` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useTransactionEventSubscription({
+ * variables: {
+ * partyId: // value for 'partyId'
+ * },
+ * });
+ */
+export function useTransactionEventSubscription(baseOptions: Apollo.SubscriptionHookOptions) {
+ const options = {...defaultOptions, ...baseOptions}
+ return Apollo.useSubscription(TransactionEventDocument, options);
+ }
+export type TransactionEventSubscriptionHookResult = ReturnType;
+export type TransactionEventSubscriptionResult = Apollo.SubscriptionResult;
\ No newline at end of file
diff --git a/libs/wallet/src/connect-dialog/json-rpc-connector-form.tsx b/libs/wallet/src/connect-dialog/json-rpc-connector-form.tsx
index a39202dd5..dfad3d52c 100644
--- a/libs/wallet/src/connect-dialog/json-rpc-connector-form.tsx
+++ b/libs/wallet/src/connect-dialog/json-rpc-connector-form.tsx
@@ -136,7 +136,7 @@ const Connecting = ({
{t(`${window.location.host} now has access to your Wallet, however you don't
- have sufficient permissions to retrieve your public keys. Got to your wallet to approve new permissions.`)}
+ have sufficient permissions to retrieve your public keys. Go to your wallet to approve new permissions.`)}
);
diff --git a/libs/wallet/src/connectors/vega-connector.ts b/libs/wallet/src/connectors/vega-connector.ts
index d428cce9b..6c2e022ed 100644
--- a/libs/wallet/src/connectors/vega-connector.ts
+++ b/libs/wallet/src/connectors/vega-connector.ts
@@ -20,36 +20,41 @@ export interface UndelegateSubmissionBody {
};
}
+interface OrderSubmission {
+ marketId: string;
+ reference?: string;
+ type: OrderType;
+ side: Side;
+ timeInForce: OrderTimeInForce;
+ size: string;
+ price?: string;
+ expiresAt?: string;
+}
+
+interface OrderCancellation {
+ orderId: string;
+ marketId: string;
+}
+
+interface OrderAmendment {
+ marketId: string;
+ orderId: string;
+ reference?: string;
+ timeInForce: OrderTimeInForce;
+ sizeDelta?: number;
+ price?: string;
+ expiresAt?: string;
+}
export interface OrderSubmissionBody {
- orderSubmission: {
- marketId: string;
- reference?: string;
- type: OrderType;
- side: Side;
- timeInForce: OrderTimeInForce;
- size: string;
- price?: string;
- expiresAt?: string;
- };
+ orderSubmission: OrderSubmission;
}
export interface OrderCancellationBody {
- orderCancellation: {
- orderId: string;
- marketId: string;
- };
+ orderCancellation: OrderCancellation;
}
export interface OrderAmendmentBody {
- orderAmendment: {
- marketId: string;
- orderId: string;
- reference?: string;
- timeInForce: OrderTimeInForce;
- sizeDelta?: number;
- price?: string;
- expiresAt?: string;
- };
+ orderAmendment: OrderAmendment;
}
export interface VoteSubmissionBody {
@@ -250,6 +255,18 @@ export interface ProposalSubmissionBody {
proposalSubmission: ProposalSubmission;
}
+export interface BatchMarketInstructionSubmissionBody {
+ batchMarketInstructions: {
+ // Will be processed in this order and the total amount of instructions is
+ // restricted by the net param spam.protection.max.batchSize
+ cancellations?: OrderCancellation[];
+ amendments?: OrderAmendment[];
+ // Note: If multiple orders are submitted the first order ID is determined by hashing the signature of the transaction
+ // (see determineId function). For each subsequent order's ID, a hash of the previous orders ID is used
+ submissions?: OrderSubmission[];
+ };
+}
+
export type Transaction =
| OrderSubmissionBody
| OrderCancellationBody
@@ -258,7 +275,8 @@ export type Transaction =
| DelegateSubmissionBody
| UndelegateSubmissionBody
| OrderAmendmentBody
- | ProposalSubmissionBody;
+ | ProposalSubmissionBody
+ | BatchMarketInstructionSubmissionBody;
export interface TransactionResponse {
transactionHash: string;
diff --git a/libs/wallet/src/index.ts b/libs/wallet/src/index.ts
index 7e5b99990..0aa0108ef 100644
--- a/libs/wallet/src/index.ts
+++ b/libs/wallet/src/index.ts
@@ -2,6 +2,7 @@ export * from './context';
export * from './use-vega-wallet';
export * from './connectors';
export * from './use-vega-transaction';
+export * from './use-transaction-result';
export * from './use-eager-connect';
export * from './manage-dialog';
export * from './vega-transaction-dialog';
@@ -9,3 +10,4 @@ export * from './provider';
export * from './connect-dialog';
export * from './utils';
export * from './constants';
+export * from './__generated___/TransactionResult';
diff --git a/libs/wallet/src/use-transaction-result.spec.tsx b/libs/wallet/src/use-transaction-result.spec.tsx
new file mode 100644
index 000000000..e8d993538
--- /dev/null
+++ b/libs/wallet/src/use-transaction-result.spec.tsx
@@ -0,0 +1,57 @@
+import type { ReactNode } from 'react';
+import type { MockedResponse } from '@apollo/client/testing';
+import { MockedProvider } from '@apollo/client/testing';
+import { renderHook } from '@testing-library/react';
+import { Schema as Types } from '@vegaprotocol/types';
+import type { TransactionEventSubscription } from './__generated___/TransactionResult';
+import { TransactionEventDocument } from './__generated___/TransactionResult';
+import { useTransactionResult } from './use-transaction-result';
+
+const pubKey = 'test-pubkey';
+const txHash = '0x123';
+const event = {
+ __typename: 'TransactionResult',
+ partyId: pubKey,
+ hash: txHash,
+ status: true,
+ error: null,
+};
+
+function setup(mock: MockedResponse) {
+ const wrapper = ({ children }: { children: ReactNode }) => (
+ {children}
+ );
+ return renderHook(() => useTransactionResult(), { wrapper });
+}
+
+describe('useTransactionResult', () => {
+ it('resolves when a matching txhash is found', async () => {
+ const mock: MockedResponse = {
+ request: {
+ query: TransactionEventDocument,
+ variables: {
+ partyId: pubKey,
+ },
+ },
+ result: {
+ data: {
+ busEvents: [
+ {
+ type: Types.BusEventType.TransactionResult,
+ event,
+ __typename: 'BusEvent',
+ },
+ ] as TransactionEventSubscription['busEvents'],
+ },
+ },
+ };
+ const { result } = setup(mock);
+ expect(result.current).toEqual(expect.any(Function));
+ const promi = result.current(txHash, pubKey);
+ expect(typeof promi === 'object' && typeof promi.then === 'function').toBe(
+ true
+ );
+ const res = await promi;
+ expect(res).toEqual(event);
+ });
+});
diff --git a/libs/wallet/src/use-transaction-result.ts b/libs/wallet/src/use-transaction-result.ts
new file mode 100644
index 000000000..ddbbd8903
--- /dev/null
+++ b/libs/wallet/src/use-transaction-result.ts
@@ -0,0 +1,74 @@
+import { useApolloClient } from '@apollo/client';
+import { BusEventType } from '@vegaprotocol/types';
+import { useCallback, useEffect, useRef } from 'react';
+import type { Subscription } from 'zen-observable-ts';
+import type {
+ TransactionEventSubscription,
+ TransactionEventSubscriptionVariables,
+} from './__generated___/TransactionResult';
+import { TransactionEventDocument } from './__generated___/TransactionResult';
+
+export interface TransactionResult {
+ partyId: string;
+ hash: string;
+ status: boolean;
+ error?: string | null;
+ __typename: 'TransactionResult';
+}
+
+type WaitFunc = (txHash: string, partyId: string) => Promise;
+
+/**
+ * Returns a function that can be called to subscribe to a transaction
+ * result event and resolves when an event with a matching txhash is seen
+ */
+export const useTransactionResult = () => {
+ const client = useApolloClient();
+ const subRef = useRef(null);
+
+ const waitForTransactionResult = useCallback(
+ (txHash: string, partyId: string) => {
+ return new Promise((resolve) => {
+ subRef.current = client
+ .subscribe<
+ TransactionEventSubscription,
+ TransactionEventSubscriptionVariables
+ >({
+ query: TransactionEventDocument,
+ variables: { partyId },
+ })
+ .subscribe(({ data }) => {
+ if (!data?.busEvents?.length) {
+ return;
+ }
+
+ const matchingTransaction = data.busEvents.find((e) => {
+ if (e.event.__typename !== BusEventType.TransactionResult) {
+ return false;
+ }
+
+ return e.event.hash.toLocaleLowerCase() === txHash.toLowerCase();
+ });
+
+ if (
+ matchingTransaction &&
+ matchingTransaction.event.__typename ===
+ BusEventType.TransactionResult
+ ) {
+ resolve(matchingTransaction.event as TransactionResult);
+ subRef.current?.unsubscribe();
+ }
+ });
+ });
+ },
+ [client]
+ );
+
+ useEffect(() => {
+ return () => {
+ subRef.current?.unsubscribe();
+ };
+ }, []);
+
+ return waitForTransactionResult;
+};
diff --git a/libs/wallet/src/use-vega-transaction.tsx b/libs/wallet/src/use-vega-transaction.tsx
index 8a0a7098e..3cc8bd348 100644
--- a/libs/wallet/src/use-vega-transaction.tsx
+++ b/libs/wallet/src/use-vega-transaction.tsx
@@ -1,6 +1,7 @@
import type { ReactNode } from 'react';
import { useCallback, useMemo, useState } from 'react';
import { useVegaWallet } from './use-vega-wallet';
+import type { VegaTransactionContentMap } from './vega-transaction-dialog';
import { VegaTransactionDialog } from './vega-transaction-dialog';
import type { Intent } from '@vegaprotocol/ui-toolkit';
import type { Transaction } from './connectors';
@@ -8,10 +9,10 @@ import { ClientErrors } from './connectors';
import { WalletError } from './connectors';
export interface DialogProps {
- children?: JSX.Element;
intent?: Intent;
title?: string;
icon?: ReactNode;
+ content?: VegaTransactionContentMap;
}
export enum VegaTxStatus {
diff --git a/libs/wallet/src/vega-transaction-dialog/vega-transaction-dialog.spec.tsx b/libs/wallet/src/vega-transaction-dialog/vega-transaction-dialog.spec.tsx
index d36c2cd99..8cfecfb79 100644
--- a/libs/wallet/src/vega-transaction-dialog/vega-transaction-dialog.spec.tsx
+++ b/libs/wallet/src/vega-transaction-dialog/vega-transaction-dialog.spec.tsx
@@ -96,25 +96,30 @@ describe('VegaTransactionDialog', () => {
testBlockExplorerLink('tx-hash');
});
- it('custom complete', () => {
- render(
-
- Custom content
-
- );
- expect(screen.getByTestId('dialog-title')).toHaveTextContent(
- 'Custom title'
- );
- expect(screen.getByText('Custom content')).toBeInTheDocument();
- });
+ it.each(Object.keys(VegaTxStatus))(
+ 'renders custom content for %s',
+ (status) => {
+ const title = `${status} title`;
+ const text = `${status} content`;
+ const content = {
+ [status]: {text}
,
+ };
+ render(
+
- {content}
+
);
};
+interface ContentProps {
+ transaction: VegaTxState;
+ content?: VegaTransactionContentMap;
+}
+
+const Content = ({ transaction, content }: ContentProps) => {
+ if (!content) {
+ return
- {
- createWithdraw.reset();
- completeWithdraw.submit(id);
- }}
- />
-
+ {
+ createWithdraw.reset();
+ completeWithdraw.submit(id);
+ }}
+ />
+ ),
+ }}
+ />