@ercworldio/blockchain-shared 1.0.0-dev.4

package/build/contracts/Escrow.js

@@ -0,0 +1,359 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const Escrow_json_1 = __importDefault(require("./artifacts/Escrow.json"));
+const ERC20Mock_json_1 = __importDefault(require("./artifacts/ERC20Mock.json"));
+const EscrowErrors_1 = require("./EscrowErrors");
+const TransactionsErrors_1 = __importDefault(require("../errors/TransactionsErrors"));
+const escrow_1 = require("./types/escrow");
+/**
+ * Class to interact with the escrow contract
+ * @author @0xgio - Georgio Diab
+ */
+class EscrowInteraction extends TransactionsErrors_1.default {
+    constructor(escrowAddress, provider, signer) {
+        super();
+        this.signer = null;
+        this.provider = null;
+        this.CONFIRMATIONS = 1;
+        this.provider = provider;
+        this.escrowContract = new ethers_1.Contract(escrowAddress, Escrow_json_1.default, provider);
+        if (signer) {
+            this.signer = signer.connect(provider);
+            this.escrowContract = this.escrowContract.connect(this.signer);
+        }
+    }
+    /**
+     * Connect signer wallet to contract for writing operations
+     * @param signer Signer object to connect to the contract
+     */
+    setSigner(signer) {
+        this.signer = signer;
+        this.escrowContract = this.escrowContract.connect(signer);
+    }
+    /** CONTRACT GETTERS */
+    /**
+     * Get the nonce of a user
+     * @param userAddress Address of the user to get the nonce of
+     * @returns Nonce of the user as a number
+     */
+    getNonce_deprecated(userAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.provider) {
+                    throw new Error("Provider not set");
+                }
+                const nonce = yield this.escrowContract.nonces(userAddress);
+                return Number(nonce);
+            }
+            catch (e) {
+                return null;
+            }
+        });
+    }
+    /**
+     * Get the nonce of a user
+     * @param userAddress Address of the user to get the nonce of
+     * @param opType Type of escrow operation (deposit or withdraw)
+     * @returns Nonce of the user as a number
+     */
+    getNonce(userAddress, opType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.provider) {
+                    throw new Error("Provider not set");
+                }
+                const _operationType = escrow_1.OperationType[opType];
+                const nonce = yield this.escrowContract.getNonce(userAddress, _operationType);
+                return Number(nonce);
+            }
+            catch (e) {
+                const errorResult = this.decodeRevertError(e);
+                // return null;
+                throw errorResult;
+            }
+        });
+    }
+    /** CONTRACT WRITERS */
+    fundWallets(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.provider) {
+                    throw new Error("Provider not set");
+                }
+                if (!this.signer) {
+                    throw new Error("Signer not connected to contract.");
+                }
+                const tx = yield this.escrowContract.fundWallets(payload.wallets, payload.amount);
+                const receipt = yield tx.wait();
+                if (!receipt)
+                    throw new Error("Failed to send transaction");
+                return {
+                    status: escrow_1.TransactionStatus.SUCCESS,
+                    transactionHash: tx.hash,
+                    receipt,
+                    fee: receipt.fee
+                };
+            }
+            catch (e) {
+                const errorResult = this.decodeRevertError(e);
+                return {
+                    status: escrow_1.TransactionStatus.FAILED,
+                    transactionHash: null,
+                    receipt: null,
+                    error: Object.assign({}, errorResult)
+                };
+            }
+        });
+    }
+    batchSweepERC20(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.signer) {
+                    throw new Error("Signer not set");
+                }
+                let tx = yield this.escrowContract.batchSweepERC20(payload);
+                let receipt = yield tx.wait(this.CONFIRMATIONS);
+                if (!receipt)
+                    throw new Error(this.UnexpectedError("Failed to retrieve transaction receipt"));
+                return {
+                    status: escrow_1.TransactionStatus.SUCCESS,
+                    transactionHash: tx.hash,
+                    fee: receipt.fee,
+                    receipt,
+                };
+            }
+            catch (e) {
+                const errorResult = this.decodeRevertError(e);
+                return {
+                    status: escrow_1.TransactionStatus.FAILED,
+                    transactionHash: null,
+                    receipt: null,
+                    error: Object.assign({}, errorResult)
+                };
+            }
+        });
+    }
+    get_used_request_ids(ids) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!ids.length)
+                    return [];
+                const used_ids = yield this.escrowContract.get_used_ids(ids);
+                if (used_ids.every(r => r === BigInt(0)))
+                    return [];
+                return used_ids.map(id => Number(id));
+            }
+            catch (e) {
+                const errorResult = this.decodeRevertError(e);
+                throw new Error(errorResult.message);
+            }
+        });
+    }
+    admin_batch_withdraw(payloads, token_price) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let success = [];
+            let failed = [];
+            let dropped = [];
+            let cancel = [];
+            const executed_at = new Date();
+            try {
+                if (!this.signer)
+                    throw new Error("Signer not set");
+                if (!payloads.length)
+                    return {
+                        status: escrow_1.TransactionStatus.FAILED,
+                        transactionHash: null,
+                        receipt: null,
+                        data: {
+                            success,
+                            failed,
+                            dropped,
+                            cancel
+                        }
+                    };
+                let tx = yield this.escrowContract.batch_withdraw(payloads);
+                let receipt = yield tx.wait(this.CONFIRMATIONS);
+                if (!receipt)
+                    throw new Error(this.UnexpectedError("Failed to retrieve transaction receipt"));
+                success = payloads.map(p => p.requestId);
+                const fee_per_transaction = receipt.fee / BigInt(payloads.length);
+                const fee_per_tx_decimals = parseFloat((0, ethers_1.formatEther)(fee_per_transaction));
+                const fee_per_tx_usd_decimals = fee_per_tx_decimals * token_price;
+                const fee_per_tx_usd = (0, ethers_1.parseUnits)(fee_per_tx_decimals.toFixed(5), 6);
+                return {
+                    status: escrow_1.TransactionStatus.SUCCESS,
+                    transactionHash: tx.hash,
+                    fee: receipt.fee,
+                    feePerTx: fee_per_transaction,
+                    feePerTxDecimals: fee_per_tx_decimals,
+                    feePerTxUsd: fee_per_tx_usd,
+                    feePerTxUsdDecimals: fee_per_tx_usd_decimals,
+                    receipt,
+                    executed_at,
+                    data: {
+                        success,
+                        failed,
+                        dropped,
+                        cancel
+                    }
+                };
+            }
+            catch (e) {
+                const errorResult = this.decodeRevertError(e);
+                return {
+                    status: escrow_1.TransactionStatus.FAILED,
+                    transactionHash: null,
+                    receipt: null,
+                    executed_at,
+                    error: Object.assign({}, errorResult),
+                    data: {
+                        success,
+                        failed,
+                        dropped,
+                        cancel
+                    }
+                };
+            }
+        });
+    }
+    /**
+     * Entry point for withdraw, requires signer to be set
+     * @param amount Amount of tokens to withdraw in decimal format. e.g: 1.5 ETH
+     * @param requestId Withdrawal request ID from backend
+     * @param tokenAddress Address of the token to withdraw. e.g: 0x0000000000000000000000000000000000000000 for ether
+     * @param receiverAddress Address of the token receiver wallet
+     * @param signature v,r,s values of the signature
+     * @returns
+     */
+    withdraw(amount, requestId, tokenAddress, receiverAddress, signature) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.signer) {
+                    throw new Error("Signer not set");
+                }
+                let amountInWei;
+                if (tokenAddress === ethers_1.ZeroAddress) {
+                    amountInWei = ethers_1.ethers.parseEther(amount.toString());
+                }
+                else {
+                    // Get the decimals from the token contract
+                    const tokenContract = new ethers_1.Contract(tokenAddress, ERC20Mock_json_1.default, this.provider);
+                    const decimals = yield tokenContract.decimals();
+                    amountInWei = ethers_1.ethers.parseUnits(amount.toString(), decimals);
+                }
+                const tx = yield this.escrowContract.withdraw(amountInWei, requestId, tokenAddress, receiverAddress, signature);
+                const receipt = yield tx.wait(this.CONFIRMATIONS);
+                if (!receipt)
+                    throw new Error(this.UnexpectedError("Failed to retrieve transaction receipt"));
+                return {
+                    status: escrow_1.TransactionStatus.SUCCESS,
+                    fee: receipt.fee,
+                    transactionHash: tx.hash,
+                    receipt
+                };
+            }
+            catch (e) {
+                const errorResult = this.decodeRevertError(e);
+                return {
+                    status: escrow_1.TransactionStatus.FAILED,
+                    transactionHash: null,
+                    receipt: null,
+                    error: Object.assign({}, errorResult)
+                };
+            }
+        });
+    }
+    // Depositing native token (Ether)
+    _depositEther(amountInWei_1) {
+        return __awaiter(this, arguments, void 0, function* (amountInWei, bonusCode = "", signature) {
+            try {
+                if (!this.signer) {
+                    throw new Error("Signer not set");
+                }
+                if (!amountInWei) {
+                    throw new Error("Failed to convert amount to wei");
+                }
+                const tx = yield this.escrowContract.deposit(bonusCode, signature, {
+                    value: ethers_1.ethers.toBigInt(amountInWei)
+                });
+                const receipt = yield tx.wait(this.CONFIRMATIONS);
+                return {
+                    status: escrow_1.TransactionStatus.SUCCESS,
+                    transactionHash: tx.hash,
+                    receipt
+                };
+            }
+            catch (e) {
+                const errorResult = this.decodeRevertError(e);
+                return {
+                    status: escrow_1.TransactionStatus.FAILED,
+                    transactionHash: null,
+                    receipt: null,
+                    error: Object.assign({}, errorResult)
+                };
+            }
+        });
+    }
+    // Depositing ERC20 token
+    _depositERC20(amountInTokenUnits_1, tokenAddress_1) {
+        return __awaiter(this, arguments, void 0, function* (amountInTokenUnits, tokenAddress, bonusCode = "", signature, signer) {
+            try {
+                const EscrowAddress = yield this.escrowContract.getAddress();
+                // Initialize token contract
+                const tokenContract = new ethers_1.Contract(tokenAddress, ERC20Mock_json_1.default, this.signer);
+                // Request approval only if the token is not already approved for spending by escrow contract
+                const allowance = yield tokenContract.allowance(yield signer.getAddress(), EscrowAddress);
+                if (allowance < ethers_1.ethers.toBigInt(amountInTokenUnits)) {
+                    const approveTx = yield tokenContract.approve(EscrowAddress, amountInTokenUnits);
+                    yield approveTx.wait(this.CONFIRMATIONS);
+                }
+                const depositTx = yield this.escrowContract.depositErc20(amountInTokenUnits, tokenAddress, bonusCode, signature);
+                const depositReceipt = yield depositTx.wait(this.CONFIRMATIONS);
+                return {
+                    status: escrow_1.TransactionStatus.SUCCESS,
+                    transactionHash: depositTx.hash,
+                    receipt: depositReceipt,
+                };
+            }
+            catch (e) {
+                const errorResult = this.decodeRevertError(e);
+                return {
+                    status: escrow_1.TransactionStatus.FAILED,
+                    transactionHash: null,
+                    receipt: null,
+                    error: Object.assign({}, errorResult)
+                };
+            }
+        });
+    }
+    decodeRevertError(error) {
+        // Decode error data
+        if (error.data) {
+            const decodedError = this.escrowContract.interface.parseError(error.data);
+            if (decodedError) {
+                // Decoded error
+                let parsedError = (0, EscrowErrors_1.parseDecodedError)(decodedError);
+                return parsedError;
+            }
+        }
+        // Error cannot be decoded
+        return {
+            name: "UnknownError",
+            message: error.message
+        };
+    }
+}
+exports.default = EscrowInteraction;

