@clayno-club/asset-flow 0.1.3 → 0.2.0

package/README.md

@@ -1,14 +1,19 @@
 # @clayno-club/asset-flow
 
-Deterministic Solana NFT asset-flow classification and normalization.
+Deterministic asset-flow classification and normalization for supported chains.
 
-This package turns transaction data into a canonical ownership history for a mint. It is designed for consumers that want consistent classification results across services, codebases, or audit pipelines.
+This package turns transaction data into a canonical ownership history for a tracked asset. It is designed for consumers that want consistent classification results across services, codebases, or audit pipelines.
+
+Current support:
+
+- Solana NFT asset-flow normalization via the root convenience exports such as `classify`, `buildFlows`, and `buildOwnershipPeriods`
+- Sui Popkins classification via explicit Sui exports such as `classifySuiTransactionForAsset`
 
 ## What it does
 
-- classify enhanced Solana transactions for a tracked mint
-- merge raw ownership evidence into enhanced transactions when needed
-- normalize a mint's transaction history into canonical flows
+- classify supported chain transactions for a tracked asset
+- merge raw ownership evidence into enhanced Solana transactions when needed
+- normalize an asset's transaction history into canonical flows
 - derive ownership periods from normalized flows
 - explain why a transaction matched a given classification path
 - analyze provided transaction sets for review candidates
@@ -21,6 +26,11 @@ This package turns transaction data into a canonical ownership history for a min
 
 You provide the transaction data. The package provides deterministic interpretation.
 
