@instadapp/interop-x 0.0.0-dev.f9253db → 0.0.0-dev.fabee70

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (73) hide show
  1. package/bin/interop-x +1 -1
  2. package/dist/package.json +73 -0
  3. package/dist/{abi → src/abi}/erc20.json +0 -0
  4. package/dist/{abi → src/abi}/gnosisSafe.json +0 -0
  5. package/dist/{abi → src/abi}/index.js +0 -0
  6. package/dist/{abi → src/abi}/interopBridgeToken.json +0 -0
  7. package/dist/{abi → src/abi}/interopXGateway.json +0 -0
  8. package/dist/src/api/index.js +33 -0
  9. package/dist/{config → src/config}/index.js +1 -0
  10. package/dist/{constants → src/constants}/addresses.js +0 -8
  11. package/dist/{constants → src/constants}/index.js +1 -0
  12. package/dist/src/constants/itokens.js +13 -0
  13. package/dist/{constants → src/constants}/tokens.js +0 -0
  14. package/dist/{db → src/db}/index.js +0 -0
  15. package/dist/{db → src/db}/models/index.js +0 -0
  16. package/dist/{db → src/db}/models/transaction.js +3 -1
  17. package/dist/{db → src/db}/sequelize.js +0 -0
  18. package/dist/src/index.js +107 -0
  19. package/dist/{logger → src/logger}/index.js +0 -0
  20. package/dist/{net → src/net}/index.js +0 -0
  21. package/dist/{net → src/net}/peer/index.js +8 -3
  22. package/dist/{net → src/net}/pool/index.js +32 -9
  23. package/dist/{net → src/net}/protocol/dial/BaseDialProtocol.js +0 -0
  24. package/dist/src/net/protocol/dial/SignatureDialProtocol.1.js +28 -0
  25. package/dist/{net → src/net}/protocol/dial/SignatureDialProtocol.js +22 -12
  26. package/dist/{net → src/net}/protocol/index.js +41 -1
  27. package/dist/src/tasks/AutoUpdateTask.js +57 -0
  28. package/dist/{tasks → src/tasks}/BaseTask.js +8 -4
  29. package/dist/src/tasks/InteropBridge/ProcessWithdrawEvents.js +146 -0
  30. package/dist/src/tasks/InteropBridge/SyncWithdrawEvents.js +69 -0
  31. package/dist/src/tasks/InteropXGateway/ProcessDepositEvents.js +149 -0
  32. package/dist/{tasks → src/tasks}/InteropXGateway/SyncDepositEvents.js +16 -21
  33. package/dist/src/tasks/Transactions/SyncTransactionStatusTask.js +53 -0
  34. package/dist/src/tasks/index.js +44 -0
  35. package/dist/{typechain → src/typechain}/Erc20.js +0 -0
  36. package/dist/{typechain → src/typechain}/GnosisSafe.js +0 -0
  37. package/dist/{typechain → src/typechain}/InteropBridgeToken.js +0 -0
  38. package/dist/{typechain → src/typechain}/InteropXGateway.js +0 -0
  39. package/dist/{typechain → src/typechain}/common.js +0 -0
  40. package/dist/{typechain → src/typechain}/factories/Erc20__factory.js +0 -0
  41. package/dist/{typechain → src/typechain}/factories/GnosisSafe__factory.js +0 -0
  42. package/dist/{typechain → src/typechain}/factories/InteropBridgeToken__factory.js +0 -0
  43. package/dist/{typechain → src/typechain}/factories/InteropXGateway__factory.js +0 -0
  44. package/dist/{typechain → src/typechain}/factories/index.js +0 -0
  45. package/dist/{typechain → src/typechain}/index.js +0 -0
  46. package/dist/{types.js → src/types.js} +0 -0
  47. package/dist/src/utils/index.js +238 -0
  48. package/package.json +9 -3
  49. package/patches/@ethersproject+properties+5.6.0.patch +13 -0
  50. package/src/api/index.ts +33 -0
  51. package/src/config/index.ts +2 -0
  52. package/src/constants/addresses.ts +0 -8
  53. package/src/constants/index.ts +1 -0
  54. package/src/constants/itokens.ts +10 -0
  55. package/src/db/models/transaction.ts +8 -4
  56. package/src/index.ts +62 -6
  57. package/src/net/peer/index.ts +9 -7
  58. package/src/net/pool/index.ts +41 -11
  59. package/src/net/protocol/dial/SignatureDialProtocol.1.ts +31 -0
  60. package/src/net/protocol/dial/SignatureDialProtocol.ts +25 -13
  61. package/src/net/protocol/index.ts +57 -1
  62. package/src/tasks/AutoUpdateTask.ts +73 -0
  63. package/src/tasks/BaseTask.ts +9 -4
  64. package/src/tasks/InteropBridge/ProcessWithdrawEvents.ts +231 -0
  65. package/src/tasks/InteropBridge/SyncWithdrawEvents.ts +119 -0
  66. package/src/tasks/InteropXGateway/ProcessDepositEvents.ts +243 -0
  67. package/src/tasks/InteropXGateway/SyncDepositEvents.ts +23 -13
  68. package/src/tasks/Transactions/SyncTransactionStatusTask.ts +65 -0
  69. package/src/tasks/index.ts +24 -2
  70. package/src/utils/index.ts +197 -7
  71. package/dist/index.js +0 -63
  72. package/dist/tasks/index.js +0 -27
  73. package/dist/utils/index.js +0 -101
