@pioneer-platform/walletguard 0.2.0 → 0.3.0

package/.turbo/turbo-build.log

@@ -0,0 +1,2 @@
+
+$ tsc -p .

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @pioneer-platform/walletguard
 
+## 0.3.0
+
+### Minor Changes
+
+- Automated minor version bump for all packages
+
+### Patch Changes
+
+- Updated dependencies
+  - @pioneer-platform/maya-network@8.6.0
+  - @pioneer-platform/loggerdog@8.6.0
+  - @pioneer-platform/pioneer-coins@9.6.0
+  - @pioneer-platform/pioneer-caip@9.5.0
+
 ## 0.2.0
 
 ### Minor Changes

package/build.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+# Fast Bun build (replaces slow tsc)
+
+OUTDIR="${1:-lib}"
+ENTRY="${2:-src/index.ts}"
+
+# Clean output
+rm -rf "$OUTDIR"
+mkdir -p "$OUTDIR"
+
+# Build with Bun (10x faster than tsc)
+bun build "$ENTRY" \
+  --outdir "$OUTDIR" \
+  --target node \
+  --format cjs \
+  --sourcemap \
+  --minify
+
+# Generate TypeScript declarations
+bunx tsc --emitDeclarationOnly --outDir "$OUTDIR" --project .
+
+echo "✅ Built $OUTDIR"

package/lib/PhishingResponse.d.ts

@@ -0,0 +1,13 @@
+import { RiskFactor } from './Transaction';
+export interface PhishingResponse {
+    domainName: string;
+    verified: boolean;
+    recommendedAction: RecommendedAction;
+    riskFactors: RiskFactor[] | null;
+    status: 'IN_PROGRESS' | 'COMPLETE';
+}
+export declare enum RecommendedAction {
+    Block = "BLOCK",
+    Warn = "WARN",
+    None = "NONE"
+}

package/lib/PhishingResponse.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecommendedAction = void 0;
+var RecommendedAction;
+(function (RecommendedAction) {
+    RecommendedAction["Block"] = "BLOCK";
+    RecommendedAction["Warn"] = "WARN";
+    RecommendedAction["None"] = "NONE";
+})(RecommendedAction || (exports.RecommendedAction = RecommendedAction = {}));

package/lib/Transaction.d.ts

