@instadapp/interop-x 0.0.0-dev.ef78459 → 0.0.0-dev.f0a6281

package/dist/utils/index.js

@@ -1,89 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.asyncCallWithTimeout = exports.buildSignatureBytes = exports.getRpcProviderUrl = exports.signGnosisSafeTx = exports.short = exports.http = void 0;
-/**
- * @module util
- */
-const axios_1 = __importDefault(require("axios"));
-const axios_retry_1 = __importDefault(require("axios-retry"));
-const constants_1 = require("@/constants");
-exports.http = axios_1.default.create();
-(0, axios_retry_1.default)(exports.http, { retries: 3, retryDelay: axios_retry_1.default.exponentialDelay });
-function short(buffer) {
-    return buffer.toString('hex').slice(0, 8) + '...';
-}
-exports.short = short;
-const signGnosisSafeTx = async ({ to, data = null, value = '0', operation = '1', baseGas = '0', gasPrice = "0", gasToken = "0x0000000000000000000000000000000000000000", refundReceiver = "0x0000000000000000000000000000000000000000", safeTxGas = "79668", nonce = "0", chainId = 137, }, { signer }) => {
-    const gnosisSafe = constants_1.addresses[chainId].gnosisSafe;
-    const domain = {
-        verifyingContract: gnosisSafe,
-        chainId,
-    };
-    const types = {
-        SafeTx: [
-            { type: 'address', name: 'to' },
-            { type: 'uint256', name: 'value' },
-            { type: 'bytes', name: 'data' },
-            { type: 'uint8', name: 'operation' },
-            { type: 'uint256', name: 'safeTxGas' },
-            { type: 'uint256', name: 'baseGas' },
-            { type: 'uint256', name: 'gasPrice' },
-            { type: 'address', name: 'gasToken' },
-            { type: 'address', name: 'refundReceiver' },
-            { type: 'uint256', name: 'nonce' },
-        ],
-    };
-    const message = {
-        baseGas,
-        data,
-        gasPrice,
-        gasToken,
-        nonce: Number(nonce),
-        operation,
-        refundReceiver,
-        safeAddress: gnosisSafe,
-        safeTxGas: String(safeTxGas),
-        to,
-        value,
-    };
-    return await signer._signTypedData(domain, types, message);
-};
-exports.signGnosisSafeTx = signGnosisSafeTx;
-const getRpcProviderUrl = (chainId) => {
-    switch (chainId) {
-        case 1:
-            return 'https://rpc.instadapp.io/mainnet';
-        case 137:
-            return 'https://rpc.instadapp.io/polygon';
-        default:
-            throw new Error(`Unknown chainId: ${chainId}`);
-    }
-};
-exports.getRpcProviderUrl = getRpcProviderUrl;
-const buildSignatureBytes = (signatures) => {
-    signatures.sort((left, right) => left.signer.toLowerCase().localeCompare(right.signer.toLowerCase()));
-    let signatureBytes = "0x";
-    for (const sig of signatures) {
-        signatureBytes += sig.data.slice(2);
-    }
-    return signatureBytes;
-};
-exports.buildSignatureBytes = buildSignatureBytes;
-/**
- * Call an async function with a maximum time limit (in milliseconds) for the timeout
- *  Resolved promise for async function call, or an error if time limit reached
- */
-const asyncCallWithTimeout = async (asyncPromise, timeout) => {
-    let timeoutHandle;
-    const timeoutPromise = new Promise((_resolve, reject) => {
-        timeoutHandle = setTimeout(() => reject(new Error('Async call timeout limit reached')), timeout);
-    });
-    return Promise.race([asyncPromise, timeoutPromise]).then(result => {
-        clearTimeout(timeoutHandle);
-        return result;
-    });
-};
-exports.asyncCallWithTimeout = asyncCallWithTimeout;

package/src/db/models/execution.ts

@@ -1,57 +0,0 @@
-import { sequelize } from '@/db/sequelize'
-import { CreationOptional, InferAttributes, InferCreationAttributes, Model, DataTypes } from 'sequelize';
-
-export class Execution extends Model<InferAttributes<Execution>, InferCreationAttributes<Execution>> {
-    declare id: CreationOptional<number>;
-
-    declare transactionHash: string;
-    declare from: string;
-    declare executions: any[];
-    declare chainId: number;
-    declare gas: string;
-    declare maxGasPrice: string;
-    declare assets: any[];
-    declare metadata: string;
-    declare vnonce: string;
-    declare txHash: string;
-
-    declare blockNumber: string;
-    declare status: CreationOptional<string>;
-    declare delayUntil: CreationOptional<Date>;
-    declare delayedCount: CreationOptional<number>;
-
-    declare error: CreationOptional<string>;
-    declare createdAt: CreationOptional<Date>;
-    declare updatedAt: CreationOptional<Date>;
-}
-
-Execution.init({
-    id: {
-        type: DataTypes.INTEGER,
-        autoIncrement: true,
-        primaryKey: true
-    },
-    transactionHash: DataTypes.STRING,
-    from: DataTypes.STRING,
-    executions: DataTypes.JSON,
-    chainId: DataTypes.NUMBER,
-    gas: DataTypes.STRING,
-    maxGasPrice: DataTypes.STRING,
-    assets: DataTypes.JSON,
-    metadata: DataTypes.STRING,
-    vnonce: DataTypes.STRING,
-    txHash: DataTypes.STRING,
-    blockNumber: DataTypes.STRING,
-    status: {
-        type: DataTypes.STRING,
-        defaultValue: 'pending'
-    },
-    delayUntil: DataTypes.DATE,
-    delayedCount: {
-        type: DataTypes.INTEGER,
-        defaultValue: 0
-    },
-    error: DataTypes.STRING,
-    createdAt: DataTypes.DATE,
-    updatedAt: DataTypes.DATE,
-}, { sequelize, tableName: 'executions' });