+## Supported entrypoints
+
+- Root exports: Solana-oriented convenience API such as `classify`, `buildMintHistory`, `buildFlows`, `buildValueMovements`, and `augmentWithRaw`
+- Sui exports: explicit helpers such as `classifySuiTransactionForAsset` and the Sui transaction/type definitions
+
 ## Install
 
 ```bash

package/dist/index.d.ts

@@ -152,6 +152,53 @@ interface NormalizedMintHistory {
     periods: ReconstructedOwnershipPeriod[];
 }
 
+declare function classifyEnhancedTransactionForMint(tx: HeliusEnhancedTx, mint: string): AssetFlowTxClassification;
+
+interface AssetFlowCoverageReviewCandidate {
+    mint: string;
+    signature: string;
+    timestamp: number | null;
+    source: string;
+    normalizedType: string;
+    matcherId: string;
+    family: AssetFlowTxClassification["family"];
+    effect: AssetFlowTxClassification["effect"];
+    materialization: AssetFlowTxClassification["materialization"];
+    confidence: AssetFlowTxClassification["confidence"];
+    reason: AssetFlowTxClassification["reason"];
+    hasOwnershipChange: boolean;
+    hasMeaningfulSettlement: boolean;
+    programIds: string[];
+    instructionLabels: string[];
+}
+interface AssetFlowCoverageCluster {
+    fingerprint: string;
+    matcherId: string;
+    family: AssetFlowTxClassification["family"];
+    effect: AssetFlowTxClassification["effect"];
+    materialization: AssetFlowTxClassification["materialization"];
+    confidence: AssetFlowTxClassification["confidence"];
+    normalizedType: string;
+    source: string;
+    reason: AssetFlowTxClassification["reason"];
+    hasOwnershipChange: boolean;
+    hasMeaningfulSettlement: boolean;
+    programIds: string[];
+    instructionLabels: string[];
+    count: number;
+    sampleSignatures: string[];
+    sampleMints: string[];
+}
+interface AssetFlowCoverageScanResult {
+    mint: string;
+    transactionsScanned: number;
+    reviewCandidates: AssetFlowCoverageReviewCandidate[];
+    clusters: AssetFlowCoverageCluster[];
+}
+declare function collectCoverageReviewCandidates(transactions: HeliusEnhancedTx[], mint: string): AssetFlowCoverageReviewCandidate[];
+declare function clusterCoverageReviewCandidates(candidates: AssetFlowCoverageReviewCandidate[], sampleLimit?: number): AssetFlowCoverageCluster[];
+declare function scanTransactionsForCoverage(transactions: HeliusEnhancedTx[], mint: string): AssetFlowCoverageScanResult;
+
 type AssetOwnershipKind = "NONE" | "DIRECT" | "CUSTODY" | "SAME_OWNER" | "AMBIGUOUS";
 type AssetSettlementKind = "NONE" | "NATIVE_SALE" | "POTENTIAL_SALE" | "AMBIGUOUS";
 type AssetNftTouchKind = "NONE" | "SAME_OWNER" | "OWNERSHIP_CHANGE";
@@ -175,20 +222,6 @@ interface AssetFlowTransactionFacts {
     instructionLabels: string[];
 }
 
-declare function buildTransactionFacts(tx: HeliusEnhancedTx, mint: string): AssetFlowTransactionFacts;
-
-declare function normalizeEnhancedType(value: string | undefined): string;
-declare function toNullableNumber(value: unknown): number | null;
-declare function isNonFungibleTokenStandard(tokenStandard: string | null | undefined): boolean;
-declare function isMintNftTransfer(transfer: HeliusTokenTransfer, mint: string): boolean;
-declare function getMintNftTransfers(tx: HeliusEnhancedTx, mint: string): HeliusTokenTransfer[];
-declare function hasMeaningfulNativeSettlement(tx: HeliusEnhancedTx, mint: string): boolean;
-
-declare function observationFromFacts(facts: AssetFlowTransactionFacts): AssetFlowObservation;
-declare function observeEnhancedTransactionForMint(tx: HeliusEnhancedTx, mint: string): AssetFlowObservation;
-
-declare function classifyEnhancedTransactionForMint(tx: HeliusEnhancedTx, mint: string): AssetFlowTxClassification;
-
 interface AssetFlowClassificationMatcher {
     id: string;
     matches(observation: AssetFlowObservation): boolean;
@@ -211,50 +244,28 @@ interface AssetFlowClassificationExplanation {
 }
 declare function explainEnhancedTransactionForMint(tx: HeliusEnhancedTx, mint: string): AssetFlowClassificationExplanation;
 
-interface AssetFlowCoverageReviewCandidate {
-    mint: string;
-    signature: string;
-    timestamp: number | null;
-    source: string;
-    normalizedType: string;
-    matcherId: string;
-    family: AssetFlowTxClassification["family"];
-    effect: AssetFlowTxClassification["effect"];
-    materialization: AssetFlowTxClassification["materialization"];
-    confidence: AssetFlowTxClassification["confidence"];
-    reason: AssetFlowTxClassification["reason"];
-    hasOwnershipChange: boolean;
-    hasMeaningfulSettlement: boolean;
-    programIds: string[];
-    instructionLabels: string[];
-}
-interface AssetFlowCoverageCluster {
-    fingerprint: string;
+declare function buildTransactionFacts(tx: HeliusEnhancedTx, mint: string): AssetFlowTransactionFacts;
+
+interface ClassificationInput {
+    family: AssetFlowFamily;
+    derivedType: AssetFlowDerivedType;
     matcherId: string;
-    family: AssetFlowTxClassification["family"];
-    effect: AssetFlowTxClassification["effect"];
-    materialization: AssetFlowTxClassification["materialization"];
-    confidence: AssetFlowTxClassification["confidence"];
-    normalizedType: string;
-    source: string;
-    reason: AssetFlowTxClassification["reason"];
-    hasOwnershipChange: boolean;
-    hasMeaningfulSettlement: boolean;
-    programIds: string[];
-    instructionLabels: string[];
-    count: number;
-    sampleSignatures: string[];
-    sampleMints: string[];
-}
-interface AssetFlowCoverageScanResult {
-    mint: string;
-    transactionsScanned: number;
-    reviewCandidates: AssetFlowCoverageReviewCandidate[];
-    clusters: AssetFlowCoverageCluster[];
+    reason: string;
+    observation: {
+        normalizedType: string;
+        hasOwnershipChange: boolean;
+    };
+    overrides?: Partial<Pick<AssetFlowTxClassification, "normalizedType" | "effect" | "materialization" | "confidence" | "shouldExtractValueMovements">>;
 }
-declare function collectCoverageReviewCandidates(transactions: HeliusEnhancedTx[], mint: string): AssetFlowCoverageReviewCandidate[];
-declare function clusterCoverageReviewCandidates(candidates: AssetFlowCoverageReviewCandidate[], sampleLimit?: number): AssetFlowCoverageCluster[];
-declare function scanTransactionsForCoverage(transactions: HeliusEnhancedTx[], mint: string): AssetFlowCoverageScanResult;
+declare const PERSIST_DERIVED_TYPES: Set<AssetFlowDerivedType>;
+declare function classification(input: ClassificationInput): AssetFlowTxClassification;
+
+declare const protocolMatchers: RegisteredAssetFlowClassificationMatcher[];
+declare const coreAndMarketplaceMatchers: RegisteredAssetFlowClassificationMatcher[];
+declare const assetFlowMatchers: RegisteredAssetFlowClassificationMatcher[];
+
+declare function getMatchingAssetFlowMatchers(matchers: RegisteredAssetFlowClassificationMatcher[], observation: AssetFlowObservation): RegisteredAssetFlowClassificationMatcher[];
+declare function selectAssetFlowMatcher(matchers: RegisteredAssetFlowClassificationMatcher[], observation: AssetFlowObservation): RegisteredAssetFlowClassificationMatcher;
 
 declare function reconstructOwnershipPeriods(flows: ExtractedMintFlow[]): ReconstructedOwnershipPeriod[];
 
@@ -263,6 +274,30 @@ declare function extractMintFlows(transactions: HeliusEnhancedTx[], mint: string
 declare function extractValueMovements(transactions: HeliusEnhancedTx[], mint: string, classificationCache?: Map<string, AssetFlowTxClassification>): ExtractedValueMovement[];
 declare function normalizeMintHistory(transactions: HeliusEnhancedTx[], mint: string): NormalizedMintHistory;
 
+declare function observationFromFacts(facts: AssetFlowTransactionFacts): AssetFlowObservation;
+declare function observeEnhancedTransactionForMint(tx: HeliusEnhancedTx, mint: string): AssetFlowObservation;
+
+type MintFlowProtocolEventKind = "DIRECT_FLOW" | "POOL_SALE" | "ESCROW_SALE" | "SWAP_REASSIGN";
+interface MintFlowProtocolEventFlow {
+    fromAddress: string | null;
+    toAddress: string | null;
+    transferIndex: number;
+    tokenStandard: string | null;
+    derivedType: ExtractedMintFlow["derivedType"];
+}
+interface MintFlowProtocolEvent {
+    kind: MintFlowProtocolEventKind;
+    tx: HeliusEnhancedTx;
+    timestamp: number;
+    classification: AssetFlowTxClassification | null;
+    flows: MintFlowProtocolEventFlow[];
+}
+declare function interpretMintFlowProtocolEvent(params: {
+    tx: HeliusEnhancedTx;
+    mint: string;
+    getClassification: (tx: HeliusEnhancedTx) => AssetFlowTxClassification;
+}): MintFlowProtocolEvent | null;
+
 declare function extractCandidateMintsFromRawTransaction(tx: RawAssetFlowTransaction): string[];
 declare function synthesizeEnhancedTransactionsFromRaw(tx: RawAssetFlowTransaction): HeliusEnhancedTx[];
 declare function mergeRawProgramEvidence(tx: HeliusEnhancedTx, rawTx: RawAssetFlowTransaction): HeliusEnhancedTx;
@@ -271,4 +306,235 @@ declare function augmentEnhancedTransactionWithRaw(tx: HeliusEnhancedTx, rawTx:
 declare function applyRawOwnerOverridesToEnhanced(tx: HeliusEnhancedTx, rawTx: RawAssetFlowTransaction): HeliusEnhancedTx;
 declare function shouldFetchRawForMintTx(tx: HeliusEnhancedTx, mint: string): boolean;
 
-export { type AssetFlowClassificationExplanation, type AssetFlowCoverageCluster, type AssetFlowCoverageReviewCandidate, type AssetFlowCoverageScanResult, type AssetFlowDerivedType, type AssetFlowEffect, type AssetFlowFamily, type AssetFlowInterpreterConfidence, type AssetFlowMatcherExplanation, type AssetFlowMaterialization, type AssetFlowObservation, type AssetFlowTransactionFacts, type AssetFlowTxClassification, type AssetNftTouchKind, type AssetOwnershipKind, type AssetSettlementKind, type ExtractedMintFlow, type ExtractedValueMovement, type HeliusEnhancedAction, type HeliusEnhancedInstruction, type HeliusEnhancedTx, type HeliusNativeTransfer, type HeliusTokenTransfer, type NormalizedMintHistory, type RawAssetFlowAccountKey, type RawAssetFlowInstruction, type RawAssetFlowTokenBalance, type RawAssetFlowTransaction, type ReconstructedOwnershipPeriod, applyRawOwnerOverridesToEnhanced, augmentEnhancedTransactionWithRaw, augmentEnhancedTransactionWithRaw as augmentWithRaw, extractMintFlows as buildFlows, normalizeMintHistory as buildMintHistory, reconstructOwnershipPeriods as buildOwnershipPeriods, buildTransactionFacts, extractValueMovements as buildValueMovements, classifyEnhancedTransactionForMint as classify, classifyEnhancedTransactionForMint, clusterCoverageReviewCandidates, collectCoverageReviewCandidates, explainEnhancedTransactionForMint as explain, explainEnhancedTransactionForMint, extractCandidateMintsFromEnhancedTx, extractCandidateMintsFromRawTransaction, extractMintFlows, extractCandidateMintsFromEnhancedTx as extractMints, extractValueMovements, getMintNftTransfers, hasMeaningfulNativeSettlement, isMintNftTransfer, isNonFungibleTokenStandard, mergeRawProgramEvidence, normalizeEnhancedType, normalizeMintHistory, observationFromFacts, observeEnhancedTransactionForMint, reconstructOwnershipPeriods, scanTransactionsForCoverage, shouldApplyRawOwnerOverrides, shouldFetchRawForMintTx as shouldFetchRaw, shouldFetchRawForMintTx, synthesizeEnhancedTransactionsFromRaw, toNullableNumber };
+declare function normalizeEnhancedType(value: string | undefined): string;
+declare function toNullableNumber(value: unknown): number | null;
+declare function isNonFungibleTokenStandard(tokenStandard: string | null | undefined): boolean;
+declare function isMintNftTransfer(transfer: HeliusTokenTransfer, mint: string): boolean;
+declare function getMintNftTransfers(tx: HeliusEnhancedTx, mint: string): HeliusTokenTransfer[];
+declare function hasMeaningfulNativeSettlement(tx: HeliusEnhancedTx, mint: string): boolean;
+
+type index$1_AssetFlowClassificationExplanation = AssetFlowClassificationExplanation;
+type index$1_AssetFlowClassificationMatcher = AssetFlowClassificationMatcher;
+type index$1_AssetFlowCoverageCluster = AssetFlowCoverageCluster;
+type index$1_AssetFlowCoverageReviewCandidate = AssetFlowCoverageReviewCandidate;
+type index$1_AssetFlowCoverageScanResult = AssetFlowCoverageScanResult;
+type index$1_AssetFlowMatcherExplanation = AssetFlowMatcherExplanation;
+type index$1_AssetFlowTransactionFacts = AssetFlowTransactionFacts;
+type index$1_AssetNftTouchKind = AssetNftTouchKind;
+type index$1_AssetOwnershipKind = AssetOwnershipKind;
+type index$1_AssetSettlementKind = AssetSettlementKind;
+type index$1_MintFlowProtocolEvent = MintFlowProtocolEvent;
+type index$1_MintFlowProtocolEventFlow = MintFlowProtocolEventFlow;
+type index$1_MintFlowProtocolEventKind = MintFlowProtocolEventKind;
+declare const index$1_PERSIST_DERIVED_TYPES: typeof PERSIST_DERIVED_TYPES;
+type index$1_RegisteredAssetFlowClassificationMatcher = RegisteredAssetFlowClassificationMatcher;
+declare const index$1_applyRawOwnerOverridesToEnhanced: typeof applyRawOwnerOverridesToEnhanced;
+declare const index$1_assetFlowMatchers: typeof assetFlowMatchers;
+declare const index$1_augmentEnhancedTransactionWithRaw: typeof augmentEnhancedTransactionWithRaw;
+declare const index$1_buildTransactionFacts: typeof buildTransactionFacts;
+declare const index$1_classification: typeof classification;
+declare const index$1_classifyEnhancedTransactionForMint: typeof classifyEnhancedTransactionForMint;
+declare const index$1_clusterCoverageReviewCandidates: typeof clusterCoverageReviewCandidates;
+declare const index$1_collectCoverageReviewCandidates: typeof collectCoverageReviewCandidates;
+declare const index$1_coreAndMarketplaceMatchers: typeof coreAndMarketplaceMatchers;
+declare const index$1_explainEnhancedTransactionForMint: typeof explainEnhancedTransactionForMint;
+declare const index$1_extractCandidateMintsFromEnhancedTx: typeof extractCandidateMintsFromEnhancedTx;
+declare const index$1_extractCandidateMintsFromRawTransaction: typeof extractCandidateMintsFromRawTransaction;
+declare const index$1_extractMintFlows: typeof extractMintFlows;
+declare const index$1_extractValueMovements: typeof extractValueMovements;
+declare const index$1_getMatchingAssetFlowMatchers: typeof getMatchingAssetFlowMatchers;
+declare const index$1_getMintNftTransfers: typeof getMintNftTransfers;
+declare const index$1_hasMeaningfulNativeSettlement: typeof hasMeaningfulNativeSettlement;
+declare const index$1_interpretMintFlowProtocolEvent: typeof interpretMintFlowProtocolEvent;
+declare const index$1_isMintNftTransfer: typeof isMintNftTransfer;
+declare const index$1_isNonFungibleTokenStandard: typeof isNonFungibleTokenStandard;
+declare const index$1_mergeRawProgramEvidence: typeof mergeRawProgramEvidence;
+declare const index$1_normalizeEnhancedType: typeof normalizeEnhancedType;
+declare const index$1_normalizeMintHistory: typeof normalizeMintHistory;
+declare const index$1_observationFromFacts: typeof observationFromFacts;
+declare const index$1_observeEnhancedTransactionForMint: typeof observeEnhancedTransactionForMint;
+declare const index$1_protocolMatchers: typeof protocolMatchers;
+declare const index$1_reconstructOwnershipPeriods: typeof reconstructOwnershipPeriods;
+declare const index$1_scanTransactionsForCoverage: typeof scanTransactionsForCoverage;
+declare const index$1_selectAssetFlowMatcher: typeof selectAssetFlowMatcher;
+declare const index$1_shouldApplyRawOwnerOverrides: typeof shouldApplyRawOwnerOverrides;
+declare const index$1_shouldFetchRawForMintTx: typeof shouldFetchRawForMintTx;
+declare const index$1_synthesizeEnhancedTransactionsFromRaw: typeof synthesizeEnhancedTransactionsFromRaw;
+declare const index$1_toNullableNumber: typeof toNullableNumber;
+declare namespace index$1 {
+  export { type index$1_AssetFlowClassificationExplanation as AssetFlowClassificationExplanation, type index$1_AssetFlowClassificationMatcher as AssetFlowClassificationMatcher, type index$1_AssetFlowCoverageCluster as AssetFlowCoverageCluster, type index$1_AssetFlowCoverageReviewCandidate as AssetFlowCoverageReviewCandidate, type index$1_AssetFlowCoverageScanResult as AssetFlowCoverageScanResult, type index$1_AssetFlowMatcherExplanation as AssetFlowMatcherExplanation, type index$1_AssetFlowTransactionFacts as AssetFlowTransactionFacts, type index$1_AssetNftTouchKind as AssetNftTouchKind, type index$1_AssetOwnershipKind as AssetOwnershipKind, type index$1_AssetSettlementKind as AssetSettlementKind, type index$1_MintFlowProtocolEvent as MintFlowProtocolEvent, type index$1_MintFlowProtocolEventFlow as MintFlowProtocolEventFlow, type index$1_MintFlowProtocolEventKind as MintFlowProtocolEventKind, index$1_PERSIST_DERIVED_TYPES as PERSIST_DERIVED_TYPES, type index$1_RegisteredAssetFlowClassificationMatcher as RegisteredAssetFlowClassificationMatcher, index$1_applyRawOwnerOverridesToEnhanced as applyRawOwnerOverridesToEnhanced, index$1_assetFlowMatchers as assetFlowMatchers, index$1_augmentEnhancedTransactionWithRaw as augmentEnhancedTransactionWithRaw, augmentEnhancedTransactionWithRaw as augmentWithRaw, extractMintFlows as buildFlows, normalizeMintHistory as buildMintHistory, reconstructOwnershipPeriods as buildOwnershipPeriods, index$1_buildTransactionFacts as buildTransactionFacts, extractValueMovements as buildValueMovements, index$1_classification as classification, classifyEnhancedTransactionForMint as classify, index$1_classifyEnhancedTransactionForMint as classifyEnhancedTransactionForMint, index$1_clusterCoverageReviewCandidates as clusterCoverageReviewCandidates, index$1_collectCoverageReviewCandidates as collectCoverageReviewCandidates, index$1_coreAndMarketplaceMatchers as coreAndMarketplaceMatchers, explainEnhancedTransactionForMint as explain, index$1_explainEnhancedTransactionForMint as explainEnhancedTransactionForMint, index$1_extractCandidateMintsFromEnhancedTx as extractCandidateMintsFromEnhancedTx, index$1_extractCandidateMintsFromRawTransaction as extractCandidateMintsFromRawTransaction, index$1_extractMintFlows as extractMintFlows, extractCandidateMintsFromEnhancedTx as extractMints, index$1_extractValueMovements as extractValueMovements, index$1_getMatchingAssetFlowMatchers as getMatchingAssetFlowMatchers, index$1_getMintNftTransfers as getMintNftTransfers, index$1_hasMeaningfulNativeSettlement as hasMeaningfulNativeSettlement, index$1_interpretMintFlowProtocolEvent as interpretMintFlowProtocolEvent, index$1_isMintNftTransfer as isMintNftTransfer, index$1_isNonFungibleTokenStandard as isNonFungibleTokenStandard, index$1_mergeRawProgramEvidence as mergeRawProgramEvidence, index$1_normalizeEnhancedType as normalizeEnhancedType, index$1_normalizeMintHistory as normalizeMintHistory, index$1_observationFromFacts as observationFromFacts, index$1_observeEnhancedTransactionForMint as observeEnhancedTransactionForMint, index$1_protocolMatchers as protocolMatchers, index$1_reconstructOwnershipPeriods as reconstructOwnershipPeriods, index$1_scanTransactionsForCoverage as scanTransactionsForCoverage, index$1_selectAssetFlowMatcher as selectAssetFlowMatcher, index$1_shouldApplyRawOwnerOverrides as shouldApplyRawOwnerOverrides, shouldFetchRawForMintTx as shouldFetchRaw, index$1_shouldFetchRawForMintTx as shouldFetchRawForMintTx, index$1_synthesizeEnhancedTransactionsFromRaw as synthesizeEnhancedTransactionsFromRaw, index$1_toNullableNumber as toNullableNumber };
+}
+
+interface SuiEventLike {
+    type: string;
+    parsedJson?: unknown | null;
+}
+type SuiObjectOwnerLike = {
+    AddressOwner: string;
+} | {
+    ObjectOwner: string;
+} | {
+    Shared: {
+        initial_shared_version: string;
+    };
+} | {
+    ConsensusV2: unknown;
+} | "Immutable" | null | undefined;
+interface SuiObjectChangeLike {
+    type: string;
+    objectId?: string;
+    objectType?: string;
+    sender?: string;
+    owner?: SuiObjectOwnerLike;
+    recipient?: SuiObjectOwnerLike;
+}
+interface SuiBalanceChangeLike {
+    owner?: SuiObjectOwnerLike;
+    coinType?: string;
+    amount?: string;
+}
+interface SuiTransactionBlockLike {
+    digest: string;
+    checkpoint?: string | null;
+    timestampMs?: string | null;
+    events?: SuiEventLike[] | null;
+    objectChanges?: SuiObjectChangeLike[] | null;
+    balanceChanges?: SuiBalanceChangeLike[] | null;
+    transaction?: {
+        data?: {
+            sender?: string | null;
+        } | null;
+    } | null;
+}
+type SuiAssetFlowFamily = "NFT_MINT" | "TRADEPORT_SALE" | "TRADEPORT_LISTING" | "TRADEPORT_BID_INTENT" | "KIOSK_LISTING" | "KIOSK_CUSTODY" | "POPKINS_STAKING" | "POPSWAP" | "GENERIC_OBJECT_TRANSFER" | "UNKNOWN";
+interface SuiAssetOwnerChange {
+    sender: string | null;
+    nextOwner: string | null;
+    nextOwnerKind?: "address" | "object" | "shared" | "immutable" | "consensus" | null;
+    objectType: string | null;
+}
+interface SuiAssetFlowClassification {
+    assetId: string;
+    family: SuiAssetFlowFamily;
+    effect: AssetFlowEffect;
+    materialization: AssetFlowMaterialization;
+    confidence: AssetFlowInterpreterConfidence;
+    derivedType: AssetFlowDerivedType;
+    matcherId: string;
+    reason: string;
+    hasOwnershipChange: boolean;
+    shouldExtractValueMovements: boolean;
+    eventTypes: string[];
+    market: string | null;
+    priceRaw: string | null;
+    currency: string | null;
+    ownerChange: SuiAssetOwnerChange | null;
+}
+
+declare const SUI_COIN_TYPE = "0x2::sui::SUI";
+declare const POPKINS_MINTED_EVENT_SUFFIX = "::popkins_nft::PopkinsMinted";
+declare const POPKINS_STAKED_EVENT_SUFFIX = "::events::PopkinsStakedEvent";
+declare const POPKINS_UNSTAKED_EVENT_SUFFIX = "::events::PopkinsUnstakedEvent";
+declare const TRADEPORT_BUY_SIMPLE_EVENT_SUFFIX = "::tradeport_listings::BuySimpleListingEvent";
+declare const TRADEPORT_MATCH_SINGLE_BID_EVENT_SUFFIX = "::tradeport_biddings::MatchSingleBidEvent";
+declare const TRADEPORT_KIOSK_BUY_EVENT_SUFFIX = "::kiosk_listings::BuyEvent";
+declare const TRADEPORT_ADD_LISTING_EVENT_SUFFIX = "::tradeport_orderbook::AddListingEvent";
+declare const TRADEPORT_RELIST_SIMPLE_EVENT_SUFFIX = "::tradeport_listings::RelistSimpleListingEvent";
+declare const TRADEPORT_REMOVE_LISTING_EVENT_SUFFIX = "::tradeport_orderbook::RemoveListingEvent";
+declare const TRADEPORT_CANCEL_SIMPLE_EVENT_SUFFIX = "::tradeport_listings::CancelSimpleListingEvent";
+declare const TRADEPORT_CREATE_SINGLE_BID_EVENT_SUFFIX = "::tradeport_biddings::CreateSingleBidEvent";
+declare const KIOSK_LIST_EVENT_SUFFIX = "::kiosk_listings::ListEvent";
+declare const KIOSK_UNLIST_EVENT_SUFFIX = "::kiosk_listings::UnlistEvent";
+declare const KIOSK_TRANSFER_EVENT_SUFFIX = "::kiosk_transfers::TransferWithPurchaseCapEvent";
+declare const KIOSK_CLAIM_EVENT_SUFFIX = "::kiosk_transfers::ClaimWithPurchaseCapEvent";
+declare const PERSONAL_KIOSK_CREATED_EVENT_SUFFIX = "::personal_kiosk::NewPersonalKiosk";
+declare const KIOSK_BIDDING_CLAIM_EVENT_SUFFIX = "::kiosk_biddings::ClaimWithPurchaseCapEvent";
+type SuiAssetOwnerRefKind = "address" | "object" | "shared" | "immutable" | "consensus";
+interface SuiAssetOwnerRef {
+    value: string;
+    kind: SuiAssetOwnerRefKind;
+}
+interface SuiAssetOwnerChangeDetails {
+    sender: string | null;
+    nextOwner: SuiAssetOwnerRef | null;
+    objectType: string | null;
+}
+declare function isRecord(value: unknown): value is Record<string, unknown>;
+declare function getString(value: unknown): string | null;
+declare function getRecordString(record: Record<string, unknown>, key: string): string | null;
+declare function getRecordStringArray(record: Record<string, unknown>, key: string): string[];
+declare function eventTypeMatches(event: Pick<SuiEventLike, "type">, suffixes: readonly string[]): boolean;
+declare function normalizeOwnerRef(owner: SuiObjectOwnerLike): SuiAssetOwnerRef | null;
+declare function getAssetObjectChange(tx: SuiTransactionBlockLike, assetId: string): SuiObjectChangeLike | null;
+declare function getAssetOwnerChangeDetails(tx: SuiTransactionBlockLike, assetId: string): SuiAssetOwnerChangeDetails | null;
+declare function getAssetOwnerChange(tx: SuiTransactionBlockLike, assetId: string): SuiAssetOwnerChange | null;
+declare function eventTouchesAsset(event: SuiEventLike, assetId: string): boolean;
+declare function getAssetEvents(tx: SuiTransactionBlockLike, assetId: string): SuiEventLike[];
+declare function getEventTypes(events: SuiEventLike[]): string[];
+declare function findFirstEvent(events: SuiEventLike[], suffixes: readonly string[]): SuiEventLike | null;
+declare function getPriceRaw(event: SuiEventLike | null): string | null;
+declare function getMarket(event: SuiEventLike | null, fallback?: string | null): string | null;
+declare function hasMeaningfulSuiSettlement(balanceChanges: SuiBalanceChangeLike[] | null | undefined): boolean;
+
+declare function classifySuiTransactionForAsset(tx: SuiTransactionBlockLike, assetId: string): SuiAssetFlowClassification;
+
+declare function extractAssetFlows(transactions: SuiTransactionBlockLike[], assetId: string, classificationCache?: Map<string, SuiAssetFlowClassification>): ExtractedMintFlow[];
+declare function normalizeAssetHistory(transactions: SuiTransactionBlockLike[], assetId: string): {
+    flows: ExtractedMintFlow[];
+    periods: ReconstructedOwnershipPeriod[];
+};
+
+declare const index_KIOSK_BIDDING_CLAIM_EVENT_SUFFIX: typeof KIOSK_BIDDING_CLAIM_EVENT_SUFFIX;
+declare const index_KIOSK_CLAIM_EVENT_SUFFIX: typeof KIOSK_CLAIM_EVENT_SUFFIX;
+declare const index_KIOSK_LIST_EVENT_SUFFIX: typeof KIOSK_LIST_EVENT_SUFFIX;
+declare const index_KIOSK_TRANSFER_EVENT_SUFFIX: typeof KIOSK_TRANSFER_EVENT_SUFFIX;
+declare const index_KIOSK_UNLIST_EVENT_SUFFIX: typeof KIOSK_UNLIST_EVENT_SUFFIX;
+declare const index_PERSONAL_KIOSK_CREATED_EVENT_SUFFIX: typeof PERSONAL_KIOSK_CREATED_EVENT_SUFFIX;
+declare const index_POPKINS_MINTED_EVENT_SUFFIX: typeof POPKINS_MINTED_EVENT_SUFFIX;
+declare const index_POPKINS_STAKED_EVENT_SUFFIX: typeof POPKINS_STAKED_EVENT_SUFFIX;
+declare const index_POPKINS_UNSTAKED_EVENT_SUFFIX: typeof POPKINS_UNSTAKED_EVENT_SUFFIX;
+declare const index_SUI_COIN_TYPE: typeof SUI_COIN_TYPE;
+type index_SuiAssetFlowClassification = SuiAssetFlowClassification;
+type index_SuiAssetFlowFamily = SuiAssetFlowFamily;
+type index_SuiAssetOwnerChange = SuiAssetOwnerChange;
+type index_SuiAssetOwnerChangeDetails = SuiAssetOwnerChangeDetails;
+type index_SuiAssetOwnerRef = SuiAssetOwnerRef;
+type index_SuiAssetOwnerRefKind = SuiAssetOwnerRefKind;
+type index_SuiBalanceChangeLike = SuiBalanceChangeLike;
+type index_SuiEventLike = SuiEventLike;
+type index_SuiObjectChangeLike = SuiObjectChangeLike;
+type index_SuiObjectOwnerLike = SuiObjectOwnerLike;
+type index_SuiTransactionBlockLike = SuiTransactionBlockLike;
+declare const index_TRADEPORT_ADD_LISTING_EVENT_SUFFIX: typeof TRADEPORT_ADD_LISTING_EVENT_SUFFIX;
+declare const index_TRADEPORT_BUY_SIMPLE_EVENT_SUFFIX: typeof TRADEPORT_BUY_SIMPLE_EVENT_SUFFIX;
+declare const index_TRADEPORT_CANCEL_SIMPLE_EVENT_SUFFIX: typeof TRADEPORT_CANCEL_SIMPLE_EVENT_SUFFIX;
+declare const index_TRADEPORT_CREATE_SINGLE_BID_EVENT_SUFFIX: typeof TRADEPORT_CREATE_SINGLE_BID_EVENT_SUFFIX;
+declare const index_TRADEPORT_KIOSK_BUY_EVENT_SUFFIX: typeof TRADEPORT_KIOSK_BUY_EVENT_SUFFIX;
+declare const index_TRADEPORT_MATCH_SINGLE_BID_EVENT_SUFFIX: typeof TRADEPORT_MATCH_SINGLE_BID_EVENT_SUFFIX;
+declare const index_TRADEPORT_RELIST_SIMPLE_EVENT_SUFFIX: typeof TRADEPORT_RELIST_SIMPLE_EVENT_SUFFIX;
+declare const index_TRADEPORT_REMOVE_LISTING_EVENT_SUFFIX: typeof TRADEPORT_REMOVE_LISTING_EVENT_SUFFIX;
+declare const index_classifySuiTransactionForAsset: typeof classifySuiTransactionForAsset;
+declare const index_eventTouchesAsset: typeof eventTouchesAsset;
+declare const index_eventTypeMatches: typeof eventTypeMatches;
+declare const index_extractAssetFlows: typeof extractAssetFlows;
+declare const index_findFirstEvent: typeof findFirstEvent;
+declare const index_getAssetEvents: typeof getAssetEvents;
+declare const index_getAssetObjectChange: typeof getAssetObjectChange;
+declare const index_getAssetOwnerChange: typeof getAssetOwnerChange;
+declare const index_getAssetOwnerChangeDetails: typeof getAssetOwnerChangeDetails;
+declare const index_getEventTypes: typeof getEventTypes;
+declare const index_getMarket: typeof getMarket;
+declare const index_getPriceRaw: typeof getPriceRaw;
+declare const index_getRecordString: typeof getRecordString;
+declare const index_getRecordStringArray: typeof getRecordStringArray;
+declare const index_getString: typeof getString;
+declare const index_hasMeaningfulSuiSettlement: typeof hasMeaningfulSuiSettlement;
+declare const index_isRecord: typeof isRecord;
+declare const index_normalizeAssetHistory: typeof normalizeAssetHistory;
+declare const index_normalizeOwnerRef: typeof normalizeOwnerRef;
+declare const index_reconstructOwnershipPeriods: typeof reconstructOwnershipPeriods;
+declare namespace index {
+  export { index_KIOSK_BIDDING_CLAIM_EVENT_SUFFIX as KIOSK_BIDDING_CLAIM_EVENT_SUFFIX, index_KIOSK_CLAIM_EVENT_SUFFIX as KIOSK_CLAIM_EVENT_SUFFIX, index_KIOSK_LIST_EVENT_SUFFIX as KIOSK_LIST_EVENT_SUFFIX, index_KIOSK_TRANSFER_EVENT_SUFFIX as KIOSK_TRANSFER_EVENT_SUFFIX, index_KIOSK_UNLIST_EVENT_SUFFIX as KIOSK_UNLIST_EVENT_SUFFIX, index_PERSONAL_KIOSK_CREATED_EVENT_SUFFIX as PERSONAL_KIOSK_CREATED_EVENT_SUFFIX, index_POPKINS_MINTED_EVENT_SUFFIX as POPKINS_MINTED_EVENT_SUFFIX, index_POPKINS_STAKED_EVENT_SUFFIX as POPKINS_STAKED_EVENT_SUFFIX, index_POPKINS_UNSTAKED_EVENT_SUFFIX as POPKINS_UNSTAKED_EVENT_SUFFIX, index_SUI_COIN_TYPE as SUI_COIN_TYPE, type index_SuiAssetFlowClassification as SuiAssetFlowClassification, type index_SuiAssetFlowFamily as SuiAssetFlowFamily, type index_SuiAssetOwnerChange as SuiAssetOwnerChange, type index_SuiAssetOwnerChangeDetails as SuiAssetOwnerChangeDetails, type index_SuiAssetOwnerRef as SuiAssetOwnerRef, type index_SuiAssetOwnerRefKind as SuiAssetOwnerRefKind, type index_SuiBalanceChangeLike as SuiBalanceChangeLike, type index_SuiEventLike as SuiEventLike, type index_SuiObjectChangeLike as SuiObjectChangeLike, type index_SuiObjectOwnerLike as SuiObjectOwnerLike, type index_SuiTransactionBlockLike as SuiTransactionBlockLike, index_TRADEPORT_ADD_LISTING_EVENT_SUFFIX as TRADEPORT_ADD_LISTING_EVENT_SUFFIX, index_TRADEPORT_BUY_SIMPLE_EVENT_SUFFIX as TRADEPORT_BUY_SIMPLE_EVENT_SUFFIX, index_TRADEPORT_CANCEL_SIMPLE_EVENT_SUFFIX as TRADEPORT_CANCEL_SIMPLE_EVENT_SUFFIX, index_TRADEPORT_CREATE_SINGLE_BID_EVENT_SUFFIX as TRADEPORT_CREATE_SINGLE_BID_EVENT_SUFFIX, index_TRADEPORT_KIOSK_BUY_EVENT_SUFFIX as TRADEPORT_KIOSK_BUY_EVENT_SUFFIX, index_TRADEPORT_MATCH_SINGLE_BID_EVENT_SUFFIX as TRADEPORT_MATCH_SINGLE_BID_EVENT_SUFFIX, index_TRADEPORT_RELIST_SIMPLE_EVENT_SUFFIX as TRADEPORT_RELIST_SIMPLE_EVENT_SUFFIX, index_TRADEPORT_REMOVE_LISTING_EVENT_SUFFIX as TRADEPORT_REMOVE_LISTING_EVENT_SUFFIX, normalizeAssetHistory as buildAssetHistory, extractAssetFlows as buildFlows, reconstructOwnershipPeriods as buildOwnershipPeriods, classifySuiTransactionForAsset as classify, index_classifySuiTransactionForAsset as classifySuiTransactionForAsset, index_eventTouchesAsset as eventTouchesAsset, index_eventTypeMatches as eventTypeMatches, index_extractAssetFlows as extractAssetFlows, index_findFirstEvent as findFirstEvent, index_getAssetEvents as getAssetEvents, index_getAssetObjectChange as getAssetObjectChange, index_getAssetOwnerChange as getAssetOwnerChange, index_getAssetOwnerChangeDetails as getAssetOwnerChangeDetails, index_getEventTypes as getEventTypes, index_getMarket as getMarket, index_getPriceRaw as getPriceRaw, index_getRecordString as getRecordString, index_getRecordStringArray as getRecordStringArray, index_getString as getString, index_hasMeaningfulSuiSettlement as hasMeaningfulSuiSettlement, index_isRecord as isRecord, index_normalizeAssetHistory as normalizeAssetHistory, index_normalizeOwnerRef as normalizeOwnerRef, index_reconstructOwnershipPeriods as reconstructOwnershipPeriods };
+}
+
+export { type AssetFlowClassificationExplanation, type AssetFlowClassificationMatcher, type AssetFlowCoverageCluster, type AssetFlowCoverageReviewCandidate, type AssetFlowCoverageScanResult, type AssetFlowDerivedType, type AssetFlowEffect, type AssetFlowFamily, type AssetFlowInterpreterConfidence, type AssetFlowMatcherExplanation, type AssetFlowMaterialization, type AssetFlowObservation, type AssetFlowTransactionFacts, type AssetFlowTxClassification, type AssetNftTouchKind, type AssetOwnershipKind, type AssetSettlementKind, type ExtractedMintFlow, type ExtractedValueMovement, type HeliusEnhancedAction, type HeliusEnhancedInstruction, type HeliusEnhancedTx, type HeliusNativeTransfer, type HeliusTokenTransfer, KIOSK_BIDDING_CLAIM_EVENT_SUFFIX, KIOSK_CLAIM_EVENT_SUFFIX, KIOSK_LIST_EVENT_SUFFIX, KIOSK_TRANSFER_EVENT_SUFFIX, KIOSK_UNLIST_EVENT_SUFFIX, type MintFlowProtocolEvent, type MintFlowProtocolEventFlow, type MintFlowProtocolEventKind, type NormalizedMintHistory, PERSIST_DERIVED_TYPES, PERSONAL_KIOSK_CREATED_EVENT_SUFFIX, POPKINS_MINTED_EVENT_SUFFIX, POPKINS_STAKED_EVENT_SUFFIX, POPKINS_UNSTAKED_EVENT_SUFFIX, type RawAssetFlowAccountKey, type RawAssetFlowInstruction, type RawAssetFlowTokenBalance, type RawAssetFlowTransaction, type ReconstructedOwnershipPeriod, type RegisteredAssetFlowClassificationMatcher, SUI_COIN_TYPE, type SuiAssetFlowClassification, type SuiAssetFlowFamily, type SuiAssetOwnerChange, type SuiAssetOwnerChangeDetails, type SuiAssetOwnerRef, type SuiAssetOwnerRefKind, type SuiBalanceChangeLike, type SuiEventLike, type SuiObjectChangeLike, type SuiObjectOwnerLike, type SuiTransactionBlockLike, TRADEPORT_ADD_LISTING_EVENT_SUFFIX, TRADEPORT_BUY_SIMPLE_EVENT_SUFFIX, TRADEPORT_CANCEL_SIMPLE_EVENT_SUFFIX, TRADEPORT_CREATE_SINGLE_BID_EVENT_SUFFIX, TRADEPORT_KIOSK_BUY_EVENT_SUFFIX, TRADEPORT_MATCH_SINGLE_BID_EVENT_SUFFIX, TRADEPORT_RELIST_SIMPLE_EVENT_SUFFIX, TRADEPORT_REMOVE_LISTING_EVENT_SUFFIX, applyRawOwnerOverridesToEnhanced, assetFlowMatchers, augmentEnhancedTransactionWithRaw, augmentEnhancedTransactionWithRaw as augmentWithRaw, extractMintFlows as buildFlows, normalizeMintHistory as buildMintHistory, reconstructOwnershipPeriods as buildOwnershipPeriods, buildTransactionFacts, extractValueMovements as buildValueMovements, classification, classifyEnhancedTransactionForMint as classify, classifyEnhancedTransactionForMint, classifySuiTransactionForAsset, clusterCoverageReviewCandidates, collectCoverageReviewCandidates, coreAndMarketplaceMatchers, eventTouchesAsset, eventTypeMatches, explainEnhancedTransactionForMint as explain, explainEnhancedTransactionForMint, extractAssetFlows, extractCandidateMintsFromEnhancedTx, extractCandidateMintsFromRawTransaction, extractMintFlows, extractCandidateMintsFromEnhancedTx as extractMints, extractValueMovements, findFirstEvent, getAssetEvents, getAssetObjectChange, getAssetOwnerChange, getAssetOwnerChangeDetails, getEventTypes, getMarket, getMatchingAssetFlowMatchers, getMintNftTransfers, getPriceRaw, getRecordString, getRecordStringArray, getString, hasMeaningfulNativeSettlement, hasMeaningfulSuiSettlement, interpretMintFlowProtocolEvent, isMintNftTransfer, isNonFungibleTokenStandard, isRecord, mergeRawProgramEvidence, normalizeAssetHistory, normalizeEnhancedType, normalizeMintHistory, normalizeOwnerRef, observationFromFacts, observeEnhancedTransactionForMint, protocolMatchers, reconstructOwnershipPeriods, scanTransactionsForCoverage, selectAssetFlowMatcher, shouldApplyRawOwnerOverrides, shouldFetchRawForMintTx as shouldFetchRaw, shouldFetchRawForMintTx, index$1 as solana, index as sui, synthesizeEnhancedTransactionsFromRaw, toNullableNumber };