@@ -0,0 +1,243 @@
+import { PhishingResponse } from './PhishingResponse';
+export interface Transaction {
+    from: string;
+    to: string;
+    data?: string;
+    value?: string;
+}
+export declare enum TransactionType {
+    Transaction = "Transaction",
+    Signature = "Signature"
+}
+export declare enum ResponseType {
+    Success = "success",
+    Revert = "revert",
+    Error = "error"
+}
+export declare enum TokenType {
+    ERC721 = "ERC721",
+    ERC1155 = "ERC1155",
+    ERC20 = "ERC20"
+}
+export declare enum SimulationMethodType {
+    EthSignTypedDataV3 = "eth_signTypedData_v3",
+    EthSignTypedDataV4 = "eth_signTypedData_v4",
+    EthSendTransaction = "eth_sendTransaction",
+    EthSign = "eth_sign",
+    PersonalSign = "personal_sign"
+}
+export type TransactionArgs = SimulateRequestArgs | SignatureRequestArgs | SignatureHashSignArgs | PersonalSignArgs | UnstandardizedSignatureRequestArgs;
+export interface SimulateRequestArgs extends RequestArgs {
+    transaction: Transaction;
+}
+export interface UnstandardizedSignatureRequestArgs extends RequestArgs {
+    params: any;
+}
+export interface SignatureRequestArgs extends RequestArgs {
+    domain: any;
+    message: any;
+    primaryType: string;
+}
+export interface SignatureHashSignArgs extends RequestArgs {
+    hash: string;
+}
+export interface PersonalSignArgs extends RequestArgs {
+    signMessage: string;
+}
+interface RequestArgs {
+    id: string;
+    chainId: string;
+    signer: string;
+    origin: string;
+    method: SimulationMethodType | string;
+    bypassed?: boolean;
+}
+export type SimulationResponse = SimulationSuccessResponse | SimulationErrorResponse;
+export type SoftLockedAssetsResponse = {
+    ownerAddress: string;
+    lastUpdatedAt: string;
+    lockedAssets: AssetKey[] | null;
+};
+export type AssetKey = {
+    ownerAddress: string;
+    ercType: string;
+    contractAddress: string;
+    tokenId: string;
+};
+export type SimulationErrorResponse = {
+    error: SimulationError;
+    scanResult?: PhishingResponse;
+};
+export type SimulationSuccessResponse = {
+    recommendedAction: RecommendedActionType;
+    overviewMessage: string;
+    stateChanges: StateChange[] | null;
+    addressDetails: SimulationAddressDetails;
+    decodedMessage?: string;
+    scanResult: PhishingResponse;
+    riskFactors: RiskFactor[] | null;
+    gas?: SimulatedGas;
+    error: null;
+    extraInfo: ExtraInfoData | null;
+};
+export type SimulationApiResponse = {
+    recommendedAction: RecommendedActionType;
+    overviewMessage: string;
+    stateChanges: StateChange[] | null;
+    addressDetails: SimulationAddressDetails;
+    decodedMessage?: string;
+    scanResult: PhishingResponse;
+    riskFactors: RiskFactor[] | null;
+    gas?: SimulatedGas;
+    error: SimulationError | null;
+    extraInfo: ExtraInfoData | null;
+};
+export declare enum ExtraInfoType {
+    UnresolvableSignature = "UNRESOLVABLE_SIGNATURE"
+}
+export type ExtraInfoData = {
+    type: ExtraInfoType;
+    message: string;
+};
+export type SimulatedGas = {
+    gasUsedEth: string;
+    fiatValue: string;
+    currency: Currency;
+};
+export declare enum Currency {
+    USD = "USD"
+}
+export declare enum RecommendedActionType {
+    None = "NONE",
+    Warn = "WARN",
+    Block = "BLOCK"
+}
+export type RiskFactor = {
+    severity: Severity;
+    type: WarningType;
+    message: string;
+    value?: string;
+};
+export declare enum WarningType {
+    Bypass = "BYPASS",
+    Similarity = "SIMILARITY",
+    RecentlyCreated = "RECENTLY_CREATED",
+    Malware = "MALWARE",
+    Homoglyph = "HOMOGLYPH",
+    Blocklisted = "BLOCKLISTED",
+    MLInference = "ML_INFERENCE",
+    Drainer = "DRAINER",
+    BlurListing = "BLUR_LISTING",
+    OpenseaListing = "OPENSEA_LISTING",
+    EthSign = "ETH_SIGN",
+    LooksrareListing = "LOOKSRARE_LISTING",
+    DrainerRequest = "DRAINER_REQUEST"
+}
+export declare enum Severity {
+    Low = "LOW",
+    High = "HIGH",
+    Critical = "CRITICAL"
+}
+export type SimulationError = {
+    type: ErrorType;
+    message: string;
+    extraData: object | null;
+};
+export declare enum ErrorType {
+    Unauthorized = "UNAUTHORIZED",
+    InsufficientFunds = "INSUFFICIENT_FUNDS",
+    MaxFeePerGasLessThanBlockBaseFee = "MAX_FEE_PER_GAS_LESS_THAN_BLOCK_BASE_FEE",
+    UnsupportedSignature = "UNSUPPORTED_SIGNATURE",
+    Revert = "REVERT",
+    TooManyRequests = "TOO_MANY_REQUESTS",
+    GeneralError = "ERROR",
+    UnknownError = "UNKNOWN_ERROR"
+}
+export declare enum SimulationWarningType {
+    None = "NONE",
+    Info = "INFO",
+    Warn = "WARN"
+}
+export declare enum SimulationChangeType {
+    OpenSeaListing = "OPENSEA_LISTING",
+    OpenSeaReceive = "OPENSEA_RECEIVE",
+    LooksRareAskReceive = "LOOKSRARE_ASK_RECEIVE",
+    LooksRareAskListing = "LOOKSRARE_ASK_LISTING",
+    LooksRareBidReceive = "LOOKSRARE_BID_RECEIVE",
+    LooksRareBidOffer = "LOOKSRARE_BID_OFFER",
+    ReceiveApproval = "RECEIVE_APPROVAL",
+    ReceiveApprovalForAll = "RECEIVE_APPROVAL_FOR_ALL",
+    ListingReceive = "LISTING_RECEIVE",
+    ListingTransfer = "LISTING_TRANSFER",
+    PermitTransfer = "PERMIT_TRANSFER",
+    PermitReceive = "PERMIT_RECEIVE",
+    ApprovalForAll = "APPROVAL_FOR_ALL",
+    Approve = "APPROVE",
+    RevokeApprovalForAll = "REVOKE_APPROVAL_FOR_ALL",
+    Revoke = "REVOKE_APPROVE",
+    Transfer = "TRANSFER",
+    Receive = "RECEIVE",
+    Bidding = "BIDDING",
+    Listing = "LISTING"
+}
+export declare enum SimulationAssetTypes {
+    ERC20 = "ERC20",
+    ERC721 = "ERC721",
+    ERC1155 = "ERC1155",
+    Native = "NATIVE"
+}
+export declare enum AddressType {
+    EOA = "EOA",
+    Contract = "CONTRACT"
+}
+export type SimulationAddressDetails = {
+    address: string;
+    addressType: AddressType;
+    etherscanVerified: boolean;
+    etherscanLink: string;
+    addressName: string;
+};
+export type TokenData = {
+    verified?: Verified;
+    address: string;
+    name?: string;
+    symbol?: string;
+    tokenID?: string;
+    tokenURI?: string;
+    decimals?: number;
+    logo?: string;
+    EIP: string;
+};
+export type ApprovalStateChange = {
+    approval: boolean;
+    allTokens: boolean;
+    tokenID: string;
+    amount: number;
+    address: string;
+};
+export type Verified = {
+    etherscan?: boolean;
+    sourcify?: boolean;
+};
+export type StateChange = {
+    assetType: SimulationAssetTypes;
+    changeType: SimulationChangeType;
+    address: string;
+    amount: string;
+    symbol: string;
+    decimals: number;
+    contractAddress: string;
+    name: string;
+    logo: string;
+    tokenID: string;
+    tokenURI: string;
+    tokenName: string;
+    openSeaFloorPrice: number;
+    openSeaVerified: boolean;
+    etherscanVerified: boolean;
+    fiatValue: string;
+    coinmarketcapLink: string;
+    openSeaLink: string;
+    locked: boolean;
+};
+export {};