package/build/contracts/EscrowErrors.d.ts

@@ -0,0 +1,75 @@
+import { ErrorDescription } from "ethers";
+export interface ContractBusyError {
+    name: "ContractBusy";
+    args: [];
+}
+export interface ContractPausedError {
+    name: "ContractPaused";
+    args: [];
+}
+export interface InvalidSignatureError {
+    name: "InvalidSignature";
+    args: [];
+}
+export interface SignatureAlreadyUsedError {
+    name: "SignatureAlreadyUsed";
+    args: [];
+}
+export interface ZeroValueError {
+    name: "ZeroValue";
+    args: [];
+}
+export interface ZeroAddressError {
+    name: "ZeroAddress";
+    args: [];
+}
+export interface RequestAlreadyFulfilledError {
+    name: "RequestAlreadyFulfilled";
+    args: [];
+}
+export interface EtherDirectTransferNotAllowedError {
+    name: "EtherDirectTransferNotAllowed";
+    args: [];
+}
+export interface DepositOnlyERC20Error {
+    name: "DepositOnlyERC20";
+    args: [];
+}
+export interface TokenNotAllowedError {
+    name: "TokenNotAllowed";
+    args: [string];
+}
+export interface InsufficientBalanceError {
+    name: "InsufficientBalance";
+    args: [string, string, number, number];
+}
+export interface InsufficientReservesError {
+    name: "InsufficientReserves";
+    args: [];
+}
+export interface TransferError {
+    name: "TransferError";
+    args: [];
+}
+export interface NotAdminError {
+    name: "NotAdmin";
+    args: [];
+}
+export interface NotAuthorizedError {
+    name: "NotAuthorized";
+    args: [];
+}
+type ErrorName = "NotAuthorized" | "NotAdmin" | "TransferError" | "InsufficientReserves" | "InsufficientBalance" | "TokenNotAllowed" | "DepositOnlyERC20" | "EtherDirectTransferNotAllowed" | "RequestAlreadyFulfilled" | "ZeroAddress" | "ZeroValue" | "SignatureAlreadyUsed" | "InvalidSignature" | "ContractPaused" | "ContractBusy" | "UnknownError";
+export interface EscrowErrorMessage {
+    name: ErrorName;
+    message: string;
+    data?: any;
+}
+export interface ErrorObject {
+    [key: string]: string;
+    message: string;
+    data: string;
+}
+export declare const parseDecodedError: (decodedError: ErrorDescription) => EscrowErrorMessage;
+export {};
+//# sourceMappingURL=EscrowErrors.d.ts.map

