@instadapp/interop-x 0.0.0-dev.73e5298 → 0.0.0-dev.7738003

package/src/api/index.ts

@@ -21,7 +21,7 @@ export const startApiServer = async () => {
                 limit: 20,
                 offset: 0,
                 order: [
-                    ['createdAt', 'DESC']
+                    ['updatedAt', 'DESC']
                 ]
             })
         })

package/src/constants/addresses.ts

@@ -1,17 +1,12 @@
 export const addresses = {
-  // 1: {
-  //   gnosisSafe: '0x811Bff6eF88dAAA0aD6438386B534A81cE3F160F',
-  //   multisend: '0xA238CBeb142c10Ef7Ad8442C6D1f9E89e07e7761',
-  //   interopXContract: '',
-  // },
   137: {
     gnosisSafe: '0x5635d2910e51da33d9DC0422c893CF4F28B69A25',
     multisend: '0xA238CBeb142c10Ef7Ad8442C6D1f9E89e07e7761',
-    interopXContract: '0x65AcB77B5191CED1B1ae85B454D20E2d128fAfEe',
+    interopX: '0xDB6083df37C5F224a3dF84A4B5f9fB60b6c8670a',
   },
   43114: {
     gnosisSafe: '0x31d7a5194Fe60AC209Cf1Ce2d539C9A60662Ed6b',
     multisend: '0x998739BFdAAdde7C933B942a68053933098f9EDa',
-    interopXContract: '0xd61f55C6d9deD35B9d13243b816c4BcC1d78592b',
+    interopX: '0xd61f55C6d9deD35B9d13243b816c4BcC1d78592b',
   }
-} as Record<number, { gnosisSafe: string, multisend: string, interopXContract: string }>
+} as Record<number, { gnosisSafe: string, multisend: string, interopX: string }>

package/src/db/models/transaction.ts

@@ -1,7 +1,7 @@
 import { sequelize } from '@/db/sequelize'
 import { CreationOptional, InferAttributes, InferCreationAttributes, Model, DataTypes } from 'sequelize';
 