package/lib/Transaction.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddressType = exports.SimulationAssetTypes = exports.SimulationChangeType = exports.SimulationWarningType = exports.ErrorType = exports.Severity = exports.WarningType = exports.RecommendedActionType = exports.Currency = exports.ExtraInfoType = exports.SimulationMethodType = exports.TokenType = exports.ResponseType = exports.TransactionType = void 0;
+var TransactionType;
+(function (TransactionType) {
+    TransactionType["Transaction"] = "Transaction";
+    TransactionType["Signature"] = "Signature";
+})(TransactionType || (exports.TransactionType = TransactionType = {}));
+var ResponseType;
+(function (ResponseType) {
+    ResponseType["Success"] = "success";
+    ResponseType["Revert"] = "revert";
+    ResponseType["Error"] = "error";
+})(ResponseType || (exports.ResponseType = ResponseType = {}));
+var TokenType;
+(function (TokenType) {
+    TokenType["ERC721"] = "ERC721";
+    TokenType["ERC1155"] = "ERC1155";
+    TokenType["ERC20"] = "ERC20";
+})(TokenType || (exports.TokenType = TokenType = {}));
+var SimulationMethodType;
+(function (SimulationMethodType) {
+    SimulationMethodType["EthSignTypedDataV3"] = "eth_signTypedData_v3";
+    SimulationMethodType["EthSignTypedDataV4"] = "eth_signTypedData_v4";
+    SimulationMethodType["EthSendTransaction"] = "eth_sendTransaction";
+    SimulationMethodType["EthSign"] = "eth_sign";
+    SimulationMethodType["PersonalSign"] = "personal_sign";
+})(SimulationMethodType || (exports.SimulationMethodType = SimulationMethodType = {}));
+;
+;
+;
+;
+var ExtraInfoType;
+(function (ExtraInfoType) {
+    ExtraInfoType["UnresolvableSignature"] = "UNRESOLVABLE_SIGNATURE";
+})(ExtraInfoType || (exports.ExtraInfoType = ExtraInfoType = {}));
+var Currency;
+(function (Currency) {
+    // add support for more currencies here in the future
+    Currency["USD"] = "USD";
+})(Currency || (exports.Currency = Currency = {}));
+var RecommendedActionType;
+(function (RecommendedActionType) {
+    RecommendedActionType["None"] = "NONE";
+    RecommendedActionType["Warn"] = "WARN";
+    RecommendedActionType["Block"] = "BLOCK";
+})(RecommendedActionType || (exports.RecommendedActionType = RecommendedActionType = {}));
+var WarningType;
+(function (WarningType) {
+    WarningType["Bypass"] = "BYPASS";
+    WarningType["Similarity"] = "SIMILARITY";
+    WarningType["RecentlyCreated"] = "RECENTLY_CREATED";
+    WarningType["Malware"] = "MALWARE";
+    WarningType["Homoglyph"] = "HOMOGLYPH";
+    WarningType["Blocklisted"] = "BLOCKLISTED";
+    WarningType["MLInference"] = "ML_INFERENCE";
+    WarningType["Drainer"] = "DRAINER";
+    WarningType["BlurListing"] = "BLUR_LISTING";
+    WarningType["OpenseaListing"] = "OPENSEA_LISTING";
+    WarningType["EthSign"] = "ETH_SIGN";
+    WarningType["LooksrareListing"] = "LOOKSRARE_LISTING";
+    WarningType["DrainerRequest"] = "DRAINER_REQUEST";
+})(WarningType || (exports.WarningType = WarningType = {}));
+var Severity;
+(function (Severity) {
+    Severity["Low"] = "LOW";
+    Severity["High"] = "HIGH";
+    Severity["Critical"] = "CRITICAL";
+})(Severity || (exports.Severity = Severity = {}));
+var ErrorType;
+(function (ErrorType) {
+    ErrorType["Unauthorized"] = "UNAUTHORIZED";
+    ErrorType["InsufficientFunds"] = "INSUFFICIENT_FUNDS";
+    ErrorType["MaxFeePerGasLessThanBlockBaseFee"] = "MAX_FEE_PER_GAS_LESS_THAN_BLOCK_BASE_FEE";
+    ErrorType["UnsupportedSignature"] = "UNSUPPORTED_SIGNATURE";
+    ErrorType["Revert"] = "REVERT";
+    ErrorType["TooManyRequests"] = "TOO_MANY_REQUESTS";
+    ErrorType["GeneralError"] = "ERROR";
+    ErrorType["UnknownError"] = "UNKNOWN_ERROR";
+})(ErrorType || (exports.ErrorType = ErrorType = {}));
+var SimulationWarningType;
+(function (SimulationWarningType) {
+    SimulationWarningType["None"] = "NONE";
+    SimulationWarningType["Info"] = "INFO";
+    SimulationWarningType["Warn"] = "WARN";
+})(SimulationWarningType || (exports.SimulationWarningType = SimulationWarningType = {}));
+var SimulationChangeType;
+(function (SimulationChangeType) {
+    // v0 (+ everything from v1 except bid, listing, and revoke)
+    SimulationChangeType["OpenSeaListing"] = "OPENSEA_LISTING";
+    SimulationChangeType["OpenSeaReceive"] = "OPENSEA_RECEIVE";
+    SimulationChangeType["LooksRareAskReceive"] = "LOOKSRARE_ASK_RECEIVE";
+    SimulationChangeType["LooksRareAskListing"] = "LOOKSRARE_ASK_LISTING";
+    SimulationChangeType["LooksRareBidReceive"] = "LOOKSRARE_BID_RECEIVE";
+    SimulationChangeType["LooksRareBidOffer"] = "LOOKSRARE_BID_OFFER";
+    SimulationChangeType["ReceiveApproval"] = "RECEIVE_APPROVAL";
+    SimulationChangeType["ReceiveApprovalForAll"] = "RECEIVE_APPROVAL_FOR_ALL";
+    SimulationChangeType["ListingReceive"] = "LISTING_RECEIVE";
+    SimulationChangeType["ListingTransfer"] = "LISTING_TRANSFER";
+    SimulationChangeType["PermitTransfer"] = "PERMIT_TRANSFER";
+    SimulationChangeType["PermitReceive"] = "PERMIT_RECEIVE";
+    // v1
+    SimulationChangeType["ApprovalForAll"] = "APPROVAL_FOR_ALL";
+    SimulationChangeType["Approve"] = "APPROVE";
+    SimulationChangeType["RevokeApprovalForAll"] = "REVOKE_APPROVAL_FOR_ALL";
+    SimulationChangeType["Revoke"] = "REVOKE_APPROVE";
+    SimulationChangeType["Transfer"] = "TRANSFER";
+    SimulationChangeType["Receive"] = "RECEIVE";
+    SimulationChangeType["Bidding"] = "BIDDING";
+    SimulationChangeType["Listing"] = "LISTING";
+})(SimulationChangeType || (exports.SimulationChangeType = SimulationChangeType = {}));
+var SimulationAssetTypes;
+(function (SimulationAssetTypes) {
+    SimulationAssetTypes["ERC20"] = "ERC20";
+    SimulationAssetTypes["ERC721"] = "ERC721";
+    SimulationAssetTypes["ERC1155"] = "ERC1155";
+    SimulationAssetTypes["Native"] = "NATIVE";
+})(SimulationAssetTypes || (exports.SimulationAssetTypes = SimulationAssetTypes = {}));
+var AddressType;
+(function (AddressType) {
+    AddressType["EOA"] = "EOA";
+    AddressType["Contract"] = "CONTRACT";
+})(AddressType || (exports.AddressType = AddressType = {}));

