@0xtorch/evm 0.0.3 → 0.0.5

package/_cjs/analyzer/seaport/analyze.js

@@ -0,0 +1,649 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeSeaport = void 0;
+const big_decimal_1 = require("@0xtorch/big-decimal");
+const createEvmAccount_1 = require("../../creates/createEvmAccount");
+const types_1 = require("../../types");
+const spam_1 = require("../spam");
+const orderFulfilled_1 = require("./orderFulfilled");
+const analyzeSeaport = async ({ chain, transaction, accountAddresses, }) => {
+    const { transactionHash, value, from, to, contractAddress, logs, erc20Transfers, erc721Transfers, erc1155Transfers, internalTransactions, nativeTokenPrice, } = transaction;
+    const allInternalTransactions = [
+        ...(value > 0n
+            ? [
+                {
+                    type: 'InternalTransaction',
+                    transactionHash,
+                    from: (0, types_1.toLowerHex)(from),
+                    to: to === null ? undefined : (0, types_1.toLowerHex)(to),
+                    contractAddress: contractAddress === null
+                        ? undefined
+                        : (0, types_1.toLowerHex)(contractAddress),
+                    txType: '',
+                    value,
+                    gas: 0n,
+                    gasUsed: 0n,
+                    isError: false,
+                    input: undefined,
+                    currency: chain.nativeToken.currency,
+                    price: nativeTokenPrice,
+                },
+            ]
+            : []),
+        ...internalTransactions,
+    ];
+    const decodedLogs = logs
+        .map((log) => (log.type === 'decoded' ? log.log : undefined))
+        .filter((log) => log !== undefined);
+    const orderFulfilledLogs = decodedLogs
+        .map((log) => (0, orderFulfilled_1.parseToOrderFulfilledLog)(log))
+        .filter((log) => log !== undefined)
+        .filter((log) => log.args[1].value !== log.args[3].value);
+    if (orderFulfilledLogs.length !== 1) {
+        return undefined;
+    }
+    const orderFulfilledLog = orderFulfilledLogs[0];
+    const orderOfferer = orderFulfilledLog.args[1].value;
+    const orderRecipient = orderFulfilledLog.args[3].value;
+    const mut_offerTransfers = [];
+    let mut_isSpam = false;
+    let mut_includeNativeToken = false;
+    for (const offerItem of orderFulfilledLog.args[4].value) {
+        switch (offerItem.itemType) {
+            case 0: {
+                const considerationAmount = orderFulfilledLog.args[5].value
+                    .filter((item) => item.itemType === 0)
+                    .reduce((accumulator, item) => accumulator + item.amount, 0n);
+                const amount = offerItem.amount - considerationAmount;
+                const internalTransfers = allInternalTransactions.filter((internal) => internal.value === amount && internal.to === orderRecipient);
+                if (internalTransfers.length <= 1) {
+                    mut_includeNativeToken = true;
+                    break;
+                }
+                else {
+                    return undefined;
+                }
+            }
+            case 1: {
+                const considerationAmount = orderFulfilledLog.args[5].value
+                    .filter((item) => item.itemType === 1 && item.token === offerItem.token)
+                    .reduce((accumulator, item) => accumulator + item.amount, 0n);
+                const amount = offerItem.amount - considerationAmount;
+                const erc20OfferTransfers = erc20Transfers.filter((transfer) => transfer.token.contractAddress === offerItem.token &&
+                    transfer.value === amount &&
+                    transfer.from === orderOfferer &&
+                    transfer.to === orderRecipient);
+                if (erc20OfferTransfers.length === 1) {
+                    mut_offerTransfers.push(erc20OfferTransfers[0]);
+                    break;
+                }
+                else if (erc20OfferTransfers.length > 1) {
+                    return undefined;
+                }
+                else {
+                    if (erc20Transfers.some((transfer) => transfer.token.contractAddress === offerItem.token &&
+                        transfer.value === amount)) {
+                        mut_isSpam = true;
+                    }
+                    else {
+                        return undefined;
+                    }
+                    break;
+                }
+            }
+            case 2: {
+                const erc721OfferTransfers = erc721Transfers.filter((transfer) => transfer.token.contractAddress === offerItem.token &&
+                    transfer.tokenId === offerItem.identifier &&
+                    transfer.from === orderOfferer &&
+                    transfer.to === orderRecipient);
+                if (erc721OfferTransfers.length === 1) {
+                    mut_offerTransfers.push(erc721OfferTransfers[0]);
+                    break;
+                }
+                else if (erc721OfferTransfers.length > 1) {
+                    return undefined;
+                }
+                else {
+                    if (erc721Transfers.some((transfer) => transfer.token.contractAddress === offerItem.token &&
+                        transfer.tokenId === offerItem.identifier)) {
+                        mut_isSpam = true;
+                    }
+                    else {
+                        return undefined;
+                    }
+                    break;
+                }
+            }
+            case 3: {
+                const erc1155OfferTransfers = erc1155Transfers.filter((transfer) => transfer.token.contractAddress === offerItem.token &&
+                    transfer.id === offerItem.identifier &&
+                    transfer.value === offerItem.amount &&
+                    transfer.from === orderOfferer &&
+                    transfer.to === orderRecipient);
+                if (erc1155OfferTransfers.length === 1) {
+                    mut_offerTransfers.push(erc1155OfferTransfers[0]);
+                    break;
+                }
+                else if (erc1155OfferTransfers.length > 1) {
+                    return undefined;
+                }
+                else {
+                    if (erc1155Transfers.some((transfer) => transfer.token.contractAddress === offerItem.token &&
+                        transfer.id === offerItem.identifier)) {
+                        mut_isSpam = true;
+                    }
+                    else {
+                        return undefined;
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    const mut_considerationTransfers = [];
+    for (const considerationItem of orderFulfilledLog.args[5].value) {
+        if (orderRecipient === considerationItem.recipient) {
+            continue;
+        }
+        switch (considerationItem.itemType) {
+            case 0: {
+                const internalTransfers = allInternalTransactions.filter((internal) => internal.value === considerationItem.amount &&
+                    internal.to === considerationItem.recipient);
+                if (internalTransfers.length <= 1) {
+                    mut_includeNativeToken = true;
+                    break;
+                }
+                else {
+                    return undefined;
+                }
+            }
+            case 1: {
+                const from = orderFulfilledLog.args[4].value.some((item) => item.itemType === 1 && item.token === considerationItem.token)
+                    ? orderOfferer
+                    : orderRecipient;
+                const erc20ConsiderationTransfers = erc20Transfers.filter((transfer) => transfer.token.contractAddress === considerationItem.token &&
+                    transfer.value === considerationItem.amount &&
+                    transfer.from === from &&
+                    transfer.to === considerationItem.recipient);
+                if (erc20ConsiderationTransfers.length === 1) {
+                    mut_considerationTransfers.push(erc20ConsiderationTransfers[0]);
+                    break;
+                }
+                else if (erc20ConsiderationTransfers.length > 1) {
+                    return undefined;
+                }
+                else {
+                    if (erc20Transfers.some((transfer) => transfer.token.contractAddress === considerationItem.token &&
+                        transfer.value === considerationItem.amount)) {
+                        mut_isSpam = true;
+                    }
+                    else {
+                        return undefined;
+                    }
+                    break;
+                }
+            }
+            case 2: {
+                const erc721ConsiderationTransfers = erc721Transfers.filter((transfer) => transfer.token.contractAddress === considerationItem.token &&
+                    transfer.tokenId === considerationItem.identifier &&
+                    transfer.from === orderRecipient &&
+                    transfer.to === considerationItem.recipient);
+                if (erc721ConsiderationTransfers.length === 1) {
+                    mut_considerationTransfers.push(erc721ConsiderationTransfers[0]);
+                    break;
+                }
+                else if (erc721ConsiderationTransfers.length > 1) {
+                    return undefined;
+                }
+                else {
+                    if (erc721Transfers.some((transfer) => transfer.token.contractAddress === considerationItem.token &&
+                        transfer.tokenId === considerationItem.identifier)) {
+                        mut_isSpam = true;
+                    }
+                    else {
+                        return undefined;
+                    }
+                    break;
+                }
+            }
+            case 3: {
+                const erc1155ConsiderationTransfers = erc1155Transfers.filter((transfer) => transfer.token.contractAddress === considerationItem.token &&
+                    transfer.id === considerationItem.identifier &&
+                    transfer.value === considerationItem.amount &&
+                    transfer.from === orderRecipient &&
+                    transfer.to === considerationItem.recipient);
+                if (erc1155ConsiderationTransfers.length === 1) {
+                    mut_considerationTransfers.push(erc1155ConsiderationTransfers[0]);
+                    break;
+                }
+                else if (erc1155ConsiderationTransfers.length > 1) {
+                    return undefined;
+                }
+                else {
+                    if (erc1155Transfers.some((transfer) => transfer.token.contractAddress === considerationItem.token &&
+                        transfer.id === considerationItem.identifier)) {
+                        mut_isSpam = true;
+                    }
+                    else {
+                        return undefined;
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    if (mut_isSpam) {
+        return await (0, spam_1.analyzeAsSpam)({ chain, transaction, accountAddresses });
+    }
+    if (erc20Transfers.some((transfer) => mut_offerTransfers.every((offerTransfer) => offerTransfer.type !== 'Erc20Transfer' ||
+        transfer.logIndex !== offerTransfer.logIndex) &&
+        mut_considerationTransfers.every((considerationTransfer) => considerationTransfer.type !== 'Erc20Transfer' ||
+            transfer.logIndex !== considerationTransfer.logIndex)) ||
+        erc721Transfers.some((transfer) => mut_offerTransfers.every((offerTransfer) => offerTransfer.type !== 'Erc721Transfer' ||
+            transfer.logIndex !== offerTransfer.logIndex) &&
+            mut_considerationTransfers.every((considerationTransfer) => considerationTransfer.type !== 'Erc721Transfer' ||
+                transfer.logIndex !== considerationTransfer.logIndex)) ||
+        erc1155Transfers.some((transfer) => mut_offerTransfers.every((offerTransfer) => offerTransfer.type !== 'Erc1155Transfer' ||
+            transfer.logIndex !== offerTransfer.logIndex) &&
+            mut_considerationTransfers.every((considerationTransfer) => considerationTransfer.type !== 'Erc1155Transfer' ||
+                transfer.logIndex !== considerationTransfer.logIndex))) {
+        return undefined;
+    }
+    const normalAction = generateNormalAction(chain, transaction, orderFulfilledLog, mut_offerTransfers, mut_considerationTransfers, mut_includeNativeToken ? allInternalTransactions : [], accountAddresses);
+    if (normalAction === undefined) {
+        return undefined;
+    }
+    const accountActions = generateAccountActions(chain, transaction, accountAddresses, normalAction);
+    if (accountActions === undefined) {
+        return undefined;
+    }
+    return {
+        actions: [normalAction],
+        accountActions: accountActions,
+    };
+};
+exports.analyzeSeaport = analyzeSeaport;
+const generateNormalAction = (chain, { app, block, nativeTokenPrice }, orderFulfilledLog, offerTransfers, considerationTransfers, internalTransactions, accountAddresses) => {
+    const offerer = orderFulfilledLog.args[1].value;
+    const recipient = orderFulfilledLog.args[3].value;
+    let mut_existNoRecipientTransfer = !accountAddresses.includes(recipient) && accountAddresses.includes(offerer);
+    const mut_recipientTransfers = [];
+    for (const transfer of [
+        ...offerTransfers,
+        ...considerationTransfers,
+        ...internalTransactions,
+    ]) {
+        if (mut_existNoRecipientTransfer) {
+            break;
+        }
+        if (transfer.from === recipient && transfer.to === recipient) {
+            continue;
+        }
+        else if (transfer.from === recipient || transfer.to === recipient) {
+            const direction = transfer.from === recipient ? 'out' : 'in';
+            switch (transfer.type) {
+                case 'InternalTransaction': {
+                    if (transfer.to === undefined) {
+                        return undefined;
+                    }
+                    mut_recipientTransfers.push({
+                        target: recipient,
+                        direction,
+                        from: (0, createEvmAccount_1.createEvmAccount)({
+                            address: transfer.from,
+                            chainId: chain.id,
+                        }),
+                        to: (0, createEvmAccount_1.createEvmAccount)({
+                            address: transfer.to,
+                            chainId: chain.id,
+                        }),
+                        asset: chain.nativeToken.currency,
+                        amount: (0, big_decimal_1.createBigDecimal)(transfer.value, chain.nativeToken.decimals),
+                        price: nativeTokenPrice,
+                    });
+                    break;
+                }
+                case 'Erc20Transfer': {
+                    mut_recipientTransfers.push({
+                        target: recipient,
+                        direction,
+                        from: (0, createEvmAccount_1.createEvmAccount)({
+                            address: transfer.from,
+                            chainId: chain.id,
+                        }),
+                        to: (0, createEvmAccount_1.createEvmAccount)({
+                            address: transfer.to,
+                            chainId: chain.id,
+                        }),
+                        asset: transfer.token.currency,
+                        amount: (0, big_decimal_1.createBigDecimal)(transfer.value, transfer.token.decimals),
+                        price: transfer.price,
+                    });
+                    break;
+                }
+                case 'Erc721Transfer': {
+                    mut_recipientTransfers.push({
+                        target: recipient,
+                        direction,
+                        from: (0, createEvmAccount_1.createEvmAccount)({
+                            address: transfer.from,
+                            chainId: chain.id,
+                        }),
+                        to: (0, createEvmAccount_1.createEvmAccount)({
+                            address: transfer.to,
+                            chainId: chain.id,
+                        }),
+                        asset: transfer.nft,
+                        amount: (0, big_decimal_1.createBigDecimal)(1n),
+                        price: undefined,
+                    });
+                    break;
+                }
+                case 'Erc1155Transfer': {
+                    mut_recipientTransfers.push({
+                        target: recipient,
+                        direction,
+                        from: (0, createEvmAccount_1.createEvmAccount)({
+                            address: transfer.from,
+                            chainId: chain.id,
+                        }),
+                        to: (0, createEvmAccount_1.createEvmAccount)({
+                            address: transfer.to,
+                            chainId: chain.id,
+                        }),
+                        asset: transfer.nft,
+                        amount: (0, big_decimal_1.createBigDecimal)(transfer.value),
+                        price: undefined,
+                    });
+                    break;
+                }
+            }
+        }
+        else if (transfer.type === 'InternalTransaction') {
+            continue;
+        }
+        else {
+            mut_existNoRecipientTransfer = true;
+            break;
+        }
+    }
+    if (!mut_existNoRecipientTransfer) {
+        return {
+            type: 'NormalAction',
+            action: 'trade',
+            evidence: 'contract',
+            timestamp: Number(block.timestamp) * 1000,
+            comment: undefined,
+            app,
+            transfers: mut_recipientTransfers,
+        };
+    }
+    const mut_offererTransfers = [];
+    for (const transfer of [
+        ...offerTransfers,
+        ...considerationTransfers,
+        ...internalTransactions,
+    ]) {
+        if (transfer.from === offerer && transfer.to === offerer) {
+            continue;
+        }
+        else if (transfer.from === offerer || transfer.to === offerer) {
+            const direction = transfer.from === offerer ? 'out' : 'in';
+            switch (transfer.type) {
+                case 'InternalTransaction': {
+                    if (transfer.to === undefined) {
+                        return undefined;
+                    }
+                    mut_offererTransfers.push({
+                        target: offerer,
+                        direction,
+                        from: (0, createEvmAccount_1.createEvmAccount)({
+                            address: transfer.from,
+                            chainId: chain.id,
+                        }),
+                        to: (0, createEvmAccount_1.createEvmAccount)({
+                            address: transfer.to,
+                            chainId: chain.id,
+                        }),
+                        asset: chain.nativeToken.currency,
+                        amount: (0, big_decimal_1.createBigDecimal)(transfer.value, chain.nativeToken.decimals),
+                        price: nativeTokenPrice,
+                    });
+                    break;
+                }
+                case 'Erc20Transfer': {
+                    mut_offererTransfers.push({
+                        target: offerer,
+                        direction,
+                        from: (0, createEvmAccount_1.createEvmAccount)({
+                            address: transfer.from,
+                            chainId: chain.id,
+                        }),
+                        to: (0, createEvmAccount_1.createEvmAccount)({
+                            address: transfer.to,
+                            chainId: chain.id,
+                        }),
+                        asset: transfer.token.currency,
+                        amount: (0, big_decimal_1.createBigDecimal)(transfer.value, transfer.token.decimals),
+                        price: transfer.price,
+                    });
+                    break;
+                }
+                case 'Erc721Transfer': {
+                    mut_offererTransfers.push({
+                        target: offerer,
+                        direction,
+                        from: (0, createEvmAccount_1.createEvmAccount)({
+                            address: transfer.from,
+                            chainId: chain.id,
+                        }),
+                        to: (0, createEvmAccount_1.createEvmAccount)({
+                            address: transfer.to,
+                            chainId: chain.id,
+                        }),
+                        asset: transfer.nft,
+                        amount: (0, big_decimal_1.createBigDecimal)(1n),
+                        price: undefined,
+                    });
+                    break;
+                }
+                case 'Erc1155Transfer': {
+                    mut_offererTransfers.push({
+                        target: offerer,
+                        direction,
+                        from: (0, createEvmAccount_1.createEvmAccount)({
+                            address: transfer.from,
+                            chainId: chain.id,
+                        }),
+                        to: (0, createEvmAccount_1.createEvmAccount)({
+                            address: transfer.to,
+                            chainId: chain.id,
+                        }),
+                        asset: transfer.nft,
+                        amount: (0, big_decimal_1.createBigDecimal)(transfer.value),
+                        price: undefined,
+                    });
+                    break;
+                }
+            }
+        }
+        else if (transfer.type === 'InternalTransaction') {
+            continue;
+        }
+        else {
+            return undefined;
+        }
+    }
+    return {
+        type: 'NormalAction',
+        action: 'trade',
+        evidence: 'contract',
+        timestamp: Number(block.timestamp) * 1000,
+        comment: undefined,
+        app,
+        transfers: mut_offererTransfers,
+    };
+};
+const generateAccountActions = (chain, { transactionHash }, accountAddresses, action) => {
+    const source = `evm_${chain.id}_${(0, types_1.toLowerHex)(transactionHash)}`;
+    const transfers = action.transfers.filter((transfer) => accountAddresses.includes(transfer.from.address) ||
+        accountAddresses.includes(transfer.to.address));
+    if (transfers.some((transfer) => accountAddresses.includes(transfer.from.address) &&
+        accountAddresses.includes(transfer.to.address))) {
+        return undefined;
+    }
+    else if (transfers.every((transfer) => accountAddresses.includes(transfer.to.address) &&
+        transfer.asset.type === 'CryptoCurrency')) {
+        return transfers.map((transfer) => {
+            if (transfer.asset.type !== 'CryptoCurrency') {
+                throw new Error('invalid transfer');
+            }
+            return {
+                type: 'AccountAction',
+                action: 'nft-royalty',
+                source,
+                evidence: 'contract',
+                timestamp: action.timestamp,
+                order: 0,
+                comment: action.comment,
+                app: action.app,
+                transfers: [
+                    {
+                        ...transfer,
+                        target: transfer.to.address,
+                        direction: 'in',
+                        asset: transfer.asset,
+                    },
+                ],
+            };
+        });
+    }
+    else if (transfers.every((transfer) => accountAddresses.includes(transfer.from.address)) ||
+        transfers.every((transfer) => accountAddresses.includes(transfer.to.address))) {
+        return undefined;
+    }
+    const inTransfers = transfers.filter((transfer) => accountAddresses.includes(transfer.to.address));
+    const outTransfers = transfers.filter((transfer) => accountAddresses.includes(transfer.from.address));
+    if (inTransfers.every((transfer) => transfer.asset.type === 'Nft') &&
+        outTransfers.every((transfer) => transfer.asset.type === 'Nft')) {
+        return [
+            {
+                type: 'AccountAction',
+                action: 'swap-nft',
+                source,
+                evidence: 'contract',
+                timestamp: action.timestamp,
+                order: 0,
+                comment: action.comment,
+                app: action.app,
+                transfers: [
+                    ...inTransfers.map((transfer) => {
+                        if (transfer.asset.type !== 'Nft') {
+                            throw new Error('invalid transfer');
+                        }
+                        return {
+                            ...transfer,
+                            target: transfer.to.address,
+                            direction: 'in',
+                            asset: transfer.asset,
+                            price: undefined,
+                        };
+                    }),
+                    ...outTransfers.map((transfer) => {
+                        if (transfer.asset.type !== 'Nft') {
+                            throw new Error('invalid transfer');
+                        }
+                        return {
+                            ...transfer,
+                            target: transfer.from.address,
+                            direction: 'out',
+                            asset: transfer.asset,
+                            price: undefined,
+                        };
+                    }),
+                ],
+            },
+        ];
+    }
+    else if (inTransfers.every((transfer) => transfer.asset.type === 'Nft') &&
+        outTransfers.every((transfer) => transfer.asset.type === 'CryptoCurrency')) {
+        return [
+            {
+                type: 'AccountAction',
+                action: 'buy-nft',
+                source,
+                evidence: 'contract',
+                timestamp: action.timestamp,
+                order: 0,
+                comment: action.comment,
+                app: action.app,
+                transfers: [
+                    ...inTransfers.map((transfer) => ({
+                        ...transfer,
+                        target: transfer.to.address,
+                        direction: 'in',
+                    })),
+                    ...outTransfers.map((transfer) => ({
+                        ...transfer,
+                        target: transfer.from.address,
+                        direction: 'out',
+                    })),
+                ],
+            },
+        ];
+    }
+    else if (inTransfers.every((transfer) => transfer.asset.type === 'CryptoCurrency') &&
+        outTransfers.every((transfer) => transfer.asset.type === 'Nft')) {
+        return [
+            {
+                type: 'AccountAction',
+                action: 'sell-nft',
+                source,
+                evidence: 'contract',
+                timestamp: action.timestamp,
+                order: 0,
+                comment: action.comment,
+                app: action.app,
+                transfers: [
+                    ...inTransfers.map((transfer) => ({
+                        ...transfer,
+                        target: transfer.to.address,
+                        direction: 'in',
+                    })),
+                    ...outTransfers.map((transfer) => ({
+                        ...transfer,
+                        target: transfer.from.address,
+                        direction: 'out',
+                    })),
+                ],
+            },
+        ];
+    }
+    else {
+        return [
+            {
+                type: 'AccountAction',
+                action: 'trade',
+                source,
+                evidence: 'contract',
+                timestamp: action.timestamp,
+                order: 0,
+                comment: action.comment,
+                app: action.app,
+                transfers: [
+                    ...inTransfers.map((transfer) => ({
+                        ...transfer,
+                        target: transfer.to.address,
+                        direction: 'in',
+                    })),
+                    ...outTransfers.map((transfer) => ({
+                        ...transfer,
+                        target: transfer.from.address,
+                        direction: 'out',
+                    })),
+                ],
+            },
+        ];
+    }
+};
+//# sourceMappingURL=analyze.js.map