-
Notifications
You must be signed in to change notification settings - Fork 542
/
execution-environment.ts
118 lines (105 loc) · 3.31 KB
/
execution-environment.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
import { ControllerMessenger } from '@metamask/base-controller';
import { SnapRpcHookArgs } from '@metamask/snaps-utils';
import { JsonRpcEngine } from 'json-rpc-engine';
import { createEngineStream } from 'json-rpc-middleware-stream';
import pump from 'pump';
import {
ExecutionService,
ExecutionServiceActions,
ExecutionServiceEvents,
NodeThreadExecutionService,
setupMultiplex,
SnapExecutionData,
} from '../services';
export const MOCK_BLOCK_NUMBER = '0xa70e75';
export const getNodeEESMessenger = (
messenger: ControllerMessenger<
ExecutionServiceActions,
ExecutionServiceEvents
>,
) =>
messenger.getRestricted({
name: 'ExecutionService',
allowedEvents: [
'ExecutionService:unhandledError',
'ExecutionService:outboundRequest',
'ExecutionService:outboundResponse',
],
allowedActions: [
'ExecutionService:executeSnap',
'ExecutionService:handleRpcRequest',
'ExecutionService:terminateAllSnaps',
'ExecutionService:terminateSnap',
],
});
export const getNodeEES = (messenger: ReturnType<typeof getNodeEESMessenger>) =>
new NodeThreadExecutionService({
messenger,
setupSnapProvider: jest.fn().mockImplementation((_snapId, rpcStream) => {
const mux = setupMultiplex(rpcStream, 'foo');
const stream = mux.createStream('metamask-provider');
const engine = new JsonRpcEngine();
engine.push((req, res, next, end) => {
if (req.method === 'metamask_getProviderState') {
res.result = {
isUnlocked: false,
accounts: [],
chainId: '0x1',
networkVersion: '1',
};
return end();
} else if (req.method === 'eth_blockNumber') {
res.result = MOCK_BLOCK_NUMBER;
return end();
}
return next();
});
const providerStream = createEngineStream({ engine });
pump(stream, providerStream, stream);
}),
});
export class ExecutionEnvironmentStub implements ExecutionService {
constructor(messenger: ReturnType<typeof getNodeEESMessenger>) {
messenger.registerActionHandler(
`ExecutionService:handleRpcRequest`,
async (snapId: string, options: SnapRpcHookArgs) =>
this.handleRpcRequest(snapId, options),
);
messenger.registerActionHandler(
'ExecutionService:executeSnap',
async (snapData: SnapExecutionData) => this.executeSnap(snapData),
);
messenger.registerActionHandler(
'ExecutionService:terminateSnap',
async (snapId: string) => this.terminateSnap(snapId),
);
messenger.registerActionHandler(
'ExecutionService:terminateAllSnaps',
async () => this.terminateAllSnaps(),
);
}
async handleRpcRequest(
snapId: string,
options: SnapRpcHookArgs,
): Promise<unknown> {
const handler = this.getRpcRequestHandler(snapId);
return await handler(options);
}
async terminateAllSnaps() {
// empty stub
}
getRpcRequestHandler(_snapId: string) {
return async ({ request }: SnapRpcHookArgs) => {
return new Promise((resolve) => {
const results = `${request.method}${request.id}`;
resolve(results);
});
};
}
async executeSnap(_snapData: SnapExecutionData) {
return Promise.resolve('some-unique-id');
}
async terminateSnap(_snapId: string) {
// empty stub
}
}