package/build/contracts/EscrowErrors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EscrowErrors.d.ts","sourceRoot":"","sources":["../../src/contracts/EscrowErrors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAC;AAE1C,MAAM,WAAW,iBAAiB;IAC9B,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,EAAE,EAAE,CAAC;CACZ;AAED,MAAM,WAAW,mBAAmB;IAChC,IAAI,EAAE,gBAAgB,CAAC;IACvB,IAAI,EAAE,EAAE,CAAC;CACZ;AAED,MAAM,WAAW,qBAAqB;IAClC,IAAI,EAAE,kBAAkB,CAAC;IACzB,IAAI,EAAE,EAAE,CAAC;CACZ;AAED,MAAM,WAAW,yBAAyB;IACtC,IAAI,EAAE,sBAAsB,CAAC;IAC7B,IAAI,EAAE,EAAE,CAAC;CACZ;AAED,MAAM,WAAW,cAAc;IAC3B,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,EAAE,CAAC;CACZ;AAED,MAAM,WAAW,gBAAgB;IAC7B,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,EAAE,EAAE,CAAC;CACZ;AAED,MAAM,WAAW,4BAA4B;IACzC,IAAI,EAAE,yBAAyB,CAAC;IAChC,IAAI,EAAE,EAAE,CAAC;CACZ;AAED,MAAM,WAAW,kCAAkC;IAC/C,IAAI,EAAE,+BAA+B,CAAC;IACtC,IAAI,EAAE,EAAE,CAAC;CACZ;AAED,MAAM,WAAW,qBAAqB;IAClC,IAAI,EAAE,kBAAkB,CAAC;IACzB,IAAI,EAAE,EAAE,CAAC;CACZ;AAED,MAAM,WAAW,oBAAoB;IACjC,IAAI,EAAE,iBAAiB,CAAC;IACxB,IAAI,EAAE,CAAC,MAAM,CAAC,CAAC;CAClB;AAED,MAAM,WAAW,wBAAwB;IACrC,IAAI,EAAE,qBAAqB,CAAC;IAC5B,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1C;AAED,MAAM,WAAW,yBAAyB;IACtC,IAAI,EAAE,sBAAsB,CAAC;IAC7B,IAAI,EAAE,EAAE,CAAC;CACZ;AAED,MAAM,WAAW,aAAa;IAC1B,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,EAAE,CAAC;CACZ;AAED,MAAM,WAAW,aAAa;IAC1B,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,EAAE,CAAC;CACZ;AAED,MAAM,WAAW,kBAAkB;IAC/B,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,EAAE,CAAC;CACZ;AAID,KAAK,SAAS,GACR,eAAe,GACf,UAAU,GACV,eAAe,GACf,sBAAsB,GACtB,qBAAqB,GACrB,iBAAiB,GACjB,kBAAkB,GAClB,+BAA+B,GAC/B,yBAAyB,GACzB,aAAa,GACb,WAAW,GACX,sBAAsB,GACtB,kBAAkB,GAClB,gBAAgB,GAChB,cAAc,GACd,cAAc,CAAC;AAErB,MAAM,WAAW,kBAAkB;IAC/B,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,GAAG,CAAC;CACd;AAED,MAAM,WAAW,WAAW;IACxB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,iBAAiB,GAAI,cAAc,gBAAgB,KAAG,kBA2ClE,CAAC"}