@@ -0,0 +1,31 @@
1
+ import { BaseDialProtocol } from "./BaseDialProtocol";
2
+ import { Transaction } from "@/db";
3
+
4
+ export class TransactionStatusDialProtocol extends BaseDialProtocol<string, Pick<Transaction, 'transactionHash' | 'sourceStatus' | 'sourceTransactionHash' | 'sourceErrors' | 'targetStatus' | 'targetTransactionHash' | 'targetErrors' | 'status'> | null> {
5
+ protected timeout = 30000;
6
+
7
+ constructor(libp2p) {
8
+ super(libp2p, '/interop-x/transaction-status')
9
+ }
10
+
11
+ async response(transactionHash: string){
12
+ const transaction = await Transaction.findOne({ where: { transactionHash } })
13
+
14
+ if(! transaction){
15
+ return null
16
+ }
17
+ return {
18
+ transactionHash: transaction.transactionHash,
19
+
20
+ sourceStatus: transaction.sourceStatus,
21
+ sourceTransactionHash: transaction.sourceTransactionHash,
22
+ sourceErrors: transaction.sourceErrors,
23
+
24
+ targetStatus: transaction.targetStatus,
25
+ targetTransactionHash: transaction.targetTransactionHash,
26
+ targetErrors: transaction.targetErrors,
27
+
28
+ status: transaction.status,
29
+ }
30
+ }
31
+ }
@@ -2,9 +2,12 @@ import { BaseDialProtocol } from "./BaseDialProtocol";
2
2
  import wait from "waait";
3
3
  import config from "@/config";
4
4
  import { Transaction } from "@/db";
5
+ import { buildDataForTransaction, signGnosisSafeTx } from "@/utils";
6
+ import { addresses } from "@/constants";
7
+ import { ChainId } from "@/types";
5
8
 