package/lib/environment.d.ts

@@ -0,0 +1,4 @@
+export declare const SERVER_URL_PROD = "https://api.walletguard.app/extension/v0";
+export declare const SERVER_URL_PROD_V1 = "https://api.walletguard.app/extension/v1";
+export declare const CHATWEB3_SERVER_URL_PROD = "https://api.chatweb3.walletguard.app";
+export declare const CDN_URL_PROD = "https://cdn.walletguard.app";

package/lib/environment.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CDN_URL_PROD = exports.CHATWEB3_SERVER_URL_PROD = exports.SERVER_URL_PROD_V1 = exports.SERVER_URL_PROD = void 0;
+// Security API - For business inquiries please visit https://docs.walletguard.app
+exports.SERVER_URL_PROD = 'https://api.walletguard.app/extension/v0';
+exports.SERVER_URL_PROD_V1 = 'https://api.walletguard.app/extension/v1';
+// CHATWEB3
+exports.CHATWEB3_SERVER_URL_PROD = 'https://api.chatweb3.walletguard.app';
+// CDN
+exports.CDN_URL_PROD = 'https://cdn.walletguard.app';

package/lib/index.d.ts

@@ -0,0 +1,36 @@
+declare const TAG = " | WalletGuard | ";
+type BaseDecimal = string | number;
+declare const axios: any;
+declare const log: any;
+declare enum TransactionType {
+    Transaction = "transaction",
+    Message = "message"
+}
+declare enum SimulationMethodType {
+    EthSendTransaction = "eth_sendTransaction",
+    EthSignTransaction = "eth_signTransaction"
+}
+declare const fetchTransaction: (transactionArgs: any, type: TransactionType) => Promise<{
+    success: boolean;
+    risk: {
+        score: number;
+        level: string;
+        alerts: never[];
+    };
+    simulation: {
+        status: string;
+        gasUsed: string;
+    };
+}>;
+declare const simulate_tx: (chainId: any, tx: any) => Promise<{
+    success: boolean;
+    risk: {
+        score: number;
+        level: string;
+        alerts: never[];
+    };
+    simulation: {
+        status: string;
+        gasUsed: string;
+    };
+}>;

