@indexing/jiti 0.0.18 → 0.0.20

package/dist/main.js

@@ -321,9 +321,318 @@ const $6144a02851f23907$var$tokenTransfersTemplate = {
         const TOKEN_TYPES = _ctx.params.tokenTypes || [];
         let transfers = [];
         switch(block._network){
-            // @TODO: expand to non-EVM
-            // assume EVM as default for now
+            case "APTOS":
+            case "APTOS_TESTNET":
+                for (const tx of block.transactions){
+                    if (!tx?.events || !Array.isArray(tx.events)) break;
+                    const timestamp = tx.timestamp ? new Date(parseInt(tx.timestamp) / 1000).toISOString() : null;
+                    const txfersByKey = {};
+                    for (const evt of tx.events)if ([
+                        "0x1::coin::WithdrawEvent",
+                        "0x1::coin::DepositEvent"
+                    ].includes(evt.type)) {
+                        const amount = evt.data?.amount;
+                        const key = `0x1-${amount}`;
+                        txfersByKey[key] ||= {
+                            amount: amount,
+                            tokenAddress: null
+                        };
+                        if (evt.type.endsWith("WithdrawEvent")) txfersByKey[key].from = evt.guid?.account_address;
+                        else txfersByKey[key].to = evt.guid?.account_address;
+                    }
+                    for (const partial of Object.values(txfersByKey)){
+                        if (!partial.from || !partial.to) continue;
+                        transfers.push({
+                            amount: BigInt(partial.amount),
+                            blockNumber: parseInt(block.block_height),
+                            from: partial.from,
+                            timestamp: timestamp,
+                            to: partial.to,
+                            token: partial.tokenAddress,
+                            tokenType: "NATIVE",
+                            transactionGasFee: BigInt(tx.gas_used),
+                            transactionHash: tx.hash
+                        });
+                    }
+                }
+                break;
+            case "BITCOIN":
+            case "BITCOIN_TESTNET":
+            case "LITCOIN":
+            case "DOGECOIN":
+                for (const tx of block.tx){
+                    const timestamp = tx.time ? new Date(tx.time * 1000).toISOString() : null;
+                    const vin = tx.vin[0];
+                    const vout = tx.vout;
+                    const fromVout = Math.min(vin.vout || 1000, vout.length - 1);
+                    const fromAddress = vin.prevout?.scriptPubKey?.address || vout[fromVout]?.scriptPubKey?.address || vout[fromVout]?.scriptPubKey?.addresses?.[0];
+                    if (!fromAddress) break;
+                    for (const v of vout)transfers.push({
+                        amount: BigInt(Math.round(v.value * Math.pow(10, 8))),
+                        blockNumber: block.height,
+                        from: fromAddress,
+                        timestamp: timestamp,
+                        to: v.scriptPubKey.address || v.scriptPubKey.addresses?.[0],
+                        transactionGasFee: BigInt(tx.fee || 0) * BigInt(Math.pow(10, 8)),
+                        transactionHash: tx.txid,
+                        token: null,
+                        tokenType: "NATIVE"
+                    });
+                    break;
+                }
+                break;
+            case "CARDANO":
+                for (const tx of block.transactions){
+                    const typedTx = tx;
+                    if (!Array.isArray(typedTx.operations)) continue;
+                    const transactionHash = typedTx.transaction_identifier?.hash || "";
+                    const timestamp = typedTx.timestamp ? new Date(typedTx.timestamp).toISOString() : null;
+                    const inputs = typedTx.operations.filter((op)=>op.type === "input");
+                    const outputs = typedTx.operations.filter((op)=>op.type === "output");
+                    if (!inputs.length && !outputs.length) break;
+                    const fromAddress = inputs[0]?.account?.address;
+                    if (!fromAddress) continue;
+                    const sumInputs = inputs.reduce((acc, op)=>{
+                        const val = BigInt(op.amount?.value || "0");
+                        return acc + val;
+                    }, BigInt(0));
+                    const sumOutputs = outputs.reduce((acc, op)=>{
+                        const val = BigInt(op.amount?.value || "0");
+                        return acc + val;
+                    }, BigInt(0));
+                    const transactionFee = sumInputs + BigInt(sumOutputs);
+                    for (const out of outputs){
+                        const rawValue = out.amount?.value || "0";
+                        const absoluteValue = BigInt(rawValue);
+                        transfers.push({
+                            amount: absoluteValue < 0 ? -absoluteValue : absoluteValue,
+                            blockNumber: block.block_identifier.index,
+                            from: fromAddress,
+                            timestamp: timestamp,
+                            to: out.account?.address || "",
+                            token: out.amount?.currency?.symbol?.toUpperCase() === "ADA" ? null : out.amount?.currency?.symbol,
+                            tokenType: out.amount?.currency?.symbol?.toUpperCase() === "ADA" ? "NATIVE" : "TOKEN",
+                            transactionGasFee: transactionFee < 0 ? -transactionFee : transactionFee,
+                            transactionHash: transactionHash
+                        });
+                    }
+                }
+                break;
+            case "RIPPLE":
+                if (!Array.isArray(block.transactions)) break;
+                for (const rawTx of block.transactions){
+                    const typedTx = rawTx;
+                    if (typedTx.TransactionType !== "Payment") continue;
+                    const deliveredOrAmount = typedTx.metaData?.delivered_amount ?? typedTx.Amount ?? "0";
+                    let tokenSymbol = "XRP";
+                    let tokenType = "NATIVE";
+                    let parsedAmount;
+                    if (typeof deliveredOrAmount === "object") {
+                        tokenSymbol = deliveredOrAmount.currency?.toUpperCase() ?? "UNKNOWN";
+                        tokenType = "TOKEN";
+                        const floatVal = parseFloat(deliveredOrAmount.value);
+                        const smallestUnit = Math.round(floatVal * 1000000);
+                        parsedAmount = BigInt(smallestUnit);
+                    } else parsedAmount = BigInt(String(deliveredOrAmount));
+                    transfers.push({
+                        amount: parsedAmount,
+                        blockNumber: parseInt(block.ledger_index, 10),
+                        from: typedTx.Account ?? "UNKNOWN",
+                        timestamp: typedTx.date ? new Date((typedTx.date + 946684800) * 1000).toISOString() : null,
+                        to: typedTx.Destination ?? "UNKNOWN",
+                        token: tokenSymbol,
+                        tokenType: tokenType,
+                        transactionGasFee: BigInt(typedTx.Fee ?? "0"),
+                        transactionHash: typedTx.hash ?? ""
+                    });
+                }
+                break;
+            case "SOLANA":
+                for (const tx of block.transactions){
+                    const solanaTx = tx;
+                    const txHash = solanaTx.transaction.signatures[0];
+                    const timestamp = block.blockTime ? new Date(block.blockTime * 1000).toISOString() : null;
+                    let txFee = BigInt(solanaTx.meta.fee);
+                    if (txFee < BigInt(10)) txFee = txFee * BigInt(Math.pow(10, 9));
+                    const transfersByKey = {};
+                    for (const post of solanaTx.meta.postTokenBalances){
+                        let matched = false;
+                        for (const pre of solanaTx.meta.preTokenBalances)if (post.mint === pre.mint && post.owner === pre.owner) {
+                            let diff = BigInt(post.uiTokenAmount.amount) - BigInt(pre.uiTokenAmount.amount);
+                            if (diff === BigInt(0)) continue;
+                            if (diff < 0) diff = -diff;
+                            const key = `${post.mint}-${diff.toString()}`;
+                            const txfer = {
+                                amount: diff,
+                                blockNumber: block.blockHeight,
+                                from: pre.owner,
+                                timestamp: timestamp,
+                                to: post.owner,
+                                transactionGasFee: txFee,
+                                transactionHash: txHash,
+                                token: post.mint,
+                                tokenType: "TOKEN"
+                            };
+                            if (transfersByKey[key]) {
+                                if (diff > 0) delete txfer.from;
+                                else delete txfer.to;
+                            }
+                            transfersByKey[key] = Object.assign(transfersByKey[key] || {}, txfer);
+                            matched = true;
+                        }
+                        if (!matched) {
+                            let diff = BigInt(post.uiTokenAmount.amount);
+                            if (diff < 0) diff = -diff;
+                            const key = `${post.mint}-${diff.toString()}`;
+                            const txfer = {
+                                amount: diff,
+                                blockNumber: block.blockHeight,
+                                from: null,
+                                timestamp: timestamp,
+                                to: post.owner,
+                                token: post.mint,
+                                tokenType: "TOKEN",
+                                transactionGasFee: txFee,
+                                transactionHash: txHash
+                            };
+                            delete txfer.from;
+                            transfersByKey[key] = Object.assign(transfersByKey[key] || {}, txfer);
+                        }
+                    }
+                    for(let i = 1; i < solanaTx.meta.postBalances.length; i += 1){
+                        const post = solanaTx.meta.postBalances[i];
+                        const pre = solanaTx.meta.preBalances[i];
+                        if (post !== undefined && pre !== undefined && post !== pre) {
+                            let diff = BigInt(post) - BigInt(pre);
+                            if (diff < 0) diff = -diff;
+                            const key = `null-${diff.toString()}`;
+                            const txfer = {
+                                amount: diff,
+                                blockNumber: block.blockHeight,
+                                from: post > pre ? typeof solanaTx.transaction.message.accountKeys[0] === "string" ? solanaTx.transaction.message.accountKeys[0] : solanaTx.transaction.message.accountKeys[0]?.pubkey : typeof solanaTx.transaction.message.accountKeys[i] === "string" ? solanaTx.transaction.message.accountKeys[i] : solanaTx.transaction.message.accountKeys[i]?.pubkey,
+                                timestamp: timestamp,
+                                to: typeof solanaTx.transaction.message.accountKeys[i] === "string" ? solanaTx.transaction.message.accountKeys[i] : solanaTx.transaction.message.accountKeys[i]?.pubkey?.toString(),
+                                token: null,
+                                tokenType: "NATIVE",
+                                transactionGasFee: txFee,
+                                transactionHash: txHash
+                            };
+                            if (transfersByKey[key]) {
+                                if (post > pre) delete txfer.from;
+                                else delete txfer.to;
+                            }
+                            transfersByKey[key] = Object.assign(transfersByKey[key] || {}, txfer);
+                        }
+                    }
+                    transfers.push(...Object.values(transfersByKey));
+                }
+                break;
+            case "STARKNET":
+                if (!Array.isArray(block.transactions)) break;
+                for (const tx of block.transactions){
+                    const typedTx = tx;
+                    const timestamp = block.timestamp ? new Date(block.timestamp * 1000).toISOString() : null;
+                    let transactionGasFee = BigInt(0);
+                    if (typedTx?.receipt?.actual_fee?.amount) transactionGasFee = BigInt(typedTx.receipt.actual_fee.amount);
+                    const transactionHash = typedTx.transaction_hash;
+                    if (!typedTx.receipt?.events) continue;
+                    for (const event of typedTx.receipt.events){
+                        if (!event.keys.includes("0x99cd8bde557814842a3121e8ddfd433a539b8c9f14bf31ebf108d12e6196e9")) continue;
+                        if (event.data.length < 3) continue;
+                        const [from, to, amountHex] = event.data;
+                        const amount = BigInt(amountHex);
+                        transfers.push({
+                            amount: amount,
+                            blockNumber: block.block_number,
+                            from: from,
+                            timestamp: timestamp,
+                            to: to,
+                            token: null,
+                            tokenType: "NATIVE",
+                            transactionGasFee: transactionGasFee,
+                            transactionHash: transactionHash
+                        });
+                    }
+                }
+                break;
+            case "STELLAR":
+                for (const tx of block.transactions){
+                    const typedTx = tx;
+                    for (const op of typedTx.operations)if (op.type === "payment") transfers.push({
+                        amount: BigInt(op.amount.replace(".", "")),
+                        blockNumber: block.sequence,
+                        from: op.from,
+                        timestamp: typedTx.created_at,
+                        to: op.to,
+                        token: op.asset_type === "native" ? null : op.asset_issuer,
+                        tokenType: op.asset_type === "native" ? "NATIVE" : "TOKEN",
+                        transactionGasFee: BigInt(typedTx.fee_charged),
+                        transactionHash: typedTx.hash
+                    });
+                }
+                break;
+            case "SUI":
+                {
+                    const blockNumber = block.sequence;
+                    const blockTimestamp = new Date(block.timestamp).toISOString();
+                    for (const tx of block.transactions || []){
+                        const transactionHash = tx.digest;
+                        const transactionGasFee = BigInt(tx.gasFee || "0");
+                        for (const bc of tx.balanceChanges || [])transfers.push({
+                            blockNumber: blockNumber,
+                            from: tx.sender ? tx.sender : undefined,
+                            to: tx.receiver ? tx.receiver : undefined,
+                            amount: BigInt(bc.amount),
+                            token: bc.coinRepr,
+                            tokenType: "NATIVE",
+                            timestamp: blockTimestamp,
+                            transactionHash: transactionHash,
+                            transactionGasFee: transactionGasFee
+                        });
+                    }
+                    break;
+                }
+            case "TON":
+                {
+                    const blockNumber = block.seqno;
+                    const blockTimestamp = new Date(block.shards?.[0]?.gen_utime * 1000).toISOString();
+                    for (const shard of block.shards || [])for (const tx of shard.transactions || []){
+                        const transactionLT = tx.transaction_id.lt;
+                        const transactionHash = tx.transaction_id.hash;
+                        const transactionFee = BigInt(tx.fee || "0");
+                        const inVal = BigInt(tx.in_msg?.value || "0");
+                        if (inVal > 0n) transfers.push({
+                            blockNumber: blockNumber,
+                            from: tx.in_msg?.source?.account_address,
+                            to: tx.address?.account_address,
+                            amount: inVal,
+                            token: "TON",
+                            tokenType: "NATIVE",
+                            timestamp: blockTimestamp,
+                            transactionHash: transactionHash,
+                            transactionGasFee: transactionFee
+                        });
+                        for (const outMsg of tx.out_msgs || []){
+                            const outVal = BigInt(outMsg.value || "0");
+                            if (outVal > 0n) transfers.push({
+                                blockNumber: blockNumber,
+                                from: outMsg.source?.account_address,
+                                to: outMsg.destination?.account_address,
+                                amount: outVal,
+                                token: "TON",
+                                tokenType: "NATIVE",
+                                timestamp: blockTimestamp,
+                                transactionHash: transactionHash,
+                                transactionGasFee: transactionFee
+                            });
+                        }
+                    }
+                    break;
+                }
+            // attempt to introspect data types
             default:
+                // @TODO: COSMOS
+                // otherwise assume EVM
                 for (const tx of block.transactions){
                     if (!tx.receipt) continue;
                     const timestamp = new Date(block.timestamp * 1000).toISOString();
@@ -375,7 +684,6 @@ const $6144a02851f23907$var$tokenTransfersTemplate = {
                             transactionHash: tx.hash
                         });
                     }
-                    // @TODO: add NFT transfers
                     if (!TOKEN_TYPES.length || TOKEN_TYPES.includes("NFT")) for (const log of tx.receipt.logs){
                         const txfer = (0, $da55be3e40667945$export$cf548b70626e2eb9)(log, [
                             "Transfer(address indexed from, address indexed to, uint256 indexed value)",
@@ -436,9 +744,10 @@ const $6144a02851f23907$var$tokenTransfersTemplate = {
                 if (typeof _ctx.params.walletAddress === "string") _ctx.params.walletAddress = _ctx.params.walletAddress.toLowerCase();
                 break;
         }
+        //console.log(transfers[0]);
         transfers = transfers.filter((txfer)=>{
             if (txfer.amount <= BigInt(0)) return false;
-            if (_ctx.params.contractAddress && _ctx.params.contractAddress !== txfer.token) return false;
+            if (_ctx.params.contractAddress && _ctx.params.contractAddress !== txfer.token && txfer.token) return false;
             if (_ctx.params.walletAddress && ![
                 txfer.from,
                 txfer.to
@@ -448,6 +757,29 @@ const $6144a02851f23907$var$tokenTransfersTemplate = {
         return transfers;
     },
     tests: [
+        // APTOS
+        {
+            params: {
+                network: "APTOS",
+                walletAddress: "0xb3589951a7d8579a2918a749260804047abc60438bf0738c4e67683e972b41cd",
+                contractAddress: "0x1"
+            },
+            payload: "https://jiti.indexing.co/networks/aptos/237372198",
+            output: [
+                {
+                    amount: 12776498n,
+                    blockNumber: 237372198,
+                    from: "0xb3589951a7d8579a2918a749260804047abc60438bf0738c4e67683e972b41cd",
+                    timestamp: "2024-10-10T16:59:34.414Z",
+                    to: "0x1f5d15c9a1330389bda239ed2f40d8d2a2ba446e7a48ee57483a047d5ed1aafe",
+                    token: null,
+                    tokenType: "NATIVE",
+                    transactionGasFee: 507n,
+                    transactionHash: "0xbabaf20c07c80ace9f1f2f6539e0df6c57c9a6b24d5e62fa4989b46c0807d9bb"
+                }
+            ]
+        },
+        // BASE
         {
             params: {
                 network: "BASE",
@@ -469,6 +801,160 @@ const $6144a02851f23907$var$tokenTransfersTemplate = {
                     transactionHash: "0x69c9b12ccbe2d4f2f1dfc7c4a8557fc099fc5df276424417815acbc79a06fd56"
                 }
             ]
+        },
+        // DOGECOIN
+        {
+            params: {
+                network: "DOGECOIN",
+                walletAddress: "DMqRVLrhbam3Kcfddpxd6EYvEBbpi3bEpP",
+                contractAddress: ""
+            },
+            payload: "https://jiti.indexing.co/networks/dogecoin/1000075",
+            output: [
+                {
+                    amount: 1008521000000n,
+                    blockNumber: 1000075,
+                    from: "DMqRVLrhbam3Kcfddpxd6EYvEBbpi3bEpP",
+                    to: "DMqRVLrhbam3Kcfddpxd6EYvEBbpi3bEpP",
+                    token: null,
+                    tokenType: "NATIVE",
+                    transactionGasFee: 0n,
+                    transactionHash: "9873fe46ab29f61cefdec498b691af68e0ad29a7599c94f42d2d4e9a5d461dbe",
+                    timestamp: "2015-12-13T19:59:52.000Z"
+                }
+            ]
+        },
+        // CARDANO
+        {
+            params: {
+                network: "CARDANO",
+                walletAddress: "addr1q9syxu908lef7r6rsvk0h7gsx3rxj22cuykgx2a2l4hcfd8e9y2e9vtv4w9dyej96w99wwj8hwgc273862lk6a3vt30qjjrund",
+                contractAddress: ""
+            },
+            payload: "https://jiti.indexing.co/networks/cardano/11443286",
+            output: [
+                {
+                    amount: 1110000n,
+                    blockNumber: 11443286,
+                    from: "addr1qymdv285few5tyqvya86rl97r9e608njs37shfew6l2nn473aw2pcnrcvfwfgg2dnew99m4tjj0apsu7232w2euzwpysndh0h3",
+                    timestamp: null,
+                    to: "addr1q9syxu908lef7r6rsvk0h7gsx3rxj22cuykgx2a2l4hcfd8e9y2e9vtv4w9dyej96w99wwj8hwgc273862lk6a3vt30qjjrund",
+                    token: null,
+                    tokenType: "NATIVE",
+                    transactionGasFee: 174257n,
+                    transactionHash: "261c42ba9124f55d8e169ebb692cd3759d796a54369acb316ee449b546e79309"
+                }
+            ]
+        },
+        // RIPPLE
+        {
+            params: {
+                network: "RIPPLE",
+                walletAddress: "rUUgoiJmjTPEbxfZ4RsS9pVS9Kv813Wpui",
+                contractAddress: ""
+            },
+            payload: "https://jiti.indexing.co/networks/ripple/88104659",
+            output: [
+                {
+                    amount: 238n,
+                    blockNumber: 88104659,
+                    from: "rMAGnTv4eMWktZnhKa5cHcDiY84ZiKUaQm",
+                    timestamp: null,
+                    to: "rUUgoiJmjTPEbxfZ4RsS9pVS9Kv813Wpui",
+                    token: "XRP",
+                    tokenType: "NATIVE",
+                    transactionGasFee: 15n,
+                    transactionHash: "03564E6109261CDE73FCC5062C2A0A70F365CB1A0F9408C065B60EC3E94E4DBF"
+                }
+            ]
+        },
+        // STELLAR
+        {
+            params: {
+                network: "STELLAR",
+                walletAddress: "GA5KLTNAWV27IOTBX5PKUOMVWFMLX4X7CPMQJ4QLR3G266MMVL7NMA4X",
+                contractAddress: "GC4Z2TDXU4GXVLHOS5P5SU6HKBCP7NKN4TJ5ZGTVRBW7MCBZTU7SNUSA"
+            },
+            payload: "https://jiti.indexing.co/networks/stellar/51720546",
+            output: [
+                {
+                    amount: 150000n,
+                    blockNumber: 51720546,
+                    from: "GA5KLTNAWV27IOTBX5PKUOMVWFMLX4X7CPMQJ4QLR3G266MMVL7NMA4X",
+                    timestamp: "2024-05-18T04:41:39Z",
+                    to: "GC4Z2TDXU4GXVLHOS5P5SU6HKBCP7NKN4TJ5ZGTVRBW7MCBZTU7SNUSA",
+                    token: "GC4Z2TDXU4GXVLHOS5P5SU6HKBCP7NKN4TJ5ZGTVRBW7MCBZTU7SNUSA",
+                    tokenType: "TOKEN",
+                    transactionGasFee: 100n,
+                    transactionHash: "4fb2441210cbe87f5003abdfa86f03bafa54f789ed041feccbda0bd054297c4d"
+                }
+            ]
+        },
+        // STARKNET
+        {
+            params: {
+                network: "STARKNET",
+                walletAddress: "0x309e6b209031362268d62d646a067365e6f6d6eb7f571b5212cbdfd5f26fe54",
+                contractAddress: ""
+            },
+            payload: "https://jiti.indexing.co/networks/starknet/1149460",
+            output: [
+                {
+                    amount: 0x1c286f74458fc6n,
+                    blockNumber: 1149460,
+                    from: "0x309e6b209031362268d62d646a067365e6f6d6eb7f571b5212cbdfd5f26fe54",
+                    timestamp: "2025-02-13T17:36:52.000Z",
+                    to: "0x1176a1bd84444c89232ec27754698e5d2e7e1a7f1539f12027f28b23ec9f3d8",
+                    token: null,
+                    tokenType: "NATIVE",
+                    transactionGasFee: 7925758505095110n,
+                    transactionHash: "0x707203dba31f442ae9a5477e6a8906f3676effa0f1d3bb19cbbc14e1ddfe21"
+                }
+            ]
+        },
+        //SUI
+        {
+            params: {
+                network: "SUI",
+                walletAddress: "0xfd0fb434d076e4cca300cf6534a5235b19ad184eedf49066726664ded42c6b5e",
+                contractAddress: ""
+            },
+            payload: "https://jiti.indexing.co/networks/sui/112336044",
+            output: [
+                {
+                    blockNumber: 112336044,
+                    from: "0xfd0fb434d076e4cca300cf6534a5235b19ad184eedf49066726664ded42c6b5e",
+                    to: undefined,
+                    amount: 180772n,
+                    token: "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI",
+                    tokenType: "NATIVE",
+                    timestamp: "2025-02-13T23:10:54.529Z",
+                    transactionHash: "336V3wP8cHDAnB1Aku3j6n9948i8FG5N1eVP6Ac68BaE",
+                    transactionGasFee: -4165572n
+                }
+            ]
+        },
+        // TON
+        {
+            params: {
+                network: "TON",
+                walletAddress: "EQAFukUyzmHjUvOYDOjNE-wbZFFl2FWas1rFJoh8IiTsWD40",
+                contractAddress: ""
+            },
+            payload: "https://jiti.indexing.co/networks/ton/44919328",
+            output: [
+                {
+                    blockNumber: 44919328,
+                    from: "EQAFukUyzmHjUvOYDOjNE-wbZFFl2FWas1rFJoh8IiTsWD40",
+                    to: "EQCFTFAHOU3vFt2NiZhRD5dwuS0k7GS59vIg3WfCKwfaQGW2",
+                    amount: 10000000n,
+                    token: "TON",
+                    tokenType: "NATIVE",
+                    timestamp: "2025-02-13T23:10:18.000Z",
+                    transactionHash: "Vh5cWr2uvCsdhoouBQ+EiUcF54os9oqvh8A/62EroQc=",
+                    transactionGasFee: 2355233n
+                }
+            ]
         }
     ]
 };