hive-stream 3.0.2 → 3.0.3

package/dist/contracts/nft.contract.js

@@ -6,7 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NFTContract = void 0;
 exports.createNFTContract = createNFTContract;
 const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const utils_1 = require("../utils");
 const contract_1 = require("./contract");
+const helpers_1 = require("./helpers");
 const CONTRACT_NAME = 'hivenft';
 class NFTContract {
     _instance;
@@ -17,6 +19,7 @@ class NFTContract {
     transactionId;
     async create() {
         this.adapter = this._instance.getAdapter();
+        (0, helpers_1.ensureSqlAdapter)(this.adapter);
         await this.initializeNFTTables();
     }
     destroy() {
@@ -29,82 +32,84 @@ class NFTContract {
         this.transactionId = transactionId;
     }
     async initializeNFTTables() {
-        try {
-            await this.adapter.query(`
-                CREATE TABLE IF NOT EXISTS nft_collections (
-                    symbol TEXT PRIMARY KEY,
-                    name TEXT NOT NULL,
-                    description TEXT,
-                    creator TEXT NOT NULL,
-                    max_supply INTEGER,
-                    current_supply INTEGER NOT NULL DEFAULT 0,
-                    royalty REAL DEFAULT 0,
-                    base_uri TEXT,
-                    allow_updates BOOLEAN DEFAULT TRUE,
-                    updateable_by_owner BOOLEAN DEFAULT FALSE,
-                    created_at DATETIME NOT NULL
-                )
-            `);
-            await this.adapter.query(`
-                CREATE TABLE IF NOT EXISTS nft_tokens (
-                    token_id TEXT NOT NULL,
-                    collection_symbol TEXT NOT NULL,
-                    owner TEXT NOT NULL,
-                    metadata TEXT,
-                    attributes TEXT,
-                    minted_at DATETIME NOT NULL,
-                    minted_by TEXT NOT NULL,
-                    burned BOOLEAN DEFAULT FALSE,
-                    PRIMARY KEY (token_id, collection_symbol),
-                    FOREIGN KEY (collection_symbol) REFERENCES nft_collections(symbol)
-                )
-            `);
-            await this.adapter.query(`
-                CREATE TABLE IF NOT EXISTS nft_listings (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    token_id TEXT NOT NULL,
-                    collection_symbol TEXT NOT NULL,
-                    seller TEXT NOT NULL,
-                    price TEXT NOT NULL,
-                    currency TEXT NOT NULL DEFAULT 'HIVE',
-                    listed_at DATETIME NOT NULL,
-                    active BOOLEAN DEFAULT TRUE,
-                    FOREIGN KEY (token_id, collection_symbol) REFERENCES nft_tokens(token_id, collection_symbol)
-                )
-            `);
-            await this.adapter.query(`
-                CREATE TABLE IF NOT EXISTS nft_transfers (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    token_id TEXT NOT NULL,
-                    collection_symbol TEXT NOT NULL,
-                    from_account TEXT NOT NULL,
-                    to_account TEXT NOT NULL,
-                    transfer_type TEXT NOT NULL,
-                    price TEXT,
-                    currency TEXT,
-                    block_number INTEGER NOT NULL,
-                    transaction_id TEXT NOT NULL,
-                    timestamp DATETIME NOT NULL,
-                    FOREIGN KEY (token_id, collection_symbol) REFERENCES nft_tokens(token_id, collection_symbol)
-                )
-            `);
-            await this.adapter.query(`
-                CREATE INDEX IF NOT EXISTS idx_nft_tokens_owner ON nft_tokens(owner);
-            `);
-            await this.adapter.query(`
-                CREATE INDEX IF NOT EXISTS idx_nft_tokens_collection ON nft_tokens(collection_symbol);
-            `);
-            await this.adapter.query(`
-                CREATE INDEX IF NOT EXISTS idx_nft_listings_active ON nft_listings(active, collection_symbol);
-            `);
-        }
-        catch (error) {
-            console.error('[NFTContract] Error initializing tables:', error);
+        await this.adapter.query(`
+            CREATE TABLE IF NOT EXISTS nft_collections (
+                symbol TEXT PRIMARY KEY,
+                name TEXT NOT NULL,
+                description TEXT,
+                creator TEXT NOT NULL,
+                max_supply INTEGER,
+                current_supply INTEGER NOT NULL DEFAULT 0,
+                royalty REAL DEFAULT 0,
+                base_uri TEXT,
+                allow_updates BOOLEAN DEFAULT TRUE,
+                updateable_by_owner BOOLEAN DEFAULT FALSE,
+                created_at DATETIME NOT NULL
+            )
+        `);
+        await this.adapter.query(`
+            CREATE TABLE IF NOT EXISTS nft_tokens (
+                token_id TEXT NOT NULL,
+                collection_symbol TEXT NOT NULL,
+                owner TEXT NOT NULL,
+                metadata TEXT,
+                attributes TEXT,
+                minted_at DATETIME NOT NULL,
+                minted_by TEXT NOT NULL,
+                burned BOOLEAN DEFAULT FALSE,
+                PRIMARY KEY (token_id, collection_symbol),
+                FOREIGN KEY (collection_symbol) REFERENCES nft_collections(symbol)
+            )
+        `);
+        await this.adapter.query(`
+            CREATE TABLE IF NOT EXISTS nft_listings (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                token_id TEXT NOT NULL,
+                collection_symbol TEXT NOT NULL,
+                seller TEXT NOT NULL,
+                price TEXT NOT NULL,
+                currency TEXT NOT NULL DEFAULT 'HIVE',
+                listed_at DATETIME NOT NULL,
+                active BOOLEAN DEFAULT TRUE,
+                FOREIGN KEY (token_id, collection_symbol) REFERENCES nft_tokens(token_id, collection_symbol)
+            )
+        `);
+        await this.adapter.query(`
+            CREATE TABLE IF NOT EXISTS nft_transfers (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                token_id TEXT NOT NULL,
+                collection_symbol TEXT NOT NULL,
+                from_account TEXT NOT NULL,
+                to_account TEXT NOT NULL,
+                transfer_type TEXT NOT NULL,
+                price TEXT,
+                currency TEXT,
+                block_number INTEGER NOT NULL,
+                transaction_id TEXT NOT NULL,
+                timestamp DATETIME NOT NULL,
+                FOREIGN KEY (token_id, collection_symbol) REFERENCES nft_tokens(token_id, collection_symbol)
+            )
+        `);
+        await this.adapter.query(`
+            CREATE INDEX IF NOT EXISTS idx_nft_tokens_owner ON nft_tokens(owner);
+        `);
+        await this.adapter.query(`
+            CREATE INDEX IF NOT EXISTS idx_nft_tokens_collection ON nft_tokens(collection_symbol);
+        `);
+        await this.adapter.query(`
+            CREATE INDEX IF NOT EXISTS idx_nft_listings_active ON nft_listings(active, collection_symbol);
+        `);
+    }
+    async withTransaction(work) {
+        if (typeof this.adapter?.runInTransaction === 'function') {
+            return this.adapter.runInTransaction(work);
         }
+        return work(this.adapter);
     }
     async createCollection(payload, { sender }) {
         try {
             const { symbol, name, description = '', maxSupply, royalty = 0, baseUri = '', allowUpdates = true, updateableByOwner = false } = payload;
+            const normalizedMaxSupply = maxSupply ?? null;
             if (!symbol.match(/^[A-Z0-9]{1,20}$/)) {
                 throw new Error('Symbol must be 1-20 uppercase alphanumeric characters');
             }
@@ -123,23 +128,25 @@ class NFTContract {
             if (baseUri && baseUri.length > 500) {
                 throw new Error('Base URI must be 500 characters or less');
             }
-            const existingCollection = await this.adapter.query('SELECT symbol FROM nft_collections WHERE symbol = ?', [symbol]);
-            if (existingCollection && existingCollection.length > 0) {
-                throw new Error(`Collection with symbol ${symbol} already exists`);
-            }
-            await this.adapter.query(`
-                INSERT INTO nft_collections (symbol, name, description, creator, max_supply, royalty, base_uri, allow_updates, updateable_by_owner, created_at)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            `, [symbol, name, description, sender, maxSupply, royalty, baseUri, allowUpdates, updateableByOwner, new Date()]);
-            await this.adapter.addEvent(new Date(), CONTRACT_NAME, 'createCollection', payload, {
-                action: 'collection_created',
-                data: {
-                    symbol,
-                    name,
-                    creator: sender,
-                    maxSupply,
-                    royalty
+            await this.withTransaction(async (adapter) => {
+                const existingCollection = await adapter.query('SELECT symbol FROM nft_collections WHERE symbol = ?', [symbol]);
+                if (existingCollection && existingCollection.length > 0) {
+                    throw new Error(`Collection with symbol ${symbol} already exists`);
                 }
+                await adapter.query(`
+                    INSERT INTO nft_collections (symbol, name, description, creator, max_supply, royalty, base_uri, allow_updates, updateable_by_owner, created_at)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                `, [symbol, name, description, sender, normalizedMaxSupply, royalty, baseUri, allowUpdates, updateableByOwner, new Date()]);
+                await adapter.addEvent(new Date(), CONTRACT_NAME, 'createCollection', payload, {
+                    action: 'collection_created',
+                    data: {
+                        symbol,
+                        name,
+                        creator: sender,
+                        maxSupply,
+                        royalty
+                    }
+                });
             });
             console.log(`[NFTContract] Collection ${symbol} created by ${sender}`);
         }
@@ -168,30 +175,34 @@ class NFTContract {
             if (attributes && attributes.length > 1000) {
                 throw new Error('Attributes must be 1000 characters or less');
             }
-            if (collectionData.max_supply && collectionData.current_supply >= collectionData.max_supply) {
-                throw new Error('Collection has reached maximum supply');
-            }
-            const existingToken = await this.adapter.query('SELECT token_id FROM nft_tokens WHERE token_id = ? AND collection_symbol = ?', [tokenId, collectionSymbol]);
-            if (existingToken && existingToken.length > 0) {
-                throw new Error(`Token ${tokenId} already exists in collection ${collectionSymbol}`);
-            }
-            await this.adapter.query(`
-                INSERT INTO nft_tokens (token_id, collection_symbol, owner, metadata, attributes, minted_at, minted_by)
-                VALUES (?, ?, ?, ?, ?, ?, ?)
-            `, [tokenId, collectionSymbol, to, metadata, attributes, new Date(), sender]);
-            await this.adapter.query('UPDATE nft_collections SET current_supply = current_supply + 1 WHERE symbol = ?', [collectionSymbol]);
-            await this.adapter.query(`
-                INSERT INTO nft_transfers (token_id, collection_symbol, from_account, to_account, transfer_type, block_number, transaction_id, timestamp)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-            `, [tokenId, collectionSymbol, 'null', to, 'mint', this.blockNumber, this.transactionId, new Date()]);
-            await this.adapter.addEvent(new Date(), CONTRACT_NAME, 'mintNFT', payload, {
-                action: 'nft_minted',
-                data: {
-                    tokenId,
-                    collectionSymbol,
-                    to,
-                    mintedBy: sender
+            await this.withTransaction(async (adapter) => {
+                // Re-read supply inside the transaction to prevent race conditions
+                const collectionCheck = await adapter.query('SELECT max_supply, current_supply FROM nft_collections WHERE symbol = ?', [collectionSymbol]);
+                if (collectionCheck[0]?.max_supply && collectionCheck[0].current_supply >= collectionCheck[0].max_supply) {
+                    throw new Error('Collection has reached maximum supply');
+                }
+                const existingToken = await adapter.query('SELECT token_id FROM nft_tokens WHERE token_id = ? AND collection_symbol = ?', [tokenId, collectionSymbol]);
+                if (existingToken && existingToken.length > 0) {
+                    throw new Error(`Token ${tokenId} already exists in collection ${collectionSymbol}`);
                 }
+                await adapter.query(`
+                    INSERT INTO nft_tokens (token_id, collection_symbol, owner, metadata, attributes, minted_at, minted_by)
+                    VALUES (?, ?, ?, ?, ?, ?, ?)
+                `, [tokenId, collectionSymbol, to, metadata, attributes, new Date(), sender]);
+                await adapter.query('UPDATE nft_collections SET current_supply = current_supply + 1 WHERE symbol = ?', [collectionSymbol]);
+                await adapter.query(`
+                    INSERT INTO nft_transfers (token_id, collection_symbol, from_account, to_account, transfer_type, block_number, transaction_id, timestamp)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                `, [tokenId, collectionSymbol, 'null', to, 'mint', this.blockNumber, this.transactionId, new Date()]);
+                await adapter.addEvent(new Date(), CONTRACT_NAME, 'mintNFT', payload, {
+                    action: 'nft_minted',
+                    data: {
+                        tokenId,
+                        collectionSymbol,
+                        to,
+                        mintedBy: sender
+                    }
+                });
             });
             console.log(`[NFTContract] NFT ${tokenId} minted in collection ${collectionSymbol} to ${to}`);
         }
@@ -246,16 +257,18 @@ class NFTContract {
                 throw new Error('No update fields provided');
             }
             updateValues.push(tokenId, collectionSymbol);
-            await this.adapter.query(`UPDATE nft_tokens SET ${updateFields.join(', ')} WHERE token_id = ? AND collection_symbol = ?`, updateValues);
-            await this.adapter.addEvent(new Date(), CONTRACT_NAME, 'updateNFT', payload, {
-                action: 'nft_updated',
-                data: {
-                    tokenId,
-                    collectionSymbol,
-                    updatedBy: sender,
-                    metadata: metadata !== undefined ? metadata : 'unchanged',
-                    attributes: attributes !== undefined ? attributes : 'unchanged'
-                }
+            await this.withTransaction(async (adapter) => {
+                await adapter.query(`UPDATE nft_tokens SET ${updateFields.join(', ')} WHERE token_id = ? AND collection_symbol = ?`, updateValues);
+                await adapter.addEvent(new Date(), CONTRACT_NAME, 'updateNFT', payload, {
+                    action: 'nft_updated',
+                    data: {
+                        tokenId,
+                        collectionSymbol,
+                        updatedBy: sender,
+                        metadata: metadata !== undefined ? metadata : 'unchanged',
+                        attributes: attributes !== undefined ? attributes : 'unchanged'
+                    }
+                });
             });
             console.log(`[NFTContract] NFT ${tokenId} updated by ${sender}`);
         }
@@ -278,23 +291,25 @@ class NFTContract {
             if (tokenData.owner === to) {
                 throw new Error('Cannot transfer to the same address');
             }
-            const activeListings = await this.adapter.query('SELECT id FROM nft_listings WHERE token_id = ? AND collection_symbol = ? AND seller = ? AND active = TRUE', [tokenId, collectionSymbol, sender]);
-            if (activeListings && activeListings.length > 0) {
-                await this.adapter.query('UPDATE nft_listings SET active = FALSE WHERE token_id = ? AND collection_symbol = ? AND seller = ?', [tokenId, collectionSymbol, sender]);
-            }
-            await this.adapter.query('UPDATE nft_tokens SET owner = ? WHERE token_id = ? AND collection_symbol = ?', [to, tokenId, collectionSymbol]);
-            await this.adapter.query(`
-                INSERT INTO nft_transfers (token_id, collection_symbol, from_account, to_account, transfer_type, block_number, transaction_id, timestamp)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-            `, [tokenId, collectionSymbol, sender, to, 'transfer', this.blockNumber, this.transactionId, new Date()]);
-            await this.adapter.addEvent(new Date(), CONTRACT_NAME, 'transferNFT', payload, {
-                action: 'nft_transferred',
-                data: {
-                    tokenId,
-                    collectionSymbol,
-                    from: sender,
-                    to
+            await this.withTransaction(async (adapter) => {
+                const activeListings = await adapter.query('SELECT id FROM nft_listings WHERE token_id = ? AND collection_symbol = ? AND seller = ? AND active = TRUE', [tokenId, collectionSymbol, sender]);
+                if (activeListings && activeListings.length > 0) {
+                    await adapter.query('UPDATE nft_listings SET active = FALSE WHERE token_id = ? AND collection_symbol = ? AND seller = ?', [tokenId, collectionSymbol, sender]);
                 }
+                await adapter.query('UPDATE nft_tokens SET owner = ? WHERE token_id = ? AND collection_symbol = ?', [to, tokenId, collectionSymbol]);
+                await adapter.query(`
+                    INSERT INTO nft_transfers (token_id, collection_symbol, from_account, to_account, transfer_type, block_number, transaction_id, timestamp)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                `, [tokenId, collectionSymbol, sender, to, 'transfer', this.blockNumber, this.transactionId, new Date()]);
+                await adapter.addEvent(new Date(), CONTRACT_NAME, 'transferNFT', payload, {
+                    action: 'nft_transferred',
+                    data: {
+                        tokenId,
+                        collectionSymbol,
+                        from: sender,
+                        to
+                    }
+                });
             });
             console.log(`[NFTContract] NFT ${tokenId} transferred from ${sender} to ${to}`);
         }
@@ -314,20 +329,22 @@ class NFTContract {
             if (tokenData.owner !== sender) {
                 throw new Error('Only the token owner can burn the NFT');
             }
-            await this.adapter.query('UPDATE nft_listings SET active = FALSE WHERE token_id = ? AND collection_symbol = ?', [tokenId, collectionSymbol]);
-            await this.adapter.query('UPDATE nft_tokens SET burned = TRUE WHERE token_id = ? AND collection_symbol = ?', [tokenId, collectionSymbol]);
-            await this.adapter.query('UPDATE nft_collections SET current_supply = current_supply - 1 WHERE symbol = ?', [collectionSymbol]);
-            await this.adapter.query(`
-                INSERT INTO nft_transfers (token_id, collection_symbol, from_account, to_account, transfer_type, block_number, transaction_id, timestamp)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-            `, [tokenId, collectionSymbol, sender, 'null', 'burn', this.blockNumber, this.transactionId, new Date()]);
-            await this.adapter.addEvent(new Date(), CONTRACT_NAME, 'burnNFT', payload, {
-                action: 'nft_burned',
-                data: {
-                    tokenId,
-                    collectionSymbol,
-                    burnedBy: sender
-                }
+            await this.withTransaction(async (adapter) => {
+                await adapter.query('UPDATE nft_listings SET active = FALSE WHERE token_id = ? AND collection_symbol = ?', [tokenId, collectionSymbol]);
+                await adapter.query('UPDATE nft_tokens SET burned = TRUE WHERE token_id = ? AND collection_symbol = ?', [tokenId, collectionSymbol]);
+                await adapter.query('UPDATE nft_collections SET current_supply = current_supply - 1 WHERE symbol = ?', [collectionSymbol]);
+                await adapter.query(`
+                    INSERT INTO nft_transfers (token_id, collection_symbol, from_account, to_account, transfer_type, block_number, transaction_id, timestamp)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                `, [tokenId, collectionSymbol, sender, 'null', 'burn', this.blockNumber, this.transactionId, new Date()]);
+                await adapter.addEvent(new Date(), CONTRACT_NAME, 'burnNFT', payload, {
+                    action: 'nft_burned',
+                    data: {
+                        tokenId,
+                        collectionSymbol,
+                        burnedBy: sender
+                    }
+                });
             });
             console.log(`[NFTContract] NFT ${tokenId} burned by ${sender}`);
         }
@@ -354,20 +371,22 @@ class NFTContract {
             if (!['HIVE', 'HBD'].includes(currency)) {
                 throw new Error('Currency must be HIVE or HBD');
             }
-            await this.adapter.query('UPDATE nft_listings SET active = FALSE WHERE token_id = ? AND collection_symbol = ? AND seller = ?', [tokenId, collectionSymbol, sender]);
-            await this.adapter.query(`
-                INSERT INTO nft_listings (token_id, collection_symbol, seller, price, currency, listed_at)
-                VALUES (?, ?, ?, ?, ?, ?)
-            `, [tokenId, collectionSymbol, sender, price, currency, new Date()]);
-            await this.adapter.addEvent(new Date(), CONTRACT_NAME, 'listNFT', payload, {
-                action: 'nft_listed',
-                data: {
-                    tokenId,
-                    collectionSymbol,
-                    seller: sender,
-                    price,
-                    currency
-                }
+            await this.withTransaction(async (adapter) => {
+                await adapter.query('UPDATE nft_listings SET active = FALSE WHERE token_id = ? AND collection_symbol = ? AND seller = ?', [tokenId, collectionSymbol, sender]);
+                await adapter.query(`
+                    INSERT INTO nft_listings (token_id, collection_symbol, seller, price, currency, listed_at)
+                    VALUES (?, ?, ?, ?, ?, ?)
+                `, [tokenId, collectionSymbol, sender, price, currency, new Date()]);
+                await adapter.addEvent(new Date(), CONTRACT_NAME, 'listNFT', payload, {
+                    action: 'nft_listed',
+                    data: {
+                        tokenId,
+                        collectionSymbol,
+                        seller: sender,
+                        price,
+                        currency
+                    }
+                });
             });
             console.log(`[NFTContract] NFT ${tokenId} listed by ${sender} for ${price} ${currency}`);
         }
@@ -383,14 +402,16 @@ class NFTContract {
             if (!listing || listing.length === 0) {
                 throw new Error(`No active listing found for token ${tokenId}`);
             }
-            await this.adapter.query('UPDATE nft_listings SET active = FALSE WHERE token_id = ? AND collection_symbol = ? AND seller = ?', [tokenId, collectionSymbol, sender]);
-            await this.adapter.addEvent(new Date(), CONTRACT_NAME, 'unlistNFT', payload, {
-                action: 'nft_unlisted',
-                data: {
-                    tokenId,
-                    collectionSymbol,
-                    seller: sender
-                }
+            await this.withTransaction(async (adapter) => {
+                await adapter.query('UPDATE nft_listings SET active = FALSE WHERE token_id = ? AND collection_symbol = ? AND seller = ?', [tokenId, collectionSymbol, sender]);
+                await adapter.addEvent(new Date(), CONTRACT_NAME, 'unlistNFT', payload, {
+                    action: 'nft_unlisted',
+                    data: {
+                        tokenId,
+                        collectionSymbol,
+                        seller: sender
+                    }
+                });
             });
             console.log(`[NFTContract] NFT ${tokenId} unlisted by ${sender}`);
         }
@@ -421,32 +442,42 @@ class NFTContract {
             const collection = await this.adapter.query('SELECT royalty, creator FROM nft_collections WHERE symbol = ?', [collectionSymbol]);
             let royaltyAmount = new bignumber_js_1.default(0);
             let sellerAmount = paidAmount;
+            let royaltyRecipient = null;
             if (collection && collection.length > 0 && collection[0].royalty > 0) {
                 royaltyAmount = paidAmount.multipliedBy(collection[0].royalty);
                 sellerAmount = paidAmount.minus(royaltyAmount);
                 if (royaltyAmount.gt(0) && collection[0].creator !== listingData.seller) {
-                    console.log(`[NFTContract] Royalty payment: ${royaltyAmount.toFixed(3)} ${asset} to ${collection[0].creator}`);
+                    royaltyRecipient = collection[0].creator;
                 }
             }
-            await this.adapter.query('UPDATE nft_tokens SET owner = ? WHERE token_id = ? AND collection_symbol = ?', [sender, tokenId, collectionSymbol]);
-            await this.adapter.query('UPDATE nft_listings SET active = FALSE WHERE token_id = ? AND collection_symbol = ?', [tokenId, collectionSymbol]);
-            await this.adapter.query(`
-                INSERT INTO nft_transfers (token_id, collection_symbol, from_account, to_account, transfer_type, price, currency, block_number, transaction_id, timestamp)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            `, [tokenId, collectionSymbol, listingData.seller, sender, 'sale', amount, asset, this.blockNumber, this.transactionId, new Date()]);
-            await this.adapter.addEvent(new Date(), CONTRACT_NAME, 'buyNFT', payload, {
-                action: 'nft_sold',
-                data: {
-                    tokenId,
-                    collectionSymbol,
-                    seller: listingData.seller,
-                    buyer: sender,
-                    price: amount,
-                    currency: asset,
-                    royaltyAmount: royaltyAmount.toFixed(3),
-                    sellerAmount: sellerAmount.toFixed(3)
-                }
+            await this.withTransaction(async (adapter) => {
+                await adapter.query('UPDATE nft_tokens SET owner = ? WHERE token_id = ? AND collection_symbol = ?', [sender, tokenId, collectionSymbol]);
+                await adapter.query('UPDATE nft_listings SET active = FALSE WHERE token_id = ? AND collection_symbol = ?', [tokenId, collectionSymbol]);
+                await adapter.query(`
+                    INSERT INTO nft_transfers (token_id, collection_symbol, from_account, to_account, transfer_type, price, currency, block_number, transaction_id, timestamp)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                `, [tokenId, collectionSymbol, listingData.seller, sender, 'sale', amount, asset, this.blockNumber, this.transactionId, new Date()]);
+                await adapter.addEvent(new Date(), CONTRACT_NAME, 'buyNFT', payload, {
+                    action: 'nft_sold',
+                    data: {
+                        tokenId,
+                        collectionSymbol,
+                        seller: listingData.seller,
+                        buyer: sender,
+                        price: amount,
+                        currency: asset,
+                        royaltyAmount: royaltyAmount.toFixed(3),
+                        sellerAmount: sellerAmount.toFixed(3)
+                    }
+                });
             });
+            // Pay the seller using the Streamer's transfer method
+            const contractAccount = this._instance.config?.HIVE_ACCOUNT || 'beggars';
+            await this._instance.transferHiveTokens(contractAccount, listingData.seller, sellerAmount.toFixed(3), asset, `NFT sale: ${tokenId} from ${collectionSymbol}`);
+            // Pay royalty to creator if applicable
+            if (royaltyRecipient && royaltyAmount.gt(0)) {
+                await this._instance.transferHiveTokens(contractAccount, royaltyRecipient, royaltyAmount.toFixed(3), asset, `NFT royalty: ${tokenId} from ${collectionSymbol}`);
+            }
             console.log(`[NFTContract] NFT ${tokenId} sold to ${sender} for ${amount} ${asset}`);
         }
         catch (error) {
@@ -572,9 +603,22 @@ function createNFTContract(options = {}) {
             unlistNFT: (0, contract_1.action)((payload, ctx) => callWithContext(payload, ctx, instance.unlistNFT.bind(instance), { sender: ctx.sender }), {
                 trigger: 'custom_json'
             }),
-            buyNFT: (0, contract_1.action)((payload, ctx) => {
+            buyNFT: (0, contract_1.action)(async (payload, ctx) => {
                 const amountRaw = ctx.transfer?.rawAmount || '';
+                if (!amountRaw || !amountRaw.includes(' ')) {
+                    throw new Error('Invalid transfer amount format');
+                }
                 const [amount, asset] = amountRaw.split(' ');
+                if (!amount || !asset || isNaN(Number(amount))) {
+                    throw new Error('Invalid transfer amount');
+                }
+                // Verify the transfer actually happened on-chain
+                const transaction = await utils_1.Utils.getTransaction(instance._instance['client'], ctx.block.number, ctx.transaction.id);
+                const contractAccount = instance._instance.config?.HIVE_ACCOUNT || 'beggars';
+                const verified = await utils_1.Utils.verifyTransfer(transaction, ctx.sender, contractAccount, amountRaw);
+                if (!verified) {
+                    throw new Error('Transfer verification failed');
+                }
                 return callWithContext(payload, ctx, instance.buyNFT.bind(instance), {
                     sender: ctx.sender,
                     amount,