package/lib/index.js

@@ -0,0 +1,120 @@
+"use strict";
+/*
+        WalletGuard Integration
+                - Highlander
+
+    BASE
+    https://docs.base.org/contracts/
+
+
+
+ */
+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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var TAG = " | WalletGuard | ";
+var axios = require('axios');
+var log = require('@pioneer-platform/loggerdog')();
+// Mock enums instead of importing
+var TransactionType;
+(function (TransactionType) {
+    TransactionType["Transaction"] = "transaction";
+    TransactionType["Message"] = "message";
+})(TransactionType || (TransactionType = {}));
+var SimulationMethodType;
+(function (SimulationMethodType) {
+    SimulationMethodType["EthSendTransaction"] = "eth_sendTransaction";
+    SimulationMethodType["EthSignTransaction"] = "eth_signTransaction";
+})(SimulationMethodType || (SimulationMethodType = {}));
+// Mock the fetchTransaction function
+var fetchTransaction = function (transactionArgs, type) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        // Return mock data
+        return [2 /*return*/, {
+                success: true,
+                risk: {
+                    score: 0,
+                    level: 'SAFE',
+                    alerts: []
+                },
+                simulation: {
+                    status: 'SUCCESS',
+                    gasUsed: '100000'
+                }
+            }];
+    });
+}); };
+module.exports = {
+    init: function (settings) {
+        return true;
+    },
+    getSimulation: function (chainId, tx) {
+        return simulate_tx(chainId, tx);
+    }
+};
+var simulate_tx = function (chainId, tx) {
+    return __awaiter(this, void 0, void 0, function () {
+        var tag, output, transactionArgs, result, e_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    tag = TAG + " | simulate_tx | ";
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    output = {};
+                    log.info(tag, "tx: ", tx);
+                    transactionArgs = {
+                        id: "some-unique-id", // You should generate a unique id
+                        chainId: chainId,
+                        signer: tx.from,
+                        origin: "your-dapp-origin.com", // Specify the domain origin of your dApp
+                        method: SimulationMethodType.EthSendTransaction, // Using EthSendTransaction as the method type
+                        transaction: tx, // the actual transaction data provided
+                    };
+                    return [4 /*yield*/, fetchTransaction(transactionArgs, TransactionType.Transaction)];
+                case 2:
+                    result = _a.sent();
+                    return [2 /*return*/, result];
+                case 3:
+                    e_1 = _a.sent();
+                    console.error(tag, "e: ", e_1);
+                    throw e_1;
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+};