6
9
  export interface ISignatureRequest {
7
- type: string,
10
+ type: 'source' | 'target' ,
8
11
  transactionHash: string
9
12
  safeTxGas: string
10
13
  safeNonce: string
@@ -24,19 +27,19 @@ export class SignatureDialProtocol extends BaseDialProtocol<ISignatureRequest, I
24
27
  async response(data: ISignatureRequest): Promise<ISignatureResponse> {
25
28
  const signer = config.wallet;
26
29
 
27
- let event: Transaction | null;
30
+ let transaction: Transaction | null;
28
31
  let maxTimeout = 20000;
29
32
 
30
33
  do {
31
- event = await Transaction.findOne({ where: { transactionHash: data.transactionHash } })
34
+ transaction = await Transaction.findOne({ where: { transactionHash: data.transactionHash } })
32
35
 
33
- if (!event) {
36
+ if (!transaction) {
34
37
  await wait(1000);
35
38
  maxTimeout -= 1000;
36
39
  }
37
- } while (!event && maxTimeout > 0)
40
+ } while (!transaction && maxTimeout > 0)
38
41
 
39
- if (!event) {
42
+ if (!transaction) {
40
43
  return {
41
44
  signer: signer.address,
42
45
  data: null,
@@ -44,16 +47,25 @@ export class SignatureDialProtocol extends BaseDialProtocol<ISignatureRequest, I
44
47
  };
45
48
  }
46
49
 
47
- // const signedData = await signGnosisSafeTx({
48
- // to: addresses[event.chainId as ChainId].multisend,
49
- // data: 'TODO',
50
- // chainId: event.chainId as ChainId,
51
- // safeTxGas: data.safeTxGas,
52
- // }, { signer });
50
+ console.log("signing:", {
51
+ to: addresses[transaction.targetChainId].multisend,
52
+ data: await buildDataForTransaction(transaction, data.type),
53
+ chainId: transaction.targetChainId as ChainId,
54
+ safeTxGas: data.safeTxGas,
55
+ nonce: data.safeNonce,
56
+ });
57
+
58
+ const signedData = await signGnosisSafeTx({
59
+ to: addresses[transaction.targetChainId].multisend,
60
+ data: await buildDataForTransaction(transaction, data.type),
61
+ chainId: transaction.targetChainId as ChainId,
62
+ safeTxGas: data.safeTxGas,
63
+ nonce: data.safeNonce,
64
+ }, { signer });
53
65
 
54
66
  return {
55
67
  signer: signer.address,
56
- data: null, //signedData,
68
+ data: signedData
57
69
  }
58
70
  }
59
71
  }
@@ -5,6 +5,8 @@ import { SignatureDialProtocol, ISignatureRequest, ISignatureResponse } from "./
5
5
  import { IPeerInfo, peerPool } from "..";
6
6
  import config from "@/config";
7
7
  import { Event } from "@/types";
8
+ import { Transaction } from "@/db";
9
+ import { TransactionStatusDialProtocol } from "./dial/SignatureDialProtocol.1";
8
10
 
9
11
  export interface ProtocolOptions {
10
12
  /* Handshake timeout in ms (default: 8000) */
@@ -33,7 +35,12 @@ interface PeerInfoEvent extends BaseMessageEvent {
33
35
  data: Omit<IPeerInfo, 'id' | 'updated' | 'idle' | 'pooled'>
34
36
  }
35
37
 
38
+ interface TransactionStatusEvent extends BaseMessageEvent {
39
+ data: Pick<Transaction, 'transactionHash' | 'sourceStatus' | 'sourceTransactionHash' | 'sourceErrors' | 'targetStatus' | 'targetTransactionHash' | 'targetErrors' | 'status'>
40
+ }
41
+
36
42
  declare interface Protocol {
43
+ on(event: 'TransactionStatus', listener: (payload: TransactionStatusEvent) => void): this;
37
44
  on(event: 'PeerInfo', listener: (payload: PeerInfoEvent) => void): this;
38
45
  on(event: string, listener: (payload: BaseMessageEvent) => void): this;
39
46
  }
@@ -44,7 +51,7 @@ class Protocol extends EventEmitter {
44
51
  private protocolMessages: Message[] = [
45
52
  {
46
53
  name: 'PeerInfo',
47
- code: 0x09,
54
+ code: 0x01,
48
55
  encode: (info: Pick<IPeerInfo, 'publicAddress'>) => [
49
56
  Buffer.from(info.publicAddress),
50
57
  ],
@@ -52,8 +59,39 @@ class Protocol extends EventEmitter {
52
59
  publicAddress: publicAddress.toString(),
53
60
  }),
54
61
  },
62
+ {
63
+ name: 'TransactionStatus',
64
+ code: 0x02,
65
+ encode: (transaction: Transaction) => [
66
+ Buffer.from(transaction.transactionHash),
67
+
68
+ Buffer.from(transaction.sourceStatus),
69
+ Buffer.from(transaction.sourceTransactionHash),
70
+ transaction.sourceErrors ? transaction.sourceErrors.map((e) => Buffer.from(e)) : [],
71
+
72
+ Buffer.from(transaction.targetStatus),
73
+ Buffer.from(transaction.targetTransactionHash),
74
+ transaction.targetErrors ? transaction.targetErrors.map((e) => Buffer.from(e)) : [],
75
+
76
+ Buffer.from(transaction.status),
77
+ ],
78
+ decode: ([transactionHash, sourceStatus, sourceTransactionHash, sourceErrors, targetStatus, targetTransactionHash, targetErrors, status]: [Buffer, Buffer, Buffer, Buffer[], Buffer, Buffer, Buffer[], Buffer]) => ({
79
+ transactionHash: transactionHash.toString(),
80
+
81
+ sourceStatus: sourceStatus.toString(),
82
+ sourceTransactionHash: sourceTransactionHash.toString(),
83
+ sourceErrors: sourceErrors.map((e) => e.toString()),
84
+
85
+ targetStatus: targetStatus.toString(),
86
+ targetTransactionHash: targetTransactionHash.toString(),
87
+ targetErrors: targetErrors.map((e) => e.toString()),
88
+
89
+ status: status.toString(),
90
+ }),
91
+ },
55
92
  ];
56
93
  private signature: SignatureDialProtocol;
94
+ private transactionStatus: TransactionStatusDialProtocol;
57
95
 
58
96
 
59
97
  start({ libp2p, topic = null, }) {
@@ -73,6 +111,7 @@ class Protocol extends EventEmitter {
73
111
  })
74
112
 
75
113
  this.signature = new SignatureDialProtocol(this.libp2p);
114
+ this.transactionStatus = new TransactionStatusDialProtocol(this.libp2p);
76
115
  }
77
116
 
78
117
 
@@ -121,6 +160,14 @@ class Protocol extends EventEmitter {
121
160
  this.libp2p.pubsub.publish(this.topic, encoded)
122
161
  }
123
162
 
163
+ public sendTransaction(transaction: Transaction) {
164
+ const message = this.protocolMessages.find((m) => m.name === 'TransactionStatus')!
165
+
166
+ const encoded = rlp.encode([message.code, message.encode(transaction)]);
167
+
168
+ this.libp2p.pubsub.publish(this.topic, encoded)
169
+ }
170
+
124
171
  async requestSignatures(data: ISignatureRequest, peerIds?: string[]) {
125
172
  try {
126
173
  peerIds = peerIds || peerPool.activePeerIds;
@@ -133,6 +180,15 @@ class Protocol extends EventEmitter {
133
180
  return []
134
181
  }
135
182
  }
183
+
184
+ async requestTransactionStatus(transactionHash: string, peerId: string) {
185
+ try {
186
+ return await this.transactionStatus.send(transactionHash, peerId);
187
+ } catch (error) {
188
+ console.log(error);
189
+ return null
190
+ }
191
+ }
136
192
  }
137
193
 
138
194
  export const protocol = new Protocol();
@@ -0,0 +1,73 @@
1
+ import { BaseTask } from "./BaseTask";
2
+ import Logger from '@/logger';
3
+ import { http } from "@/utils";
4
+ import spawn from 'await-spawn';
5
+ import config from "@/config";
6
+ import wait from "waait";
7
+ import packageJson from "../../package.json";
8
+
9
+ const currentVersion = packageJson.version;
10
+
11
+ class AutoUpdateTask extends BaseTask {
12
+ pollIntervalMs: number = 60 * 5 * 1000
13
+
14
+ constructor() {
15
+ super({
16
+ logger: new Logger("AutoUpdateTask"),
17
+ })
18
+ }
19
+
20
+ prePollHandler(): boolean {
21
+ return config.autoUpdate && !config.isLeadNode();
22
+ }
23
+
24
+ async getInstalledVersion() {
25
+ try {
26
+ const stdout = await spawn('npm', ['-g', 'ls', '--depth=0', '--json'])
27
+
28
+
29
+ return JSON.parse(stdout.toString()).dependencies[packageJson.name].version
30
+ } catch (error) {
31
+ this.logger.error(error)
32
+
33
+ return currentVersion
34
+ }
35
+ }
36
+
37
+ async pollHandler() {
38
+
39
+ const { data } = await http.get('https://registry.npmjs.org/@instadapp/interop-x')
40
+
41
+ const version = data['dist-tags'].latest
42
+
43
+ if (version === currentVersion) {
44
+ return;
45
+ }
46
+
47
+ this.logger.warn(`New version ${version} available.`)
48
+
49
+
50
+ this.logger.info('Updating...')
51
+
52
+ await spawn('npm', ['-g', 'install', '@instadapp/interop-x', '-f']);
53
+
54
+ await wait(5000)
55
+
56
+ if (version !== await this.getInstalledVersion()) {
57
+ this.logger.warn(`failed to install ${version}, retrying in 5 minutes`)
58
+ return;
59
+ }
60
+
61
+ this.logger.warn(`Installed version ${version}`)
62
+ this.logger.warn(`Restarting...`)
63
+
64
+ spawn(process.argv[0], process.argv.slice(1), {
65
+ cwd: process.cwd(),
66
+ stdio: "inherit"
67
+ });
68
+
69
+ process.exit()
70
+ }
71
+ }
72
+
73
+ export default AutoUpdateTask;
@@ -19,6 +19,7 @@ export class BaseTask extends EventEmitter implements IBaseTask {
19
19
  started: boolean = false
20
20
  pollIntervalMs: number = 10 * 1000
21
21
  leadNodeOnly: boolean = false
22
+ exceptLeadNode: boolean = false
22
23
 
23
24
  public constructor({ logger }: { logger?: Logger }) {
24
25
  super()
@@ -37,7 +38,7 @@ export class BaseTask extends EventEmitter implements IBaseTask {
37
38
  await this.pollHandler()
38
39
  }
39
40
  } catch (err) {
40
- this.logger.error(`poll check error: ${err.message}\ntrace: ${err.stack}`)
41
+ this.logger.error(`poll check error:\n${err.message}\ntrace: ${err.stack}`)
41
42
  }
42
43
 
43
44
  await this.postPollHandler()
@@ -45,11 +46,15 @@ export class BaseTask extends EventEmitter implements IBaseTask {
45
46
  }
46
47
 
47
48
  prePollHandler(): boolean {
48
- if (!this.leadNodeOnly) {
49
- return true
49
+ if (this.exceptLeadNode) {
50
+ return !config.isLeadNode();
50
51
  }
51
52
 
52
- return config.isLeadNode()
53
+ if (this.leadNodeOnly) {
54
+ return config.isLeadNode()
55
+ }
56
+
57
+ return true
53
58
  }
54
59
 
55
60
  async pollHandler() {
@@ -0,0 +1,231 @@
1
+ import { BaseTask } from "../BaseTask";
2
+ import Logger from '@/logger';
3
+ import { BigNumber, ethers } from "ethers";
4
+ import abi from "@/abi";
5
+ import { Transaction } from "@/db";
6
+ import { buildDataForTransaction, buildSignatureBytes, getContract, getRpcProviderUrl, Signature } from "@/utils";
7
+ import { addresses } from "@/constants";
8
+ import { ChainId } from "@/types";
9
+ import config from "@/config";
10
+ import { GnosisSafe, InteropXGateway } from "@/typechain";
11
+ import { Op } from "sequelize";
12
+ import wait from "waait";
13
+ import { peerPool, protocol } from "@/net";
14
+ import { LogDescription } from "ethers/lib/utils";
15
+
16
+ const generateGnosisTransaction = async (transactionData: any, safeContract: GnosisSafe) => {
17
+ console.log(transactionData);
18
+
19
+ let isExecuted = await safeContract.dataHashes(
20
+ await safeContract.getTransactionHash(
21
+ transactionData.to,
22
+ transactionData.value,
23
+ transactionData.data,
24
+ transactionData.operation,
25
+ transactionData.safeTxGas,
26
+ transactionData.baseGas,
27
+ transactionData.gasPrice,
28
+ transactionData.gasToken,
29
+ transactionData.refundReceiver,
30
+ transactionData.nonce
31
+ )
32
+ )
33
+
34
+ while (isExecuted == 1) {
35
+ transactionData.safeTxGas = BigNumber.from(String(transactionData.safeTxGas)).add(1).toString()
36
+
37
+ isExecuted = await safeContract.dataHashes(
38
+ await safeContract.getTransactionHash(
39
+ transactionData.to,
40
+ transactionData.value,
41
+ transactionData.data,
42
+ transactionData.operation,
43
+ transactionData.safeTxGas,
44
+ transactionData.baseGas,
45
+ transactionData.gasPrice,
46
+ transactionData.gasToken,
47
+ transactionData.refundReceiver,
48
+ transactionData.nonce
49
+ )
50
+ )
51
+ }
52
+
53
+ return transactionData
54
+ }
55
+
56
+ class ProcessWithdrawEvents extends BaseTask {
57
+ provider: ethers.providers.JsonRpcProvider;
58
+ chainId: ChainId;
59
+ leadNodeOnly = true
60
+
61
+ constructor({ chainId }: { chainId: ChainId }) {
62
+ super({
63
+ logger: new Logger("InteropXGateway::ProcessWithdrawEvents"),
64
+ })
65
+ this.chainId = chainId;
66
+ }
67
+
68
+ async pollHandler() {
69
+ const blockNumber = await this.provider.getBlockNumber()
70
+
71
+ const transaction = await Transaction.findOne({
72
+ where: {
73
+ status: 'pending',
74
+ sourceStatus: 'success',
75
+ targetStatus: 'uninitialised',
76
+ action: 'withdraw',
77
+ sourceCreatedAt: {
78
+ [Op.gte]: new Date(Date.now() - 12 * 60 * 60 * 1000),
79
+ },
80
+ targetDelayUntil: {
81
+ [Op.or]: {
82
+ [Op.is]: null,
83
+ [Op.lt]: new Date(),
84
+ }
85
+ },
86
+ sourceBlockNumber: {
87
+ [Op.lt]: blockNumber - 12,
88
+ },
89
+ sourceChainId: this.chainId,
90
+ }
91
+ })
92
+
93
+ if (!transaction) {
94
+ return;
95
+ }
96
+
97
+ console.log(`Processing transaction ${transaction.transactionHash}`);
98
+
99
+ transaction.targetStatus = 'pending';
100
+ await transaction.save();
101
+
102
+ // refresh event data?
103
+
104
+ const targetChainProvider = new ethers.providers.JsonRpcProvider(
105
+ getRpcProviderUrl(transaction.targetChainId as ChainId)
106
+ );
107
+
108
+ const targetWallet = new ethers.Wallet(config.privateKey!, targetChainProvider);
109
+
110
+ const safeAddress = addresses[transaction.targetChainId].gnosisSafe;
111
+
112
+
113
+ const safeContract = getContract<GnosisSafe>(
114
+ safeAddress,
115
+ abi.gnosisSafe,
116
+ targetWallet
117
+ )
118
+
119
+ const ownersThreshold = await safeContract.getThreshold();
120
+ await wait(10000);
121
+
122
+ let gnosisTx = await generateGnosisTransaction({
123
+ baseGas: "0",
124
+ data: await buildDataForTransaction(transaction),
125
+ gasPrice: "0",
126
+ gasToken: "0x0000000000000000000000000000000000000000",
127
+ nonce: '0',
128
+ operation: "1",
129
+ refundReceiver: "0x0000000000000000000000000000000000000000",
130
+ safeAddress: safeAddress,
131
+ safeTxGas: "79668",
132
+ to: addresses[transaction.targetChainId].multisend,
133
+ value: "0",
134
+ }, safeContract);
135
+
136
+ const owners = await safeContract.getOwners().then(owners => owners.map(owner => owner.toLowerCase()));
137
+
138
+ const ownerPeerIds = peerPool.activePeers.filter(peer => owners.includes(peer.publicAddress.toLowerCase())).map(peer => peer.id)
139
+
140
+ console.log(`Collecting signatures for execution ${transaction.transactionHash}`)
141
+
142
+ console.log(ownerPeerIds);
143
+
144
+ const signatures = await protocol.requestSignatures({
145
+ type: 'source',
146
+ transactionHash: transaction.transactionHash,
147
+ safeTxGas: gnosisTx.safeTxGas,
148
+ safeNonce: gnosisTx.nonce
149
+ }, ownerPeerIds)
150
+
151
+
152
+ const validSignatures = signatures.filter(s => !!s.data && s.data !== '0x') as Signature[];
153
+
154
+ console.log({ signatures, validSignatures, ownersThreshold: ownersThreshold.toString() });
155
+
156
+ if (validSignatures.length === 0 || ownersThreshold.gt(validSignatures.length)) {
157
+ await transaction.save();
158
+ transaction.targetDelayUntil = new Date(Date.now() + 30 * 1000);
159
+ transaction.targetStatus = 'uninitialised'
160
+
161
+ await transaction.save();
162
+ const errorMessage = signatures.find(s => !!s.error)?.error;
163
+ throw new Error(`Not enough signatures` + (errorMessage ? `: ${errorMessage}` : ''));
164
+ }
165
+
166
+
167
+ console.log(`Executing transaction for execution ${transaction.transactionHash}`)
168
+
169
+ const { data: txData } = await safeContract.populateTransaction.execTransaction(
170
+ gnosisTx.to,
171
+ gnosisTx.value,
172
+ gnosisTx.data,
173
+ gnosisTx.operation,
174
+ gnosisTx.safeTxGas,
175
+ gnosisTx.baseGas,
176
+ gnosisTx.gasPrice,
177
+ gnosisTx.gasToken,
178
+ gnosisTx.refundReceiver,
179
+ buildSignatureBytes(validSignatures)
180
+ );
181
+
182
+ console.log({
183
+ from: targetWallet.address,
184
+ gasPrice: BigNumber.from(120 * 10 ** 9).toString(),
185
+ to: safeAddress,
186
+ data: txData,
187
+ })
188
+
189
+
190
+ const txSent = await targetWallet.sendTransaction({
191
+ from: targetWallet.address,
192
+ gasPrice: BigNumber.from(120 * 10 ** 9),
193
+ to: safeAddress,
194
+ data: txData,
195
+ })
196
+
197
+ const receipt = await txSent.wait();
198
+
199
+ const parsedLogs: LogDescription[] = [];
200
+
201
+ receipt.logs.forEach((log) => {
202
+ try {
203
+ parsedLogs.push(safeContract.interface.parseLog(log));
204
+ } catch (e) { }
205
+ });
206
+
207
+ if (parsedLogs.find(e => e.name === 'ExecutionSuccess')) {
208
+ console.log('ExecutionSuccess')
209
+ transaction.targetStatus = 'success'
210
+ transaction.targetTransactionHash = txSent.hash
211
+ transaction.status = 'success'
212
+ await transaction.save();
213
+ } else {
214
+ console.log('ExecutionFailure')
215
+ transaction.targetStatus = 'failed'
216
+ transaction.targetTransactionHash = txSent.hash
217
+ transaction.status = 'failed'
218
+ await transaction.save();
219
+ }
220
+ }
221
+
222
+ async start(): Promise<void> {
223
+ this.provider = new ethers.providers.JsonRpcProvider(
224
+ getRpcProviderUrl(this.chainId)
225
+ );
226
+
227
+ await super.start()
228
+ }
229
+ }
230
+
231
+ export default ProcessWithdrawEvents;
@@ -0,0 +1,119 @@
1
+ import { BaseTask } from "../BaseTask";
2
+ import Logger from '@/logger';
3
+ import { ethers } from "ethers";
4
+ import abi from "@/abi";
5
+ import { Transaction } from "@/db";
6
+ import { generateInteropTransactionHash, getContract, getRpcProviderUrl } from "@/utils";
7
+ import { ChainId } from "@/types";
8
+ import config from "@/config";
9
+ import { InteropBridgeToken } from "@/typechain";
10
+
11
+ class SyncWithdrawEvents extends BaseTask {
12
+ contractAddress: string;
13
+ provider: ethers.providers.JsonRpcProvider;
14
+ contract: InteropBridgeToken;
15
+ chainId: ChainId;
16
+ itokenAddress: string;
17
+
18
+ constructor({ chainId, itokenAddress }: { chainId: ChainId, itokenAddress: string }) {
19
+ super({
20
+ logger: new Logger("InteropBridgeToken::SyncWithdrawEvents"),
21
+ })
22
+ this.chainId = chainId;
23
+ this.itokenAddress = itokenAddress;
24
+ }
25
+
26
+ async pollHandler() {
27
+ const currentBlock = await this.provider.getBlockNumber();
28
+
29
+ const events = await this.contract.queryFilter(
30
+ this.contract.filters.Burn(),
31
+ currentBlock - 2000,
32
+ currentBlock,
33
+ );
34
+
35
+ let processedEvents = 0;
36
+
37
+ for (const event of events) {
38
+
39
+ try {
40
+ if (!event.args) {
41
+ continue;
42
+ }
43
+
44
+ const { to, amount, chainId } = event.args;
45
+
46
+ const uniqueIdentifier = {
47
+ action: 'withdraw',
48
+ submitTransactionHash: event.transactionHash,
49
+ sourceChainId:this.chainId,
50
+ targetChainId: chainId.toNumber(),
51
+ }
52
+
53
+ if (await Transaction.findOne({ where: uniqueIdentifier })) {
54
+ continue;
55
+ }
56
+
57
+ const tx = await event.getTransaction()
58
+
59
+ await Transaction.create({
60
+ ...uniqueIdentifier,
61
+ transactionHash: generateInteropTransactionHash(uniqueIdentifier),
62
+ from: tx.from,
63
+ to,
64
+
65
+
66
+ submitTransactionHash: event.transactionHash,
67
+ submitBlockNumber: event.blockNumber,
68
+
69
+ // submit & source are the same
70
+ sourceTransactionHash: event.transactionHash,
71
+ sourceBlockNumber: event.blockNumber,
72
+ sourceStatus: "success",
73
+
74
+ targetStatus: "uninitialised",
75
+
76
+ submitEvent: {
77
+ to,
78
+ amount: amount.toString(),
79
+ itoken: this.itokenAddress,
80
+ chainId: chainId.toString()
81
+ },
82
+
83
+ sourceEvent: {
84
+ to,
85
+ amount: amount.toString(),
86
+ itoken: this.itokenAddress,
87
+ chainId: chainId.toString(),
88
+ },
89
+ status: "pending",
90
+ })
91
+
92
+ this.logger.info(
93
+ `Withdraw queued: ${event.transactionHash} ${event.blockNumber}`
94
+ );
95
+ } catch (error) {
96
+ this.logger.error(error);
97
+ }
98
+ }
99
+
100
+ if (processedEvents > 0)
101
+ this.logger.info(`${processedEvents} events processed`);
102
+ }
103
+
104
+ async start(): Promise<void> {
105
+ this.provider = new ethers.providers.JsonRpcProvider(
106
+ getRpcProviderUrl(this.chainId)
107
+ );
108
+
109
+ this.contract = getContract<InteropBridgeToken>(
110
+ this.itokenAddress,
111
+ abi.interopBridgeToken,
112
+ new ethers.Wallet(config.privateKey!, this.provider)
113
+ );
114
+
115
+ await super.start()
116
+ }
117
+ }
118
+
119
+ export default SyncWithdrawEvents;