-export interface IPositionTokenInfo{
+export interface IPositionTokenInfo {
     amount: string;
     sourceToken: string;
     targetToken: string;
@@ -16,14 +16,17 @@ export class Transaction extends Model<InferAttributes<Transaction>, InferCreati
     declare id: CreationOptional<number>;
 
     declare transactionHash: string;
-    
+    declare vnonce: string;
     declare actionId: string;
-    declare bridger: string;
-    declare requestTransactionHash: string;
+    declare sourceSender: string;
 
-    declare requestBlockNumber: number;
+    declare submitChainId: number;
+    declare submitTransactionHash: string;
+    declare submitBlockNumber: number;
+    declare submitCreatedAt: Date;
 
     declare sourceChainId: number;
+    declare sourceDsaId: string;
     declare sourceTransactionHash: CreationOptional<string>;
     declare sourceBlockNumber: CreationOptional<number>;
     declare sourceStatus: CreationOptional<string>;
@@ -33,6 +36,7 @@ export class Transaction extends Model<InferAttributes<Transaction>, InferCreati
     declare sourceDelayUntil: CreationOptional<Date>;
 
     declare targetChainId: number;
+    declare targetDsaId: string;
     declare targetTransactionHash: CreationOptional<string>;
     declare targetBlockNumber: CreationOptional<number>;
     declare targetStatus: CreationOptional<string>;
@@ -41,33 +45,18 @@ export class Transaction extends Model<InferAttributes<Transaction>, InferCreati
     declare targetCreatedAt: CreationOptional<Date>;
     declare targetDelayUntil: CreationOptional<Date>;
 
-    declare requestEvent: {
-        actionId: string;
-        bridger: string;
-        metadata: string;
+    declare submitEvent: {
         position: IPosition;
-        sourceChainId: number;
-        targetChainId: number;
-    };
-    declare requestSentEvent: CreationOptional<{
         actionId: string;
-        bridger: string;
-        metadata: string;
-        position: IPosition;
+        actionIdHashHash: string;
+        sourceSender: string;
+        sourceDsaId: string;
+        targetDsaId: string;
         sourceChainId: number;
         targetChainId: number;
-        requestTransactionHash: string;
-    }>;
-    declare committedEvent: CreationOptional<{
-        actionId: string;
-        bridger: string;
+        vnonce: string;
         metadata: string;
-        position: IPosition;
-        sourceChainId: number;
-        targetChainId: number;
-        requestTransactionHash: string;
-    }>;
-    declare completedEvent: CreationOptional<any>;
+    };
 
     declare status: CreationOptional<string>;
 
@@ -82,19 +71,23 @@ Transaction.init({
         primaryKey: true
     },
 
-    requestTransactionHash: DataTypes.NUMBER,
-    requestBlockNumber: DataTypes.NUMBER,
-
     transactionHash: DataTypes.STRING,
     actionId: DataTypes.STRING,
-    bridger: DataTypes.STRING,
+    vnonce: DataTypes.STRING,
+    sourceSender: DataTypes.STRING,
+
+    submitChainId: DataTypes.NUMBER,
+    submitTransactionHash: DataTypes.STRING,
+    submitBlockNumber: DataTypes.NUMBER,
+    submitCreatedAt: DataTypes.DATE,
 
     sourceChainId: DataTypes.NUMBER,
+    sourceDsaId: DataTypes.STRING,
     sourceTransactionHash: DataTypes.STRING,
     sourceBlockNumber: DataTypes.NUMBER,
     sourceStatus: {
         type: DataTypes.STRING,
-        defaultValue: 'uninitialised'
+        defaultValue: 'pending'
     },
     sourceErrors: {
         type: DataTypes.JSON,
@@ -111,11 +104,12 @@ Transaction.init({
     sourceDelayUntil: DataTypes.STRING,
 
     targetChainId: DataTypes.NUMBER,
+    targetDsaId: DataTypes.STRING,
     targetTransactionHash: DataTypes.STRING,
     targetBlockNumber: DataTypes.NUMBER,
     targetStatus: {
         type: DataTypes.STRING,
-        defaultValue: 'uninitialised'
+        defaultValue: 'pending'
     },
     targetErrors: {
         type: DataTypes.JSON,
@@ -128,13 +122,10 @@ Transaction.init({
     targetCreatedAt: DataTypes.DATE,
     targetDelayUntil: DataTypes.DATE,
 
-    requestEvent: {
+    submitEvent: {
         type: DataTypes.JSON,
         allowNull: false
     },
-    requestSentEvent: DataTypes.JSON,
-    committedEvent: DataTypes.JSON,
-    completedEvent: DataTypes.JSON,
 
     status: {
         type: DataTypes.STRING,

package/src/gnosis/actions/withdraw/index.ts

@@ -2,154 +2,154 @@ import abi from "@/abi";
 import config from "@/config";
 import { addresses, tokens } from "@/constants";
 import { Transaction } from "@/db";
-import { Erc20, InteropXContract } from "@/typechain";
+import { Erc20, InteropX } from "@/typechain";
 import { ChainId } from "@/types";
 import { getContract, getRpcProviderUrl, LiquidityError } from "@/utils";
 import { BigNumber, ethers } from "ethers";
 import { MetaTransaction, OperationType } from "ethers-multisend";
 
 
-const getBridgeAmounts = async (user: string, tokens: string[], chainId: ChainId) => {
-    const sourceChainProvider = new ethers.providers.JsonRpcProvider(getRpcProviderUrl(chainId));
-    const sourceWallet = new ethers.Wallet(config.privateKey, sourceChainProvider);
-    const contractAddress = addresses[chainId].interopXContract;
-    const contract = getContract<InteropXContract>(contractAddress, abi.interopXContract, sourceWallet);
-    const data = await contract.getBridgeAmounts(user, tokens);
+// const getBridgeAmounts = async (user: string, tokens: string[], chainId: ChainId) => {
+//     const sourceChainProvider = new ethers.providers.JsonRpcProvider(getRpcProviderUrl(chainId));
+//     const sourceWallet = new ethers.Wallet(config.privateKey, sourceChainProvider);
+//     const contractAddress = addresses[chainId].interopX;
+//     const contract = getContract<InteropX>(contractAddress, abi.interopX, sourceWallet);
+//     const data = await contract.getBridgeAmounts(user, tokens);
 
 
-    return data.map((item, index) => ({
-        token: tokens[index],
-        deposit: item.deposit,
-        withdraw: item.withdraw,
-    }))
-}
+//     return data.map((item, index) => ({
+//         token: tokens[index],
+//         deposit: item.deposit,
+//         withdraw: item.withdraw,
+//     }))
+// }
 
 export default async function (transaction: Transaction, type: 'source' | 'target') {
     const transactions: MetaTransaction[] = [];
     const logs: any[] = [];
 
-    if (transaction.actionId !== 'withdraw') {
-        throw new Error(`Invalid action: ${transaction.actionId}`)
-    }
+    // if (transaction.actionId !== 'withdraw') {
+    //     throw new Error(`Invalid action: ${transaction.actionId}`)
+    // }
 
-    if (type !== 'source') {
-        throw new Error(`[WIP] Type not supported: ${type}`)
-    }
+    // if (type !== 'source') {
+    //     throw new Error(`[WIP] Type not supported: ${type}`)
+    // }
 
-    if (transaction.sourceStatus === 'pending') {
-        throw Error('Source transaction already processesing')
-    }
+    // if (transaction.sourceStatus === 'pending') {
+    //     throw Error('Source transaction already processesing')
+    // }
 
-    if (transaction.sourceStatus === 'pending') {
-        throw Error('Source transaction already processed')
-    }
+    // if (transaction.sourceStatus === 'pending') {
+    //     throw Error('Source transaction already processed')
+    // }
 
-    if (!transaction.requestEvent) {
-        throw Error('Something went wrong, source transaction has no request event')
-    }
-
-    const { actionId, bridger, position, sourceChainId, targetChainId, metadata } = transaction.requestEvent;
-
-    const sourceChainProvider = new ethers.providers.JsonRpcProvider(getRpcProviderUrl(sourceChainId as ChainId));
-    const sourceWallet = new ethers.Wallet(config.privateKey, sourceChainProvider);
-    const contractAddress = addresses[sourceChainId].interopXContract;
-    const contract = getContract<InteropXContract>(contractAddress, abi.interopXContract, sourceWallet);
-
-    const sourceToken = tokens[sourceChainId].find(t => t.address.toLowerCase() === position.withdraw[0].sourceToken.toLowerCase());
-
-    if (!sourceToken) {
-        throw Error('Source token not found')
-    }
-
-    const targetToken = tokens[targetChainId].find(t => t.address.toLowerCase() === position.withdraw[0].targetToken.toLowerCase());
-
-    if (!targetToken) {
-        throw Error('Target token not found')
-    }
-
-    if (!sourceToken.aliases.some(alias => targetToken.aliases.includes(alias))) {
-        throw Error('Source and target token must be the same')
-    }
-
-    const networks: ChainId[] = [137, 43114];
-    const networkUserData = {}
-    for (const network of networks) {
-        networkUserData[network] = await getBridgeAmounts(bridger, tokens[network].map(t => t.address), network)
-    }
-
-    for (const tokenSymbol of ["dai", "usdc", "usdt", "eth", "wbtc"]) {
-        let totalDeposit = BigNumber.from(0)
-        let totalWithdraw = BigNumber.from(0)
-
-        for (const network of networks) {
-            // on avax might we have 2 usdc/usdt tokens
-            const matchedTokens = tokens[network].filter(t => t.aliases.includes(tokenSymbol));
-
-            for (const matchedToken of matchedTokens) {
-                const data = networkUserData[network].find(t => t.token.toLowerCase() === matchedToken.address.toLowerCase());
-
-                if (data) {
-                    totalDeposit = totalDeposit.add(data.deposit)
-                    totalWithdraw = totalWithdraw.add(data.withdraw)
-                }
-            }
-
-            //  on Mainent add weth too
-            if (tokenSymbol === "eth" && network === 1) {
-                const weth = tokens[1].find(t => t.symbol === 'WETH');
-
-                if (weth) {
-                    const data = networkUserData[1].find(t => t.token.toLowerCase() === weth.address.toLowerCase());
-
-                    if (data) {
-                        totalDeposit = totalDeposit.add(data.deposit)
-                        totalWithdraw = totalWithdraw.add(data.withdraw)
-                    }
-                }
-            }
-        }
-
-        if (totalWithdraw.gt(totalDeposit)) {
-            throw Error(`if withdraw > deposit, user has debt and we can't process the withdraw and reject it`)
-        }
-
-        if (totalWithdraw.lt(totalDeposit)) {
-            throw Error('Something went wrong')
-        }
-    }
-
-    let balance = BigNumber.from(0);
-
-    if (position.withdraw[0].sourceToken.toLowerCase() === '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE'.toLowerCase()) {
-        balance = await sourceChainProvider.getBalance(bridger);
-
-    } else {
-        const erc20 = getContract<Erc20>(position.withdraw[0].sourceToken, abi.erc20, sourceChainProvider);
-        balance = await erc20.balanceOf(addresses[sourceChainId].gnosisSafe);
-    }
-
-    if (balance.lt(position.withdraw[0].amount)) {
-        throw new LiquidityError()
-    }
-
-
-    const { data } = await contract.populateTransaction.withdrawRequested(
-        actionId,
-        bridger,
-        position.withdraw[0].sourceToken,
-        position.withdraw[0].targetToken,
-        position.withdraw[0].amount,
-        targetChainId,
-        transaction.requestTransactionHash,
-        metadata,
-    );
-
-    transactions.push({
-        to: contractAddress,
-        data: data!,
-        value: '0',
-        operation: OperationType.Call,
-    });
+    // if (!transaction.requestEvent) {
+    //     throw Error('Something went wrong, source transaction has no request event')
+    // }
+
+    // const { actionId, bridger, position, sourceChainId, targetChainId, metadata } = transaction.requestEvent;
+
+    // const sourceChainProvider = new ethers.providers.JsonRpcProvider(getRpcProviderUrl(sourceChainId as ChainId));
+    // const sourceWallet = new ethers.Wallet(config.privateKey, sourceChainProvider);
+    // const contractAddress = addresses[sourceChainId].interopX;
+    // const contract = getContract<InteropX>(contractAddress, abi.interopX, sourceWallet);
+
+    // const sourceToken = tokens[sourceChainId].find(t => t.address.toLowerCase() === position.withdraw[0].sourceToken.toLowerCase());
+
+    // if (!sourceToken) {
+    //     throw Error('Source token not found')
+    // }
+
+    // const targetToken = tokens[targetChainId].find(t => t.address.toLowerCase() === position.withdraw[0].targetToken.toLowerCase());
+
+    // if (!targetToken) {
+    //     throw Error('Target token not found')
+    // }
+
+    // if (!sourceToken.aliases.some(alias => targetToken.aliases.includes(alias))) {
+    //     throw Error('Source and target token must be the same')
+    // }
+
+    // const networks: ChainId[] = [137, 43114];
+    // const networkUserData = {}
+    // for (const network of networks) {
+    //     networkUserData[network] = await getBridgeAmounts(bridger, tokens[network].map(t => t.address), network)
+    // }
+
+    // for (const tokenSymbol of ["dai", "usdc", "usdt", "eth", "wbtc"]) {
+    //     let totalDeposit = BigNumber.from(0)
+    //     let totalWithdraw = BigNumber.from(0)
+
+    //     for (const network of networks) {
+    //         // on avax might we have 2 usdc/usdt tokens
+    //         const matchedTokens = tokens[network].filter(t => t.aliases.includes(tokenSymbol));
+
+    //         for (const matchedToken of matchedTokens) {
+    //             const data = networkUserData[network].find(t => t.token.toLowerCase() === matchedToken.address.toLowerCase());
+
+    //             if (data) {
+    //                 totalDeposit = totalDeposit.add(data.deposit)
+    //                 totalWithdraw = totalWithdraw.add(data.withdraw)
+    //             }
+    //         }
+
+    //         //  on Mainent add weth too
+    //         if (tokenSymbol === "eth" && network === 1) {
+    //             const weth = tokens[1].find(t => t.symbol === 'WETH');
+
+    //             if (weth) {
+    //                 const data = networkUserData[1].find(t => t.token.toLowerCase() === weth.address.toLowerCase());
+
+    //                 if (data) {
+    //                     totalDeposit = totalDeposit.add(data.deposit)
+    //                     totalWithdraw = totalWithdraw.add(data.withdraw)
+    //                 }
+    //             }
+    //         }
+    //     }
+
+    //     if (totalWithdraw.gt(totalDeposit)) {
+    //         throw Error(`if withdraw > deposit, user has debt and we can't process the withdraw and reject it`)
+    //     }
+
+    //     if (totalWithdraw.lt(totalDeposit)) {
+    //         throw Error('Something went wrong')
+    //     }
+    // }
+
+    // let balance = BigNumber.from(0);
+
+    // if (position.withdraw[0].sourceToken.toLowerCase() === '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE'.toLowerCase()) {
+    //     balance = await sourceChainProvider.getBalance(bridger);
+
+    // } else {
+    //     const erc20 = getContract<Erc20>(position.withdraw[0].sourceToken, abi.erc20, sourceChainProvider);
+    //     balance = await erc20.balanceOf(addresses[sourceChainId].gnosisSafe);
+    // }
+
+    // if (balance.lt(position.withdraw[0].amount)) {
+    //     throw new LiquidityError()
+    // }
+
+
+    // const { data } = await contract.populateTransaction.withdrawRequested(
+    //     actionId,
+    //     bridger,
+    //     position.withdraw[0].sourceToken,
+    //     position.withdraw[0].targetToken,
+    //     position.withdraw[0].amount,
+    //     targetChainId,
+    //     transaction.requestTransactionHash,
+    //     metadata,
+    // );
+
+    // transactions.push({
+    //     to: contractAddress,
+    //     data: data!,
+    //     value: '0',
+    //     operation: OperationType.Call,
+    // });
 
     return { transactions, logs }
 }

package/src/tasks/{InteropXContract/SyncBridgeRequestEvents.ts → InteropX/SyncLogSubmitEvents.ts}

@@ -7,17 +7,17 @@ import { generateInteropTransactionHash, getContract, getRpcProviderUrl } from "
 import { addresses } from "@/constants";
 import { ChainId } from "@/types";
 import config from "@/config";
-import { InteropXContract } from "@/typechain";
+import { InteropX } from "@/typechain";
 
-class SyncBridgeRequestEvents extends BaseTask {
+class SyncLogSubmitEvents extends BaseTask {
     contractAddress: string;
     provider: ethers.providers.JsonRpcProvider;
-    contract: InteropXContract;
+    contract: InteropX;
     chainId: ChainId;
 
     constructor({ chainId }: { chainId: ChainId }) {
         super({
-            logger: new Logger("InteropXContract::SyncBridgeRequestEvents"),
+            logger: new Logger("InteropX::SyncLogSubmitEvents"),
         })
         this.chainId = chainId;
     }
@@ -26,7 +26,7 @@ class SyncBridgeRequestEvents extends BaseTask {
         const currentBlock = await this.provider.getBlockNumber();
 
         const events = await this.contract.queryFilter(
-            this.contract.filters.LogBridgeRequest(),
+            this.contract.filters.LogSubmit(),
             currentBlock - 2000,
             currentBlock,
         );
@@ -40,14 +40,28 @@ class SyncBridgeRequestEvents extends BaseTask {
                     continue;
                 }
 
-                const { actionId, bridger, position, sourceChainId, targetChainId, metadata } = event.args;
+                const {
+                    position,
+                    actionId,
+                    actionIdHashHash,
+                    sourceSender,
+                    sourceDsaId,
+                    targetDsaId,
+                    sourceChainId,
+                    targetChainId,
+                    vnonce,
+                    metadata,
+
+                } = event.args;
 
                 const uniqueIdentifier = {
                     actionId,
-                    bridger,
-                    requestTransactionHash: event.transactionHash,
+                    vnonce: vnonce.toString(),
+                    sourceSender: sourceSender.toString(),
                     sourceChainId: sourceChainId.toNumber(),
                     targetChainId: targetChainId.toNumber(),
+                    sourceDsaId: sourceDsaId.toString(),
+                    targetDsaId: targetDsaId.toString(),
                 }
 
                 let transactionHash = generateInteropTransactionHash(uniqueIdentifier);
@@ -61,10 +75,14 @@ class SyncBridgeRequestEvents extends BaseTask {
                 await Transaction.create({
                     transactionHash,
                     ...uniqueIdentifier,
-                    requestBlockNumber: event.blockNumber,
-                    requestEvent: {
+                    submitChainId: this.chainId,
+                    submitTransactionHash: event.transactionHash,
+                    submitBlockNumber: event.blockNumber,
+                    submitCreatedAt: new Date(),
+                    submitEvent: {
                         actionId,
-                        bridger,
+                        actionIdHashHash,
+                        vnonce: vnonce.toString(),
                         position: {
                             withdraw: position.withdraw.map((v) => ({
                                 sourceToken: v.sourceToken,
@@ -79,12 +97,15 @@ class SyncBridgeRequestEvents extends BaseTask {
                         },
                         sourceChainId: sourceChainId.toNumber(),
                         targetChainId: targetChainId.toNumber(),
+                        sourceSender,
+                        sourceDsaId: sourceDsaId.toString(),
+                        targetDsaId: targetDsaId.toString(),
                         metadata,
                     }
                 })
 
                 this.logger.info(
-                    `New bridge request received: ${transactionHash} `
+                    `New InteropX tranaction: ${transactionHash} `
                 );
             } catch (error) {
                 this.logger.error(error);
@@ -96,15 +117,15 @@ class SyncBridgeRequestEvents extends BaseTask {
     }
 
     async start(): Promise<void> {
-        this.contractAddress = addresses[this.chainId].interopXContract;
+        this.contractAddress = addresses[this.chainId].interopX;
 
         this.provider = new ethers.providers.JsonRpcProvider(
             getRpcProviderUrl(this.chainId)
         );
 
-        this.contract = getContract<InteropXContract>(
+        this.contract = getContract<InteropX>(
             this.contractAddress,
-            abi.interopXContract,
+            abi.interopX,
             new ethers.Wallet(config.privateKey!, this.provider)
         );
 
@@ -112,4 +133,4 @@ class SyncBridgeRequestEvents extends BaseTask {
     }
 }
 
-export default SyncBridgeRequestEvents;
+export default SyncLogSubmitEvents;

package/src/tasks/Transactions/SyncTransactionStatusTask.ts

@@ -25,11 +25,11 @@ class SyncTransactionStatusTask extends BaseTask {
 
         const transaction = await Transaction.findOne({
             where: {
-                status: {
-                    [Op.ne] : 'success'
+                sourceStatus: {
+                    [Op.notIn] : ['success', 'failed'],
                 },
                 sourceCreatedAt: {
-                    [Op.gte]: new Date(Date.now() - 60 * 60 * 1000),
+                    [Op.gte]: new Date(Date.now() - 15 * 60 * 1000),
                 },
             }
         })

package/src/tasks/index.ts

@@ -5,10 +5,8 @@ import SyncTransactionStatusTask from "./Transactions/SyncTransactionStatusTask"
 
 import AutoUpdateTask from "./AutoUpdateTask";
 
-import SyncBridgeRequestEvents from "./InteropXContract/SyncBridgeRequestEvents";
-import ProccessBridgeRequestEvents from "./InteropXContract/ProcessBridgeRequestEvents";
-import SyncBridgeRequestSentEvents from "./InteropXContract/SyncBridgeRequestSentEvents";
-import SyncBridgeCommittedEvents from "./InteropXContract/SyncBridgeCommittedEvents";
+import SyncBridgeRequestEvents from "./InteropX/SyncLogSubmitEvents";
+import SyncLogSubmitEvents from "./InteropX/SyncLogSubmitEvents";
 
 export class Tasks {
 
@@ -16,19 +14,9 @@ export class Tasks {
         // new SyncTransactionStatusTask(),
         new AutoUpdateTask(),
 
-        // InteropXContract
-
-        new SyncBridgeRequestEvents({ chainId: 137 }),
-        new SyncBridgeRequestEvents({ chainId: 43114 }),
-
-        new SyncBridgeRequestSentEvents({ chainId: 137 }),
-        new SyncBridgeRequestSentEvents({ chainId: 43114 }),
-
-        new SyncBridgeCommittedEvents({ chainId: 137 }),
-        new SyncBridgeCommittedEvents({ chainId: 43114 }),
-
-        new ProccessBridgeRequestEvents({ chainId: 137 }),
-        new ProccessBridgeRequestEvents({ chainId: 43114 }),
+        // InteropX
+        new SyncLogSubmitEvents({ chainId: 137 }),
+        new SyncLogSubmitEvents({ chainId: 43114 }),
     ];
 
     async start() {