763 lines
24 KiB
JavaScript
763 lines
24 KiB
JavaScript
const suiBlockchainAPI = {
|
|
// Get Balance
|
|
async getBalance(address, coinType = "0x2::sui::SUI") {
|
|
const res = await fetch("https://fullnode.mainnet.sui.io:443", {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify({
|
|
jsonrpc: "2.0",
|
|
id: 1,
|
|
method: "suix_getBalance",
|
|
params: [address, coinType],
|
|
}),
|
|
});
|
|
const json = await res.json();
|
|
return json?.result?.totalBalance || 0;
|
|
},
|
|
// Get Transaction History
|
|
async getTransactionHistory(address, page = 1, limit = 10) {
|
|
const SUI_RPC_URL = "https://fullnode.mainnet.sui.io:443";
|
|
|
|
try {
|
|
const requiredTransactions = page * limit;
|
|
const smartBatchSize = requiredTransactions + 20;
|
|
console.log(
|
|
`Page ${page}: Smart batching - need ${requiredTransactions}, fetching ${smartBatchSize}`
|
|
);
|
|
|
|
// Get both sent (FromAddress) and received (ToAddress) transactions
|
|
let allFromDigests = [];
|
|
let allToDigests = [];
|
|
let fromCursor = null;
|
|
let toCursor = null;
|
|
let fromHasMore = true;
|
|
let toHasMore = true;
|
|
|
|
// Keep a set of unique digests while fetching.
|
|
const uniqueDigestSet = new Set();
|
|
const digestToTimestamp = new Map(); // Store timestamps from queryTransactionBlocks
|
|
let safetyCounter = 0;
|
|
const MAX_FETCH_ROUNDS = 10;
|
|
|
|
while (
|
|
(fromHasMore || toHasMore) &&
|
|
uniqueDigestSet.size < smartBatchSize &&
|
|
safetyCounter < MAX_FETCH_ROUNDS
|
|
) {
|
|
safetyCounter++;
|
|
const requests = [];
|
|
|
|
if (fromHasMore) {
|
|
requests.push(
|
|
fetch(SUI_RPC_URL, {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify({
|
|
jsonrpc: "2.0",
|
|
id: 1,
|
|
method: "suix_queryTransactionBlocks",
|
|
params: [
|
|
{
|
|
filter: { FromAddress: address },
|
|
options: { showInput: true, showEffects: true },
|
|
},
|
|
fromCursor,
|
|
Math.min(25, smartBatchSize - allFromDigests.length),
|
|
true,
|
|
],
|
|
}),
|
|
})
|
|
);
|
|
}
|
|
|
|
// Fetch TO transactions if we still have more
|
|
if (toHasMore) {
|
|
requests.push(
|
|
fetch(SUI_RPC_URL, {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify({
|
|
jsonrpc: "2.0",
|
|
id: 2,
|
|
method: "suix_queryTransactionBlocks",
|
|
params: [
|
|
{
|
|
filter: { ToAddress: address },
|
|
options: { showInput: true, showEffects: true },
|
|
},
|
|
toCursor,
|
|
Math.min(25, smartBatchSize - allToDigests.length),
|
|
true,
|
|
],
|
|
}),
|
|
})
|
|
);
|
|
}
|
|
|
|
const responses = await Promise.all(requests);
|
|
let responseIndex = 0;
|
|
|
|
// Process FROM response
|
|
if (fromHasMore && responses[responseIndex]) {
|
|
const fromJson = await responses[responseIndex].json();
|
|
responseIndex++;
|
|
const newFromDigests =
|
|
fromJson.result?.data?.map((d) => d.digest) || [];
|
|
allFromDigests.push(...newFromDigests);
|
|
|
|
// Store timestamps from queryTransactionBlocks
|
|
fromJson.result?.data?.forEach((tx) => {
|
|
if (tx.digest && tx.timestampMs) {
|
|
digestToTimestamp.set(tx.digest, Number(tx.timestampMs));
|
|
}
|
|
});
|
|
|
|
// Add to unique set
|
|
newFromDigests.forEach((dg) => uniqueDigestSet.add(dg));
|
|
fromCursor = fromJson.result?.nextCursor;
|
|
fromHasMore =
|
|
!!fromJson.result?.hasNextPage && newFromDigests.length > 0;
|
|
console.log(
|
|
`Page ${page}: FROM batch - got ${newFromDigests.length}, total ${allFromDigests.length}, unique ${uniqueDigestSet.size}, hasMore: ${fromHasMore}`
|
|
);
|
|
}
|
|
|
|
// Process TO response
|
|
if (toHasMore && responses[responseIndex]) {
|
|
const toJson = await responses[responseIndex].json();
|
|
const newToDigests = toJson.result?.data?.map((d) => d.digest) || [];
|
|
allToDigests.push(...newToDigests);
|
|
|
|
// Store timestamps from queryTransactionBlocks
|
|
toJson.result?.data?.forEach((tx) => {
|
|
if (tx.digest && tx.timestampMs) {
|
|
digestToTimestamp.set(tx.digest, Number(tx.timestampMs));
|
|
}
|
|
});
|
|
|
|
// Add to unique set
|
|
newToDigests.forEach((dg) => uniqueDigestSet.add(dg));
|
|
toCursor = toJson.result?.nextCursor;
|
|
toHasMore = !!toJson.result?.hasNextPage && newToDigests.length > 0;
|
|
console.log(
|
|
`Page ${page}: TO batch - got ${newToDigests.length}, total ${allToDigests.length}, unique ${uniqueDigestSet.size}, hasMore: ${toHasMore}`
|
|
);
|
|
}
|
|
|
|
if (requests.length === 0) break;
|
|
}
|
|
|
|
console.log(
|
|
`Page ${page}: Final totals - FROM=${allFromDigests.length}, TO=${allToDigests.length} digests`
|
|
);
|
|
// Use the unique set as the deduplicated result
|
|
const uniqueDigests = [...uniqueDigestSet];
|
|
|
|
const mightHaveMorePages = fromHasMore || toHasMore;
|
|
console.log(
|
|
`Page ${page}: HasNextPage - FROM: ${fromHasMore}, TO: ${toHasMore}`
|
|
);
|
|
|
|
let digests = uniqueDigests;
|
|
console.log(
|
|
`Page ${page}: Got ${digests.length} unique digests from API`
|
|
);
|
|
|
|
const neededForPage = page * limit;
|
|
|
|
// Fetch ALL transaction details first, then sort globally by timestamp
|
|
console.log(
|
|
`Page ${page}: Fetching details for ALL ${digests.length} transactions for global time-sort`
|
|
);
|
|
|
|
// Convert Set to Array for processing
|
|
const allUniqueDigests = Array.from(uniqueDigestSet);
|
|
const allDetails = [];
|
|
const BATCH_SIZE = 20;
|
|
|
|
// Fetch transaction details for ALL unique digests
|
|
for (let i = 0; i < allUniqueDigests.length; i += BATCH_SIZE) {
|
|
const batch = allUniqueDigests.slice(i, i + BATCH_SIZE);
|
|
console.log(
|
|
`Page ${page}: Processing batch ${Math.floor(i / BATCH_SIZE) + 1}: ${
|
|
batch.length
|
|
} transactions`
|
|
);
|
|
|
|
try {
|
|
// Use sui_multiGetTransactionBlocks
|
|
const batchRes = await fetch(SUI_RPC_URL, {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify({
|
|
jsonrpc: "2.0",
|
|
id: 1,
|
|
method: "sui_multiGetTransactionBlocks",
|
|
params: [
|
|
batch, // Array of digests
|
|
{
|
|
showInput: true,
|
|
showRawInput: false,
|
|
showEffects: true,
|
|
showEvents: true,
|
|
showObjectChanges: false,
|
|
showBalanceChanges: true,
|
|
},
|
|
],
|
|
}),
|
|
});
|
|
|
|
if (!batchRes.ok) {
|
|
console.warn(`HTTP ${batchRes.status} for batch starting at ${i}`);
|
|
continue;
|
|
}
|
|
|
|
const batchJson = await batchRes.json();
|
|
|
|
if (batchJson.error) {
|
|
console.warn(`Batch API error:`, batchJson.error);
|
|
continue;
|
|
}
|
|
|
|
// Filter out null results and add missing timestamps
|
|
const validResults = batchJson.result.filter(Boolean);
|
|
|
|
// Ensure every transaction has a timestamp
|
|
validResults.forEach((tx) => {
|
|
if (!tx.timestampMs && digestToTimestamp.has(tx.digest)) {
|
|
tx.timestampMs = digestToTimestamp.get(tx.digest);
|
|
}
|
|
});
|
|
|
|
allDetails.push(...validResults);
|
|
|
|
console.log(
|
|
`Page ${page}: Batch ${Math.floor(i / BATCH_SIZE) + 1}: Got ${
|
|
validResults.length
|
|
}/${batch.length} valid transactions`
|
|
);
|
|
} catch (error) {
|
|
console.error(`Batch fetch error for batch starting at ${i}:`, error);
|
|
}
|
|
|
|
if (i + BATCH_SIZE < allUniqueDigests.length) {
|
|
await new Promise((resolve) => setTimeout(resolve, 100));
|
|
}
|
|
}
|
|
|
|
console.log(
|
|
`Page ${page}: Fetched ${allDetails.length} total transaction details`
|
|
);
|
|
|
|
allDetails.sort((a, b) => {
|
|
const t1 = Number(a.timestampMs || 0);
|
|
const t2 = Number(b.timestampMs || 0);
|
|
return t2 - t1; // Newest first
|
|
});
|
|
|
|
console.log(
|
|
`Page ${page}: Globally sorted ${allDetails.length} transactions by timestamp`
|
|
);
|
|
|
|
const startIndex = (page - 1) * limit;
|
|
const endIndex = page * limit;
|
|
const validDetails = allDetails.slice(startIndex, endIndex);
|
|
|
|
console.log(
|
|
`Page ${page}: Showing ${validDetails.length} transactions for this page`
|
|
);
|
|
|
|
|
|
if (validDetails.length === 0 && page > 1) {
|
|
console.warn(`Page ${page}: No transactions available for this page`);
|
|
return {
|
|
txs: [],
|
|
hasNextPage: false,
|
|
nextCursor: {
|
|
from: fromCursor,
|
|
to: toCursor,
|
|
fromHasMore,
|
|
toHasMore,
|
|
},
|
|
};
|
|
}
|
|
|
|
console.log(
|
|
`Page ${page}: Returning ${validDetails.length} transactions (globally sorted)`
|
|
);
|
|
|
|
|
|
const totalAvailableTransactions = allDetails.length;
|
|
const hasNextPage =
|
|
endIndex < totalAvailableTransactions || mightHaveMorePages;
|
|
console.log(
|
|
`Page ${page}: hasNextPage = ${hasNextPage} (total: ${totalAvailableTransactions}, endIndex: ${endIndex}, mightHaveMorePages: ${mightHaveMorePages})`
|
|
);
|
|
|
|
// Transform to the expected format
|
|
const transactions = validDetails.map((tx) => {
|
|
const from = tx.transaction?.data?.sender || "Unknown";
|
|
const balanceChanges = tx.balanceChanges || [];
|
|
const status = tx.effects?.status?.status || "unknown";
|
|
|
|
let to = "Unknown";
|
|
let amountRaw = 0;
|
|
let coinType = "0x2::sui::SUI"; // Default to SUI
|
|
|
|
let maxChangeAmount = 0;
|
|
for (const change of balanceChanges) {
|
|
const changeAmount = Math.abs(Number(change.amount || 0));
|
|
const changeOwner = change.owner?.AddressOwner;
|
|
const changeCoinType = change.coinType || "0x2::sui::SUI";
|
|
|
|
if (
|
|
changeOwner &&
|
|
changeOwner.toLowerCase() !== from.toLowerCase() &&
|
|
changeAmount > maxChangeAmount
|
|
) {
|
|
to = changeOwner;
|
|
amountRaw = changeAmount;
|
|
coinType = changeCoinType;
|
|
maxChangeAmount = changeAmount;
|
|
}
|
|
}
|
|
|
|
if (to === "Unknown" || amountRaw === 0) {
|
|
const inputs = tx.transaction?.data?.transaction?.inputs || [];
|
|
|
|
// Find the address input (recipient)
|
|
const addressInput = inputs.find(
|
|
(input) => input.type === "pure" && input.valueType === "address"
|
|
);
|
|
|
|
// Find the amount input
|
|
const amountInput = inputs.find(
|
|
(input) => input.type === "pure" && input.valueType === "u64"
|
|
);
|
|
|
|
if (addressInput && to === "Unknown") {
|
|
to = addressInput.value;
|
|
}
|
|
|
|
if (amountInput && amountRaw === 0) {
|
|
amountRaw = parseInt(amountInput.value);
|
|
}
|
|
}
|
|
|
|
if (amountRaw === 0) {
|
|
const senderChange = balanceChanges.find(
|
|
(change) =>
|
|
change.owner?.AddressOwner?.toLowerCase() === from.toLowerCase()
|
|
);
|
|
if (senderChange) {
|
|
const totalChange = Math.abs(Number(senderChange.amount || 0));
|
|
const gasEstimate = 1500000;
|
|
if (totalChange > gasEstimate * 2) {
|
|
amountRaw = totalChange - gasEstimate;
|
|
} else if (status !== "success") {
|
|
// For failed transactions
|
|
amountRaw = totalChange;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
const datetime = tx.timestampMs
|
|
? new Date(Number(tx.timestampMs)).toLocaleString()
|
|
: "N/A";
|
|
const timestamp = Number(tx.timestampMs || 0);
|
|
|
|
// Determine direction
|
|
let direction = "Other";
|
|
|
|
// Direct check for self-transfer (same from and to address)
|
|
if (
|
|
from.toLowerCase() === address.toLowerCase() &&
|
|
to.toLowerCase() === address.toLowerCase()
|
|
) {
|
|
direction = "Self";
|
|
} else {
|
|
// Check balance changes to determine if this address gained or lost value
|
|
for (const change of balanceChanges) {
|
|
if (
|
|
change.owner?.AddressOwner?.toLowerCase() ===
|
|
address.toLowerCase()
|
|
) {
|
|
const changeAmount = Number(change.amount || 0);
|
|
if (changeAmount > 0) {
|
|
direction = "Received";
|
|
} else if (changeAmount < 0) {
|
|
const hasPositiveChange = balanceChanges.some(
|
|
(c) =>
|
|
c.owner?.AddressOwner?.toLowerCase() ===
|
|
address.toLowerCase() && Number(c.amount || 0) > 0
|
|
);
|
|
direction = hasPositiveChange ? "Self" : "Sent";
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (direction === "Other") {
|
|
if (from.toLowerCase() === address.toLowerCase()) {
|
|
direction =
|
|
to.toLowerCase() === address.toLowerCase() ? "Self" : "Sent";
|
|
} else if (to.toLowerCase() === address.toLowerCase()) {
|
|
direction = "Received";
|
|
}
|
|
}
|
|
}
|
|
|
|
// Format status
|
|
const statusText =
|
|
status === "success"
|
|
? "Confirmed"
|
|
: status === "failure"
|
|
? "Failed"
|
|
: status.charAt(0).toUpperCase() + status.slice(1);
|
|
|
|
// Get error message if failed
|
|
const errorMessage =
|
|
status === "failure"
|
|
? tx?.effects?.status?.error || "Transaction failed"
|
|
: null;
|
|
|
|
|
|
let decimals = 1e9;
|
|
let symbol = "SUI";
|
|
|
|
if (coinType) {
|
|
if (coinType.includes("usdc") || coinType.includes("USDC")) {
|
|
decimals = 1e6;
|
|
symbol = "USDC";
|
|
} else if (coinType === "0x2::sui::SUI") {
|
|
decimals = 1e9;
|
|
symbol = "SUI";
|
|
}
|
|
|
|
}
|
|
|
|
const amountFormatted = (amountRaw / decimals).toFixed(6);
|
|
|
|
return {
|
|
digest: tx.digest,
|
|
from,
|
|
to,
|
|
amount: amountFormatted,
|
|
amountRaw,
|
|
coinType: coinType || "0x2::sui::SUI",
|
|
symbol: symbol,
|
|
datetime,
|
|
timestamp,
|
|
direction,
|
|
status: statusText,
|
|
rawStatus: status,
|
|
errorMessage,
|
|
};
|
|
});
|
|
|
|
return {
|
|
txs: transactions,
|
|
hasNextPage,
|
|
nextCursor: {
|
|
from: fromCursor,
|
|
to: toCursor,
|
|
fromHasMore,
|
|
toHasMore,
|
|
},
|
|
};
|
|
} catch (e) {
|
|
console.error("Error fetching transaction history:", e);
|
|
return {
|
|
txs: [],
|
|
hasNextPage: false,
|
|
nextCursor: null,
|
|
};
|
|
}
|
|
},
|
|
|
|
// SUI Transaction
|
|
async prepareSuiTransaction(privateKey, recipientAddress, amount) {
|
|
const SUI_RPC_URL = "https://fullnode.mainnet.sui.io:443";
|
|
|
|
if (!privateKey || !recipientAddress || !amount)
|
|
throw new Error("Missing required parameters.");
|
|
|
|
const amt = parseFloat(amount);
|
|
if (isNaN(amt) || amt <= 0) throw new Error("Invalid amount specified.");
|
|
|
|
// Get sender's address and private key from any supported format
|
|
const wallet = await suiCrypto.generateMultiChain(privateKey);
|
|
const senderAddress = wallet.SUI.address;
|
|
const suiPrivateKey = wallet.SUI.privateKey;
|
|
|
|
// Get sender coins
|
|
const coinResponse = await fetch(SUI_RPC_URL, {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify({
|
|
jsonrpc: "2.0",
|
|
id: 1,
|
|
method: "suix_getCoins",
|
|
params: [senderAddress, "0x2::sui::SUI"],
|
|
}),
|
|
});
|
|
const coinJson = await coinResponse.json();
|
|
if (coinJson.error) throw new Error(coinJson.error.message);
|
|
const coins = coinJson.result.data;
|
|
if (!coins.length) throw new Error("No SUI balance found.");
|
|
|
|
const amountInMist = Math.floor(amt * 1e9).toString();
|
|
|
|
const txResponse = await fetch(SUI_RPC_URL, {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify({
|
|
jsonrpc: "2.0",
|
|
id: 1,
|
|
method: "unsafe_paySui",
|
|
params: [
|
|
senderAddress,
|
|
[coins[0].coinObjectId],
|
|
[recipientAddress],
|
|
[amountInMist],
|
|
"50000000",
|
|
],
|
|
}),
|
|
});
|
|
const txJson = await txResponse.json();
|
|
|
|
if (txJson.error) throw new Error(`Build failed: ${txJson.error.message}`);
|
|
const txBytes = txJson.result.txBytes;
|
|
|
|
// Simulate for gas estimate
|
|
const dryRunResponse = await fetch(SUI_RPC_URL, {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify({
|
|
jsonrpc: "2.0",
|
|
id: 1,
|
|
method: "sui_dryRunTransactionBlock",
|
|
params: [txBytes],
|
|
}),
|
|
});
|
|
const dryRunJson = await dryRunResponse.json();
|
|
if (dryRunJson.error)
|
|
throw new Error(`Dry run failed: ${dryRunJson.error.message}`);
|
|
|
|
const gasUsed = dryRunJson.result.effects.gasUsed;
|
|
const gasFee =
|
|
parseInt(gasUsed.computationCost) +
|
|
parseInt(gasUsed.storageCost) -
|
|
parseInt(gasUsed.storageRebate);
|
|
|
|
return {
|
|
senderAddress,
|
|
suiPrivateKey,
|
|
txBytes,
|
|
gasFee: gasFee,
|
|
};
|
|
},
|
|
|
|
// Sign and Send SUI Transaction
|
|
async signAndSendSuiTransaction(preparedTx) {
|
|
const SUI_RPC_URL = "https://fullnode.mainnet.sui.io:443";
|
|
|
|
// Sign the transaction bytes
|
|
const signature = await suiCrypto.sign(
|
|
preparedTx.txBytes,
|
|
preparedTx.suiPrivateKey
|
|
);
|
|
|
|
// Execute the transaction
|
|
const response = await fetch(SUI_RPC_URL, {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify({
|
|
jsonrpc: "2.0",
|
|
id: 1,
|
|
method: "sui_executeTransactionBlock",
|
|
params: [
|
|
preparedTx.txBytes,
|
|
[signature],
|
|
null,
|
|
"WaitForLocalExecution",
|
|
],
|
|
}),
|
|
});
|
|
|
|
const result = await response.json();
|
|
if (result.error) throw new Error(result.error.message);
|
|
return result;
|
|
},
|
|
|
|
// Get Transaction Details by Hash
|
|
async getTransactionDetails(transactionHash) {
|
|
const SUI_RPC_URL = "https://fullnode.mainnet.sui.io:443";
|
|
|
|
if (!transactionHash) {
|
|
throw new Error("Transaction hash is required");
|
|
}
|
|
|
|
try {
|
|
const res = await fetch(SUI_RPC_URL, {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify({
|
|
jsonrpc: "2.0",
|
|
id: 1,
|
|
method: "sui_getTransactionBlock",
|
|
params: [
|
|
transactionHash,
|
|
{
|
|
showInput: true,
|
|
showEffects: true,
|
|
showEvents: true,
|
|
showBalanceChanges: true,
|
|
showObjectChanges: true,
|
|
},
|
|
],
|
|
}),
|
|
});
|
|
|
|
const json = await res.json();
|
|
|
|
if (json.error) {
|
|
throw new Error(json.error.message);
|
|
}
|
|
|
|
const txData = json.result;
|
|
if (!txData) {
|
|
throw new Error("Transaction not found");
|
|
}
|
|
|
|
// Extract transaction details
|
|
const digest = txData.digest;
|
|
const sender = txData.transaction?.data?.sender || "Unknown";
|
|
const gasUsed = txData.effects?.gasUsed;
|
|
const status = txData.effects?.status?.status || "Unknown";
|
|
const timestamp = txData.timestampMs
|
|
? new Date(Number(txData.timestampMs)).toLocaleString()
|
|
: "N/A";
|
|
|
|
// Extract transfer information
|
|
let recipient = "Unknown";
|
|
let amount = 0;
|
|
let coinType = "0x2::sui::SUI";
|
|
|
|
// First, try to get recipient and amount from transaction inputs (works for all transactions)
|
|
const inputs = txData.transaction?.data?.transaction?.inputs || [];
|
|
|
|
// Find the address input (recipient)
|
|
const addressInput = inputs.find(
|
|
(input) => input.type === "pure" && input.valueType === "address"
|
|
);
|
|
|
|
// Find the amount input
|
|
const amountInput = inputs.find(
|
|
(input) => input.type === "pure" && input.valueType === "u64"
|
|
);
|
|
|
|
if (addressInput) {
|
|
recipient = addressInput.value;
|
|
}
|
|
|
|
if (amountInput) {
|
|
amount = parseInt(amountInput.value);
|
|
}
|
|
|
|
if (status === "success" && (recipient === "Unknown" || amount === 0)) {
|
|
// Check events for transfer information
|
|
for (const event of txData.events || []) {
|
|
if (
|
|
event.type?.includes("TransferEvent") ||
|
|
event.type?.includes("::coin::Transfer")
|
|
) {
|
|
if (recipient === "Unknown") {
|
|
recipient = event.parsedJson?.recipient || recipient;
|
|
}
|
|
if (amount === 0) {
|
|
amount = Number(event.parsedJson?.amount || 0);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If still no recipient found, check balance changes for different owner
|
|
if (recipient === "Unknown" && txData.balanceChanges?.length) {
|
|
const change = txData.balanceChanges.find(
|
|
(c) => c.owner?.AddressOwner && c.owner.AddressOwner !== sender
|
|
);
|
|
if (change) {
|
|
recipient = change.owner.AddressOwner;
|
|
if (amount === 0) {
|
|
amount = Math.abs(Number(change.amount || 0));
|
|
}
|
|
coinType = change.coinType || coinType;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If still no amount, try to get it from balance changes
|
|
if (amount === 0 && txData.balanceChanges?.length) {
|
|
const gasChange = txData.balanceChanges.find(
|
|
(change) =>
|
|
change.owner?.AddressOwner?.toLowerCase() === sender.toLowerCase()
|
|
);
|
|
if (gasChange) {
|
|
const totalChange = Math.abs(Number(gasChange.amount || 0));
|
|
const gasEstimate = 1500000;
|
|
|
|
if (totalChange > gasEstimate * 2) {
|
|
amount = totalChange - gasEstimate;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Calculate gas fee
|
|
const gasFee = gasUsed
|
|
? parseInt(gasUsed.computationCost) +
|
|
parseInt(gasUsed.storageCost) -
|
|
parseInt(gasUsed.storageRebate)
|
|
: 0;
|
|
|
|
// Format status for display
|
|
const statusText =
|
|
status === "success"
|
|
? "Confirmed"
|
|
: status === "failure"
|
|
? "Failed"
|
|
: status === "unknown"
|
|
? "Unknown"
|
|
: status.charAt(0).toUpperCase() + status.slice(1);
|
|
|
|
// Get error message if transaction failed
|
|
const errorMessage =
|
|
status === "failure"
|
|
? txData?.effects?.status?.error ||
|
|
txData?.effects?.status?.errorMessage ||
|
|
"Transaction failed"
|
|
: null;
|
|
|
|
return {
|
|
digest,
|
|
sender,
|
|
recipient,
|
|
amount: (amount / 1e9).toFixed(6), // Convert MIST to SUI
|
|
coinType,
|
|
status: statusText,
|
|
rawStatus: status,
|
|
timestamp,
|
|
gasUsed: (gasFee / 1e9).toFixed(6), // Convert MIST to SUI
|
|
errorMessage,
|
|
rawData: txData,
|
|
};
|
|
} catch (error) {
|
|
console.error("Error fetching transaction details:", error);
|
|
throw error;
|
|
}
|
|
},
|
|
};
|
|
|
|
window.suiBlockchainAPI = suiBlockchainAPI;
|