package/build/contracts/EscrowErrors.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDecodedError = void 0;
+const parseDecodedError = (decodedError) => {
+    switch (decodedError.name) {
+        case "ContractPaused":
+            return { name: decodedError.name, message: `Contract is currently paused by the administrators.` };
+        case "ContractBusy":
+            return { name: decodedError.name, message: `Contract is busy with another tranasction.` };
+        case "ContractBusy":
+            return { name: decodedError.name, message: `Contract is busy with another tranasction.` };
+        case "DepositOnlyERC20":
+            return { name: decodedError.name, message: `Only ERC20 tokend deposits are allowed.` };
+        case "EtherDirectTransferNotAllowed":
+            return {
+                name: decodedError.name,
+                message: `Direct transfer of native token to the contract is not allowed. Please use the deposit methods instead.`
+            };
+        case "InvalidSignature":
+            return { name: decodedError.name, message: `Transaction signature does not match.` };
+        case "InsufficientReserves":
+            return { name: decodedError.name, message: `Contract token balance is low.` };
+        // case "InsufficientBalance":
+        //     const [holder, token, available, requested] = decodedError.args;
+        //     return { name: decodedError.name, message: `Balance of ${holder} of token: ${token} is low. Requested ${requested}, but has ${available}. ` }
+        case "NotAuthorized":
+            return { name: decodedError.name, message: `User is not authorized for this action.` };
+        case "NotAdmin":
+            return { name: decodedError.name, message: `Admin role required for this action.` };
+        case "RequestAlreadyFulfilled":
+            return { name: decodedError.name, message: `Withdraw request already fulfilled. No tokens for withdrawal.`, data: { requestId: Number(decodedError.args[0]) } };
+        case "TransferError":
+            return { name: decodedError.name, message: `Token transfer failed.` };
+        case "SignatureAlreadyUsed":
+            return { name: decodedError.name, message: `Transaction cannot be repeated.` };
+        case "TokenNotAllowed":
+            const [tokenAddress] = decodedError.args;
+            return { name: decodedError.name, message: `Transfer of token ${tokenAddress} is not allowed.` };
+        case "ZeroAddress":
+            return { name: decodedError.name, message: `Transfer to the Ethereum Zero Address is not allowed.` };
+        case "ZeroValue":
+            return { name: decodedError.name, message: `Token amount cannot be zero.` };
+        default:
+            return { name: "UnknownError", message: "Unexpected error occured." };
+    }
+};
+exports.parseDecodedError = parseDecodedError;