@rosen-bridge/rosen-extractor 8.1.0 → 10.0.0

package/dist/getRosenData/bitcoin-runes/bitcoinRunesEsploraRosenExtractor.js

@@ -0,0 +1,114 @@
+import AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';
+import { BITCOIN_RUNES_CHAIN } from '../const';
+import { address } from 'bitcoinjs-lib';
+import { parseAggregatedData } from './utils';
+import JsonBigInt from '@rosen-bridge/json-bigint';
+import { minUtxoValue } from './constants';
+export class BitcoinRunesEsploraRosenExtractor extends AbstractRosenDataExtractor {
+    chain = BITCOIN_RUNES_CHAIN;
+    lockScriptPubKey;
+    constructor(lockAddress, tokens, logger) {
+        super(lockAddress, tokens, logger);
+        this.lockScriptPubKey = address.toOutputScript(lockAddress).toString('hex');
+    }
+    /**
+     * extracts RosenData from given lock transaction in Esplora format
+     * @param transaction the lock transaction in Esplora format
+     */
+    extractRawData = (transaction) => {
+        const baseError = `No rosen data is found for tx [${transaction.txid}]`;
+        try {
+            // validate number of output boxes
+            const outputs = transaction.vout;
+            if (outputs.length < 5) {
+                this.logger.debug(baseError + `: Insufficient number of boxes`);
+                return undefined;
+            }
+            // validate lock conditions
+            const validLock = this.validateLock(outputs);
+            if (!validLock) {
+                this.logger.debug(baseError + `: Failed to find rosen lock utxo`);
+                return undefined;
+            }
+            // validate data conditions
+            const lockDataChunks = this.getLockDataChunks(outputs);
+            const lockData = this.lockDataFromChunks(lockDataChunks);
+            if (!lockData) {
+                this.logger.debug(baseError + `: Failed to extract rosen data from utxos`);
+                return undefined;
+            }
+            const fromAddress = `box:${transaction.vin[0].txid}.${transaction.vin[0].vout}`;
+            return {
+                toChain: lockData.toChain,
+                toAddress: lockData.toAddress,
+                bridgeFee: lockData.bridgeFee,
+                networkFee: lockData.networkFee,
+                fromAddress: fromAddress,
+                sourceChainTokenId: '',
+                amount: '',
+                targetChainTokenId: '',
+                sourceTxId: transaction.txid,
+            };
+        }
+        catch (e) {
+            this.logger.debug(`An error occurred while getting Runes rosen data from Esplora: ${e}`);
+            if (e instanceof Error && e.stack) {
+                this.logger.debug(e.stack);
+            }
+        }
+        return undefined;
+    };
+    /**
+     * extracts RosenData chunks from tx outputs
+     * @param outputs
+     * @return array of LockDataChunk
+     */
+    getLockDataChunks = (outputs) => {
+        const lockDataChunks = [];
+        for (let i = 0; i < 4; i++) {
+            // the first 3 boxes are expected to be change, OP_RETURN and lock address, which should not be considered for data chunks
+            for (let boxIndex = 3; boxIndex < outputs.length; boxIndex++) {
+                const output = outputs[boxIndex];
+                if (output.value !== minUtxoValue + i)
+                    continue; // wrong data index
+                if (output.scriptpubkey.slice(0, 4) !== '0014')
+                    continue; // not a native-segwit utxo
+                lockDataChunks.push({
+                    index: i,
+                    data: output.scriptpubkey.slice(4),
+                });
+                break;
+            }
+        }
+        return lockDataChunks;
+    };
+    /**
+     * combines lock data chunks into lock data object
+     * @param lockDataChunks
+     * @return lock data object or undefined
+     */
+    lockDataFromChunks = (lockDataChunks) => {
+        let lockData;
+        try {
+            lockData = parseAggregatedData(lockDataChunks.map((chunk) => chunk.data).join(''));
+        }
+        catch (e) {
+            this.logger.debug(`Failed to extract data from chunks [${JsonBigInt.stringify(lockDataChunks)}]: ${e}`);
+        }
+        return lockData;
+    };
+    /**
+     * check lock box exists in the tx outputs
+     * @param outputs
+     * @return boolean
+     */
+    validateLock = (outputs) => {
+        for (let i = 0; i < outputs.length; i++) {
+            if (outputs[i].scriptpubkey === this.lockScriptPubKey) {
+                return true;
+            }
+        }
+        return false;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bitcoinRunesEsploraRosenExtractor.js","sourceRoot":"","sources":["../../../lib/getRosenData/bitcoin-runes/bitcoinRunesEsploraRosenExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["import { RosenData } from '../abstract/types';\nimport AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';\nimport { BITCOIN_RUNES_CHAIN } from '../const';\nimport { BitcoinEsploraTransaction, EsploraTxOutput } from '../bitcoin/types';\nimport { TokenMap } from '@rosen-bridge/tokens';\nimport { AbstractLogger } from '@rosen-bridge/abstract-logger';\nimport { address } from 'bitcoinjs-lib';\nimport { parseAggregatedData } from './utils';\nimport JsonBigInt from '@rosen-bridge/json-bigint';\nimport { LockDataChunk } from './types';\nimport { MinimalOnChainRosenData } from '../../types';\nimport { minUtxoValue } from './constants';\n\nexport class BitcoinRunesEsploraRosenExtractor extends AbstractRosenDataExtractor<BitcoinEsploraTransaction> {\n  readonly chain = BITCOIN_RUNES_CHAIN;\n  protected lockScriptPubKey: string;\n\n  constructor(lockAddress: string, tokens: TokenMap, logger?: AbstractLogger) {\n    super(lockAddress, tokens, logger);\n    this.lockScriptPubKey = address.toOutputScript(lockAddress).toString('hex');\n  }\n\n  /**\n   * extracts RosenData from given lock transaction in Esplora format\n   * @param transaction the lock transaction in Esplora format\n   */\n  extractRawData = (\n    transaction: BitcoinEsploraTransaction,\n  ): RosenData | undefined => {\n    const baseError = `No rosen data is found for tx [${transaction.txid}]`;\n    try {\n      // validate number of output boxes\n      const outputs = transaction.vout;\n      if (outputs.length < 5) {\n        this.logger.debug(baseError + `: Insufficient number of boxes`);\n        return undefined;\n      }\n\n      // validate lock conditions\n      const validLock = this.validateLock(outputs);\n      if (!validLock) {\n        this.logger.debug(baseError + `: Failed to find rosen lock utxo`);\n        return undefined;\n      }\n\n      // validate data conditions\n      const lockDataChunks = this.getLockDataChunks(outputs);\n      const lockData = this.lockDataFromChunks(lockDataChunks);\n      if (!lockData) {\n        this.logger.debug(\n          baseError + `: Failed to extract rosen data from utxos`,\n        );\n        return undefined;\n      }\n\n      const fromAddress = `box:${transaction.vin[0].txid}.${transaction.vin[0].vout}`;\n      return {\n        toChain: lockData.toChain,\n        toAddress: lockData.toAddress,\n        bridgeFee: lockData.bridgeFee,\n        networkFee: lockData.networkFee,\n        fromAddress: fromAddress,\n        sourceChainTokenId: '',\n        amount: '',\n        targetChainTokenId: '',\n        sourceTxId: transaction.txid,\n      };\n    } catch (e) {\n      this.logger.debug(\n        `An error occurred while getting Runes rosen data from Esplora: ${e}`,\n      );\n      if (e instanceof Error && e.stack) {\n        this.logger.debug(e.stack);\n      }\n    }\n    return undefined;\n  };\n\n  /**\n   * extracts RosenData chunks from tx outputs\n   * @param outputs\n   * @return array of LockDataChunk\n   */\n  protected getLockDataChunks = (\n    outputs: EsploraTxOutput[],\n  ): LockDataChunk[] => {\n    const lockDataChunks: LockDataChunk[] = [];\n\n    for (let i = 0; i < 4; i++) {\n      // the first 3 boxes are expected to be change, OP_RETURN and lock address, which should not be considered for data chunks\n      for (let boxIndex = 3; boxIndex < outputs.length; boxIndex++) {\n        const output = outputs[boxIndex];\n\n        if (output.value !== minUtxoValue + i) continue; // wrong data index\n        if (output.scriptpubkey.slice(0, 4) !== '0014') continue; // not a native-segwit utxo\n\n        lockDataChunks.push({\n          index: i,\n          data: output.scriptpubkey.slice(4),\n        });\n        break;\n      }\n    }\n\n    return lockDataChunks;\n  };\n\n  /**\n   * combines lock data chunks into lock data object\n   * @param lockDataChunks\n   * @return lock data object or undefined\n   */\n  protected lockDataFromChunks = (\n    lockDataChunks: LockDataChunk[],\n  ): MinimalOnChainRosenData | undefined => {\n    let lockData: MinimalOnChainRosenData | undefined;\n\n    try {\n      lockData = parseAggregatedData(\n        lockDataChunks.map((chunk) => chunk.data).join(''),\n      );\n    } catch (e) {\n      this.logger.debug(\n        `Failed to extract data from chunks [${JsonBigInt.stringify(\n          lockDataChunks,\n        )}]: ${e}`,\n      );\n    }\n\n    return lockData;\n  };\n\n  /**\n   * check lock box exists in the tx outputs\n   * @param outputs\n   * @return boolean\n   */\n  protected validateLock = (outputs: EsploraTxOutput[]): boolean => {\n    for (let i = 0; i < outputs.length; i++) {\n      if (outputs[i].scriptpubkey === this.lockScriptPubKey) {\n        return true;\n      }\n    }\n    return false;\n  };\n}\n"]}

package/dist/{lib/getRosenData/runes/RunesRosenExtractor.d.ts → getRosenData/bitcoin-runes/bitcoinRunesRosenExtractor.d.ts}

@@ -1,17 +1,16 @@
-import { RosenData } from '../abstract/types';
-import AbstractRosenDataExtractor from '../abstract/AbstractRosenDataExtractor';
-import { BitcoinTxOutput } from '../bitcoin/types';
-import { TokenMap } from '@rosen-bridge/tokens';
 import { AbstractLogger } from '@rosen-bridge/abstract-logger';
-import { LockDataChunk } from './types';
+import { TokenMap } from '@rosen-bridge/tokens';
+import { RosenData, TokenTransformation } from '../abstract/types';
+import AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';
 import { MinimalOnChainRosenData } from '../../types';
-export declare class RunesRosenExtractor extends AbstractRosenDataExtractor<string> {
+import { BitcoinRunesTxOutput, LockDataChunk } from './types';
+export declare class BitcoinRunesRosenExtractor extends AbstractRosenDataExtractor<string> {
     readonly chain = "bitcoin-runes";
     protected lockScriptPubKey: string;
     constructor(lockAddress: string, tokens: TokenMap, logger?: AbstractLogger);
     /**
-     * extracts RosenData from given lock transaction in BitcoinTx format
-     * @param serializedTransaction stringified transaction in BitcoinTx format
+     * extracts RosenData from given lock transaction in BitcoinRunesTx format
+     * @param serializedTransaction stringified transaction in BitcoinRunesTx format
      */
     extractRawData: (serializedTransaction: string) => RosenData | undefined;
     /**
@@ -19,7 +18,7 @@ export declare class RunesRosenExtractor extends AbstractRosenDataExtractor<stri
      * @param outputs
      * @return array of LockDataChunk
      */
-    protected getLockDataChunks: (outputs: BitcoinTxOutput[]) => LockDataChunk[];
+    protected getLockDataChunks: (outputs: BitcoinRunesTxOutput[]) => LockDataChunk[];
     /**
      * combines lock data chunks into lock data object
      * @param lockDataChunks
@@ -27,10 +26,10 @@ export declare class RunesRosenExtractor extends AbstractRosenDataExtractor<stri
      */
     protected lockDataFromChunks: (lockDataChunks: LockDataChunk[]) => MinimalOnChainRosenData | undefined;
     /**
-     * check lock box exists in the tx outputs
-     * @param outputs
-     * @return boolean
+     * extracts and builds token transformation from UTXO and tokenMap
+     * @param box transaction output
+     * @param toChain event target chain
      */
-    protected validateLock: (outputs: BitcoinTxOutput[]) => boolean;
+    getAssetTransformation: (box: BitcoinRunesTxOutput, toChain: string) => TokenTransformation | undefined;
 }
-//# sourceMappingURL=RunesRosenExtractor.d.ts.map
+//# sourceMappingURL=bitcoinRunesRosenExtractor.d.ts.map

package/dist/getRosenData/bitcoin-runes/bitcoinRunesRosenExtractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitcoinRunesRosenExtractor.d.ts","sourceRoot":"","sources":["../../../lib/getRosenData/bitcoin-runes/bitcoinRunesRosenExtractor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD,OAAO,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,0BAA0B,MAAM,wCAAwC,CAAC;AAEhF,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAEtD,OAAO,EAAE,oBAAoB,EAAkB,aAAa,EAAE,MAAM,SAAS,CAAC;AAG9E,qBAAa,0BAA2B,SAAQ,0BAA0B,CAAC,MAAM,CAAC;IAChF,QAAQ,CAAC,KAAK,mBAAuB;IACrC,SAAS,CAAC,gBAAgB,EAAE,MAAM,CAAC;gBAEvB,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,cAAc;IAK1E;;;OAGG;IACH,cAAc,GAAI,uBAAuB,MAAM,KAAG,SAAS,GAAG,SAAS,CAwErE;IAEF;;;;OAIG;IACH,SAAS,CAAC,iBAAiB,GACzB,SAAS,oBAAoB,EAAE,KAC9B,aAAa,EAAE,CAoBhB;IAEF;;;;OAIG;IACH,SAAS,CAAC,kBAAkB,GAC1B,gBAAgB,aAAa,EAAE,KAC9B,uBAAuB,GAAG,SAAS,CAgBpC;IAEF;;;;OAIG;IACH,sBAAsB,GACpB,KAAK,oBAAoB,EACzB,SAAS,MAAM,KACd,mBAAmB,GAAG,SAAS,CAchC;CACH"}

package/dist/getRosenData/bitcoin-runes/bitcoinRunesRosenExtractor.js

@@ -0,0 +1,138 @@
+import { address } from 'bitcoinjs-lib';
+import JsonBigInt from '@rosen-bridge/json-bigint';
+import AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';
+import { BITCOIN_RUNES_CHAIN } from '../const';
+import { minUtxoValue } from './constants';
+import { parseAggregatedData } from './utils';
+export class BitcoinRunesRosenExtractor extends AbstractRosenDataExtractor {
+    chain = BITCOIN_RUNES_CHAIN;
+    lockScriptPubKey;
+    constructor(lockAddress, tokens, logger) {
+        super(lockAddress, tokens, logger);
+        this.lockScriptPubKey = address.toOutputScript(lockAddress).toString('hex');
+    }
+    /**
+     * extracts RosenData from given lock transaction in BitcoinRunesTx format
+     * @param serializedTransaction stringified transaction in BitcoinRunesTx format
+     */
+    extractRawData = (serializedTransaction) => {
+        let transaction;
+        try {
+            transaction = JsonBigInt.parse(serializedTransaction);
+        }
+        catch (e) {
+            throw new Error(`Failed to parse transaction json to BitcoinRunesTx format while extracting rosen data: ${e}`);
+        }
+        const baseError = `No rosen data is found for tx [${transaction.id}]`;
+        try {
+            // validate number of output boxes
+            const outputs = transaction.outputs;
+            if (outputs.length < 5) {
+                this.logger.debug(baseError + `: Insufficient number of boxes`);
+                return undefined;
+            }
+            // validate data conditions
+            const lockDataChunks = this.getLockDataChunks(outputs);
+            const lockData = this.lockDataFromChunks(lockDataChunks);
+            if (!lockData) {
+                this.logger.debug(baseError + `: Failed to extract rosen data from utxos`);
+                return undefined;
+            }
+            // validate lock conditions
+            let validLock = false;
+            let assetTransformation;
+            for (let i = 0; i < outputs.length; i++) {
+                if (outputs[i].scriptPubKey === this.lockScriptPubKey) {
+                    assetTransformation = this.getAssetTransformation(outputs[i], lockData.toChain);
+                    if (assetTransformation) {
+                        validLock = true;
+                        break;
+                    }
+                }
+            }
+            if (!validLock || !assetTransformation) {
+                this.logger.debug(baseError + `: Failed to find rosen asset transformation`);
+                return undefined;
+            }
+            const fromAddress = `box:${transaction.inputs[0].txId}.${transaction.inputs[0].index}`;
+            return {
+                toChain: lockData.toChain,
+                toAddress: lockData.toAddress,
+                bridgeFee: lockData.bridgeFee,
+                networkFee: lockData.networkFee,
+                fromAddress: fromAddress,
+                sourceChainTokenId: assetTransformation.from,
+                amount: assetTransformation.amount,
+                targetChainTokenId: assetTransformation.to,
+                sourceTxId: transaction.id,
+            };
+        }
+        catch (e) {
+            this.logger.debug(`An error occurred while getting Runes rosen data from BitcoinRunesTx: ${e}`);
+            if (e instanceof Error && e.stack) {
+                this.logger.debug(e.stack);
+            }
+        }
+        return undefined;
+    };
+    /**
+     * extracts RosenData chunks from tx outputs
+     * @param outputs
+     * @return array of LockDataChunk
+     */
+    getLockDataChunks = (outputs) => {
+        const lockDataChunks = [];
+        for (let i = 0; i < 4; i++) {
+            // the first 3 boxes are expected to be change, OP_RETURN and lock address, which should not be considered for data chunks
+            for (let boxIndex = 3; boxIndex < outputs.length; boxIndex++) {
+                const output = outputs[boxIndex];
+                if (output.value !== BigInt(minUtxoValue) + BigInt(i))
+                    continue; // wrong data index
+                if (output.scriptPubKey.slice(0, 4) !== '0014')
+                    continue; // not a native-segwit utxo
+                lockDataChunks.push({
+                    index: i,
+                    data: output.scriptPubKey.slice(4),
+                });
+                break;
+            }
+        }
+        return lockDataChunks;
+    };
+    /**
+     * combines lock data chunks into lock data object
+     * @param lockDataChunks
+     * @return lock data object or undefined
+     */
+    lockDataFromChunks = (lockDataChunks) => {
+        let lockData;
+        try {
+            lockData = parseAggregatedData(lockDataChunks.map((chunk) => chunk.data).join(''));
+        }
+        catch (e) {
+            this.logger.debug(`Failed to extract data from chunks [${JsonBigInt.stringify(lockDataChunks)}]: ${e}`);
+        }
+        return lockData;
+    };
+    /**
+     * extracts and builds token transformation from UTXO and tokenMap
+     * @param box transaction output
+     * @param toChain event target chain
+     */
+    getAssetTransformation = (box, toChain) => {
+        // try to build transformation using locked assets
+        for (const asset of box.runes) {
+            const token = this.tokens.search(BITCOIN_RUNES_CHAIN, {
+                tokenId: asset.runeId,
+            });
+            if (token.length > 0 && Object.hasOwn(token[0], toChain))
+                return {
+                    from: this.tokens.getID(token[0], BITCOIN_RUNES_CHAIN),
+                    to: this.tokens.getID(token[0], toChain),
+                    amount: asset.quantity.toString(),
+                };
+        }
+        return undefined;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bitcoinRunesRosenExtractor.js","sourceRoot":"","sources":["../../../lib/getRosenData/bitcoin-runes/bitcoinRunesRosenExtractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAGxC,OAAO,UAAU,MAAM,2BAA2B,CAAC;AAEnD,OAAO,0BAA0B,MAAM,wCAAwC,CAAC;AAChF,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAE/C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAE9C,MAAM,OAAO,0BAA2B,SAAQ,0BAAkC;IACvE,KAAK,GAAG,mBAAmB,CAAC;IAC3B,gBAAgB,CAAS;IAEnC,YAAY,WAAmB,EAAE,MAAgB,EAAE,MAAuB;QACxE,KAAK,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QACnC,IAAI,CAAC,gBAAgB,GAAG,OAAO,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC9E,CAAC;IAED;;;OAGG;IACH,cAAc,GAAG,CAAC,qBAA6B,EAAyB,EAAE;QACxE,IAAI,WAA2B,CAAC;QAChC,IAAI,CAAC;YACH,WAAW,GAAG,UAAU,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC;QACxD,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CACb,0FAA0F,CAAC,EAAE,CAC9F,CAAC;QACJ,CAAC;QACD,MAAM,SAAS,GAAG,kCAAkC,WAAW,CAAC,EAAE,GAAG,CAAC;QACtE,IAAI,CAAC;YACH,kCAAkC;YAClC,MAAM,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC;YACpC,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACvB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,GAAG,gCAAgC,CAAC,CAAC;gBAChE,OAAO,SAAS,CAAC;YACnB,CAAC;YAED,2BAA2B;YAC3B,MAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;YACvD,MAAM,QAAQ,GAAG,IAAI,CAAC,kBAAkB,CAAC,cAAc,CAAC,CAAC;YAEzD,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,SAAS,GAAG,2CAA2C,CACxD,CAAC;gBACF,OAAO,SAAS,CAAC;YACnB,CAAC;YAED,2BAA2B;YAC3B,IAAI,SAAS,GAAG,KAAK,CAAC;YACtB,IAAI,mBAAoD,CAAC;YACzD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBACxC,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC,YAAY,KAAK,IAAI,CAAC,gBAAgB,EAAE,CAAC;oBACtD,mBAAmB,GAAG,IAAI,CAAC,sBAAsB,CAC/C,OAAO,CAAC,CAAC,CAAC,EACV,QAAQ,CAAC,OAAO,CACjB,CAAC;oBACF,IAAI,mBAAmB,EAAE,CAAC;wBACxB,SAAS,GAAG,IAAI,CAAC;wBACjB,MAAM;oBACR,CAAC;gBACH,CAAC;YACH,CAAC;YACD,IAAI,CAAC,SAAS,IAAI,CAAC,mBAAmB,EAAE,CAAC;gBACvC,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,SAAS,GAAG,6CAA6C,CAC1D,CAAC;gBACF,OAAO,SAAS,CAAC;YACnB,CAAC;YAED,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC;YACvF,OAAO;gBACL,OAAO,EAAE,QAAQ,CAAC,OAAO;gBACzB,SAAS,EAAE,QAAQ,CAAC,SAAS;gBAC7B,SAAS,EAAE,QAAQ,CAAC,SAAS;gBAC7B,UAAU,EAAE,QAAQ,CAAC,UAAU;gBAC/B,WAAW,EAAE,WAAW;gBACxB,kBAAkB,EAAE,mBAAmB,CAAC,IAAI;gBAC5C,MAAM,EAAE,mBAAmB,CAAC,MAAM;gBAClC,kBAAkB,EAAE,mBAAmB,CAAC,EAAE;gBAC1C,UAAU,EAAE,WAAW,CAAC,EAAE;aAC3B,CAAC;QACJ,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,yEAAyE,CAAC,EAAE,CAC7E,CAAC;YACF,IAAI,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC;gBAClC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;YAC7B,CAAC;QACH,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC;IAEF;;;;OAIG;IACO,iBAAiB,GAAG,CAC5B,OAA+B,EACd,EAAE;QACnB,MAAM,cAAc,GAAoB,EAAE,CAAC;QAE3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3B,0HAA0H;YAC1H,KAAK,IAAI,QAAQ,GAAG,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,CAAC;gBAC7D,MAAM,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;gBAEjC,IAAI,MAAM,CAAC,KAAK,KAAK,MAAM,CAAC,YAAY,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;oBAAE,SAAS,CAAC,mBAAmB;gBACpF,IAAI,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM;oBAAE,SAAS,CAAC,2BAA2B;gBAErF,cAAc,CAAC,IAAI,CAAC;oBAClB,KAAK,EAAE,CAAC;oBACR,IAAI,EAAE,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;iBACnC,CAAC,CAAC;gBACH,MAAM;YACR,CAAC;QACH,CAAC;QAED,OAAO,cAAc,CAAC;IACxB,CAAC,CAAC;IAEF;;;;OAIG;IACO,kBAAkB,GAAG,CAC7B,cAA+B,EACM,EAAE;QACvC,IAAI,QAA6C,CAAC;QAElD,IAAI,CAAC;YACH,QAAQ,GAAG,mBAAmB,CAC5B,cAAc,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CACnD,CAAC;QACJ,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,uCAAuC,UAAU,CAAC,SAAS,CACzD,cAAc,CACf,MAAM,CAAC,EAAE,CACX,CAAC;QACJ,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC,CAAC;IAEF;;;;OAIG;IACH,sBAAsB,GAAG,CACvB,GAAyB,EACzB,OAAe,EACkB,EAAE;QACnC,kDAAkD;QAClD,KAAK,MAAM,KAAK,IAAI,GAAG,CAAC,KAAK,EAAE,CAAC;YAC9B,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,mBAAmB,EAAE;gBACpD,OAAO,EAAE,KAAK,CAAC,MAAM;aACtB,CAAC,CAAC;YACH,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC;gBACtD,OAAO;oBACL,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,mBAAmB,CAAC;oBACtD,EAAE,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC;oBACxC,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,QAAQ,EAAE;iBAClC,CAAC;QACN,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC;CACH","sourcesContent":["import { address } from 'bitcoinjs-lib';\nimport { AbstractLogger } from '@rosen-bridge/abstract-logger';\nimport { TokenMap } from '@rosen-bridge/tokens';\nimport JsonBigInt from '@rosen-bridge/json-bigint';\nimport { RosenData, TokenTransformation } from '../abstract/types';\nimport AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';\nimport { BITCOIN_RUNES_CHAIN } from '../const';\nimport { MinimalOnChainRosenData } from '../../types';\nimport { minUtxoValue } from './constants';\nimport { BitcoinRunesTxOutput, BitcoinRunesTx, LockDataChunk } from './types';\nimport { parseAggregatedData } from './utils';\n\nexport class BitcoinRunesRosenExtractor extends AbstractRosenDataExtractor<string> {\n  readonly chain = BITCOIN_RUNES_CHAIN;\n  protected lockScriptPubKey: string;\n\n  constructor(lockAddress: string, tokens: TokenMap, logger?: AbstractLogger) {\n    super(lockAddress, tokens, logger);\n    this.lockScriptPubKey = address.toOutputScript(lockAddress).toString('hex');\n  }\n\n  /**\n   * extracts RosenData from given lock transaction in BitcoinRunesTx format\n   * @param serializedTransaction stringified transaction in BitcoinRunesTx format\n   */\n  extractRawData = (serializedTransaction: string): RosenData | undefined => {\n    let transaction: BitcoinRunesTx;\n    try {\n      transaction = JsonBigInt.parse(serializedTransaction);\n    } catch (e) {\n      throw new Error(\n        `Failed to parse transaction json to BitcoinRunesTx format while extracting rosen data: ${e}`,\n      );\n    }\n    const baseError = `No rosen data is found for tx [${transaction.id}]`;\n    try {\n      // validate number of output boxes\n      const outputs = transaction.outputs;\n      if (outputs.length < 5) {\n        this.logger.debug(baseError + `: Insufficient number of boxes`);\n        return undefined;\n      }\n\n      // validate data conditions\n      const lockDataChunks = this.getLockDataChunks(outputs);\n      const lockData = this.lockDataFromChunks(lockDataChunks);\n\n      if (!lockData) {\n        this.logger.debug(\n          baseError + `: Failed to extract rosen data from utxos`,\n        );\n        return undefined;\n      }\n\n      // validate lock conditions\n      let validLock = false;\n      let assetTransformation: TokenTransformation | undefined;\n      for (let i = 0; i < outputs.length; i++) {\n        if (outputs[i].scriptPubKey === this.lockScriptPubKey) {\n          assetTransformation = this.getAssetTransformation(\n            outputs[i],\n            lockData.toChain,\n          );\n          if (assetTransformation) {\n            validLock = true;\n            break;\n          }\n        }\n      }\n      if (!validLock || !assetTransformation) {\n        this.logger.debug(\n          baseError + `: Failed to find rosen asset transformation`,\n        );\n        return undefined;\n      }\n\n      const fromAddress = `box:${transaction.inputs[0].txId}.${transaction.inputs[0].index}`;\n      return {\n        toChain: lockData.toChain,\n        toAddress: lockData.toAddress,\n        bridgeFee: lockData.bridgeFee,\n        networkFee: lockData.networkFee,\n        fromAddress: fromAddress,\n        sourceChainTokenId: assetTransformation.from,\n        amount: assetTransformation.amount,\n        targetChainTokenId: assetTransformation.to,\n        sourceTxId: transaction.id,\n      };\n    } catch (e) {\n      this.logger.debug(\n        `An error occurred while getting Runes rosen data from BitcoinRunesTx: ${e}`,\n      );\n      if (e instanceof Error && e.stack) {\n        this.logger.debug(e.stack);\n      }\n    }\n    return undefined;\n  };\n\n  /**\n   * extracts RosenData chunks from tx outputs\n   * @param outputs\n   * @return array of LockDataChunk\n   */\n  protected getLockDataChunks = (\n    outputs: BitcoinRunesTxOutput[],\n  ): LockDataChunk[] => {\n    const lockDataChunks: LockDataChunk[] = [];\n\n    for (let i = 0; i < 4; i++) {\n      // the first 3 boxes are expected to be change, OP_RETURN and lock address, which should not be considered for data chunks\n      for (let boxIndex = 3; boxIndex < outputs.length; boxIndex++) {\n        const output = outputs[boxIndex];\n\n        if (output.value !== BigInt(minUtxoValue) + BigInt(i)) continue; // wrong data index\n        if (output.scriptPubKey.slice(0, 4) !== '0014') continue; // not a native-segwit utxo\n\n        lockDataChunks.push({\n          index: i,\n          data: output.scriptPubKey.slice(4),\n        });\n        break;\n      }\n    }\n\n    return lockDataChunks;\n  };\n\n  /**\n   * combines lock data chunks into lock data object\n   * @param lockDataChunks\n   * @return lock data object or undefined\n   */\n  protected lockDataFromChunks = (\n    lockDataChunks: LockDataChunk[],\n  ): MinimalOnChainRosenData | undefined => {\n    let lockData: MinimalOnChainRosenData | undefined;\n\n    try {\n      lockData = parseAggregatedData(\n        lockDataChunks.map((chunk) => chunk.data).join(''),\n      );\n    } catch (e) {\n      this.logger.debug(\n        `Failed to extract data from chunks [${JsonBigInt.stringify(\n          lockDataChunks,\n        )}]: ${e}`,\n      );\n    }\n\n    return lockData;\n  };\n\n  /**\n   * extracts and builds token transformation from UTXO and tokenMap\n   * @param box transaction output\n   * @param toChain event target chain\n   */\n  getAssetTransformation = (\n    box: BitcoinRunesTxOutput,\n    toChain: string,\n  ): TokenTransformation | undefined => {\n    // try to build transformation using locked assets\n    for (const asset of box.runes) {\n      const token = this.tokens.search(BITCOIN_RUNES_CHAIN, {\n        tokenId: asset.runeId,\n      });\n      if (token.length > 0 && Object.hasOwn(token[0], toChain))\n        return {\n          from: this.tokens.getID(token[0], BITCOIN_RUNES_CHAIN),\n          to: this.tokens.getID(token[0], toChain),\n          amount: asset.quantity.toString(),\n        };\n    }\n    return undefined;\n  };\n}\n"]}

package/dist/getRosenData/{runes/RunesRpcRosenExtractor.d.ts → bitcoin-runes/bitcoinRunesRpcRosenExtractor.d.ts}

@@ -1,11 +1,11 @@
 import { RosenData } from '../abstract/types';
-import AbstractRosenDataExtractor from '../abstract/AbstractRosenDataExtractor';
+import AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';
 import { BitcoinRpcTransaction, BitcoinRpcTxOutput } from '../bitcoin/types';
 import { TokenMap } from '@rosen-bridge/tokens';
 import { AbstractLogger } from '@rosen-bridge/abstract-logger';
 import { LockDataChunk } from './types';
 import { MinimalOnChainRosenData } from '../../types';
-export declare class RunesRpcRosenExtractor extends AbstractRosenDataExtractor<BitcoinRpcTransaction> {
+export declare class BitcoinRunesRpcRosenExtractor extends AbstractRosenDataExtractor<BitcoinRpcTransaction> {
     readonly chain = "bitcoin-runes";
     protected lockScriptPubKey: string;
     constructor(lockAddress: string, tokens: TokenMap, logger?: AbstractLogger);
@@ -33,4 +33,4 @@ export declare class RunesRpcRosenExtractor extends AbstractRosenDataExtractor<B
      */
     protected validateLock: (outputs: BitcoinRpcTxOutput[]) => boolean;
 }
-//# sourceMappingURL=RunesRpcRosenExtractor.d.ts.map
+//# sourceMappingURL=bitcoinRunesRpcRosenExtractor.d.ts.map

package/dist/getRosenData/bitcoin-runes/bitcoinRunesRpcRosenExtractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitcoinRunesRpcRosenExtractor.d.ts","sourceRoot":"","sources":["../../../lib/getRosenData/bitcoin-runes/bitcoinRunesRpcRosenExtractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,0BAA0B,MAAM,wCAAwC,CAAC;AAEhF,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC7E,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAI/D,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAGtD,qBAAa,6BAA8B,SAAQ,0BAA0B,CAAC,qBAAqB,CAAC;IAClG,QAAQ,CAAC,KAAK,mBAAuB;IACrC,SAAS,CAAC,gBAAgB,EAAE,MAAM,CAAC;gBAEvB,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,cAAc;IAK1E;;;OAGG;IACH,cAAc,GACZ,aAAa,qBAAqB,KACjC,SAAS,GAAG,SAAS,CAkDtB;IAEF;;;;OAIG;IACH,SAAS,CAAC,iBAAiB,GACzB,SAAS,kBAAkB,EAAE,KAC5B,aAAa,EAAE,CAoBhB;IAEF;;;;OAIG;IACH,SAAS,CAAC,kBAAkB,GAC1B,gBAAgB,aAAa,EAAE,KAC9B,uBAAuB,GAAG,SAAS,CAgBpC;IAEF;;;;OAIG;IACH,SAAS,CAAC,YAAY,GAAI,SAAS,kBAAkB,EAAE,KAAG,OAAO,CAO/D;CACH"}

package/dist/getRosenData/bitcoin-runes/bitcoinRunesRpcRosenExtractor.js

@@ -0,0 +1,114 @@
+import AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';
+import { BITCOIN_RUNES_CHAIN } from '../const';
+import { address } from 'bitcoinjs-lib';
+import { parseAggregatedData } from './utils';
+import JsonBigInt from '@rosen-bridge/json-bigint';
+import { minUtxoValue } from './constants';
+export class BitcoinRunesRpcRosenExtractor extends AbstractRosenDataExtractor {
+    chain = BITCOIN_RUNES_CHAIN;
+    lockScriptPubKey;
+    constructor(lockAddress, tokens, logger) {
+        super(lockAddress, tokens, logger);
+        this.lockScriptPubKey = address.toOutputScript(lockAddress).toString('hex');
+    }
+    /**
+     * extracts RosenData from given lock transaction in Rpc format
+     * @param transaction the lock transaction in Rpc format
+     */
+    extractRawData = (transaction) => {
+        const baseError = `No rosen data is found for tx [${transaction.txid}]`;
+        try {
+            // validate number of output boxes
+            const outputs = transaction.vout;
+            if (outputs.length < 5) {
+                this.logger.debug(baseError + `: Insufficient number of boxes`);
+                return undefined;
+            }
+            // validate lock conditions
+            const validLock = this.validateLock(outputs);
+            if (!validLock) {
+                this.logger.debug(baseError + `: Failed to find rosen lock utxo`);
+                return undefined;
+            }
+            // validate data conditions
+            const lockDataChunks = this.getLockDataChunks(outputs);
+            const lockData = this.lockDataFromChunks(lockDataChunks);
+            if (!lockData) {
+                this.logger.debug(baseError + `: Failed to extract rosen data from utxos`);
+                return undefined;
+            }
+            const fromAddress = `box:${transaction.vin[0].txid}.${transaction.vin[0].vout}`;
+            return {
+                toChain: lockData.toChain,
+                toAddress: lockData.toAddress,
+                bridgeFee: lockData.bridgeFee,
+                networkFee: lockData.networkFee,
+                fromAddress: fromAddress,
+                sourceChainTokenId: '',
+                amount: '',
+                targetChainTokenId: '',
+                sourceTxId: transaction.txid,
+            };
+        }
+        catch (e) {
+            this.logger.debug(`An error occurred while getting Runes rosen data from Rpc: ${e}`);
+            if (e instanceof Error && e.stack) {
+                this.logger.debug(e.stack);
+            }
+        }
+        return undefined;
+    };
+    /**
+     * extracts RosenData chunks from tx outputs
+     * @param outputs
+     * @return array of LockDataChunk
+     */
+    getLockDataChunks = (outputs) => {
+        const lockDataChunks = [];
+        for (let i = 0; i < 4; i++) {
+            // the first 3 boxes are expected to be change, OP_RETURN and lock address, which should not be considered for data chunks
+            for (let boxIndex = 3; boxIndex < outputs.length; boxIndex++) {
+                const output = outputs[boxIndex];
+                if (output.value * 10 ** 8 !== minUtxoValue + i)
+                    continue; // wrong data index
+                if (output.scriptPubKey.hex.slice(0, 4) !== '0014')
+                    continue; // not a native-segwit utxo
+                lockDataChunks.push({
+                    index: i,
+                    data: output.scriptPubKey.hex.slice(4),
+                });
+                break;
+            }
+        }
+        return lockDataChunks;
+    };
+    /**
+     * combines lock data chunks into lock data object
+     * @param lockDataChunks
+     * @return lock data object or undefined
+     */
+    lockDataFromChunks = (lockDataChunks) => {
+        let lockData;
+        try {
+            lockData = parseAggregatedData(lockDataChunks.map((chunk) => chunk.data).join(''));
+        }
+        catch (e) {
+            this.logger.debug(`Failed to extract data from chunks [${JsonBigInt.stringify(lockDataChunks)}]: ${e}`);
+        }
+        return lockData;
+    };
+    /**
+     * check lock box exists in the tx outputs
+     * @param outputs
+     * @return boolean
+     */
+    validateLock = (outputs) => {
+        for (let i = 0; i < outputs.length; i++) {
+            if (outputs[i].scriptPubKey.hex === this.lockScriptPubKey) {
+                return true;
+            }
+        }
+        return false;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bitcoinRunesRpcRosenExtractor.js","sourceRoot":"","sources":["../../../lib/getRosenData/bitcoin-runes/bitcoinRunesRpcRosenExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["import { RosenData } from '../abstract/types';\nimport AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';\nimport { BITCOIN_RUNES_CHAIN } from '../const';\nimport { BitcoinRpcTransaction, BitcoinRpcTxOutput } from '../bitcoin/types';\nimport { TokenMap } from '@rosen-bridge/tokens';\nimport { AbstractLogger } from '@rosen-bridge/abstract-logger';\nimport { address } from 'bitcoinjs-lib';\nimport { parseAggregatedData } from './utils';\nimport JsonBigInt from '@rosen-bridge/json-bigint';\nimport { LockDataChunk } from './types';\nimport { MinimalOnChainRosenData } from '../../types';\nimport { minUtxoValue } from './constants';\n\nexport class BitcoinRunesRpcRosenExtractor extends AbstractRosenDataExtractor<BitcoinRpcTransaction> {\n  readonly chain = BITCOIN_RUNES_CHAIN;\n  protected lockScriptPubKey: string;\n\n  constructor(lockAddress: string, tokens: TokenMap, logger?: AbstractLogger) {\n    super(lockAddress, tokens, logger);\n    this.lockScriptPubKey = address.toOutputScript(lockAddress).toString('hex');\n  }\n\n  /**\n   * extracts RosenData from given lock transaction in Rpc format\n   * @param transaction the lock transaction in Rpc format\n   */\n  extractRawData = (\n    transaction: BitcoinRpcTransaction,\n  ): RosenData | undefined => {\n    const baseError = `No rosen data is found for tx [${transaction.txid}]`;\n    try {\n      // validate number of output boxes\n      const outputs = transaction.vout;\n      if (outputs.length < 5) {\n        this.logger.debug(baseError + `: Insufficient number of boxes`);\n        return undefined;\n      }\n\n      // validate lock conditions\n      const validLock = this.validateLock(outputs);\n\n      if (!validLock) {\n        this.logger.debug(baseError + `: Failed to find rosen lock utxo`);\n        return undefined;\n      }\n\n      // validate data conditions\n      const lockDataChunks = this.getLockDataChunks(outputs);\n      const lockData = this.lockDataFromChunks(lockDataChunks);\n\n      if (!lockData) {\n        this.logger.debug(\n          baseError + `: Failed to extract rosen data from utxos`,\n        );\n        return undefined;\n      }\n\n      const fromAddress = `box:${transaction.vin[0].txid}.${transaction.vin[0].vout}`;\n      return {\n        toChain: lockData.toChain,\n        toAddress: lockData.toAddress,\n        bridgeFee: lockData.bridgeFee,\n        networkFee: lockData.networkFee,\n        fromAddress: fromAddress,\n        sourceChainTokenId: '',\n        amount: '',\n        targetChainTokenId: '',\n        sourceTxId: transaction.txid,\n      };\n    } catch (e) {\n      this.logger.debug(\n        `An error occurred while getting Runes rosen data from Rpc: ${e}`,\n      );\n      if (e instanceof Error && e.stack) {\n        this.logger.debug(e.stack);\n      }\n    }\n    return undefined;\n  };\n\n  /**\n   * extracts RosenData chunks from tx outputs\n   * @param outputs\n   * @return array of LockDataChunk\n   */\n  protected getLockDataChunks = (\n    outputs: BitcoinRpcTxOutput[],\n  ): LockDataChunk[] => {\n    const lockDataChunks: LockDataChunk[] = [];\n\n    for (let i = 0; i < 4; i++) {\n      // the first 3 boxes are expected to be change, OP_RETURN and lock address, which should not be considered for data chunks\n      for (let boxIndex = 3; boxIndex < outputs.length; boxIndex++) {\n        const output = outputs[boxIndex];\n\n        if (output.value * 10 ** 8 !== minUtxoValue + i) continue; // wrong data index\n        if (output.scriptPubKey.hex.slice(0, 4) !== '0014') continue; // not a native-segwit utxo\n\n        lockDataChunks.push({\n          index: i,\n          data: output.scriptPubKey.hex.slice(4),\n        });\n        break;\n      }\n    }\n\n    return lockDataChunks;\n  };\n\n  /**\n   * combines lock data chunks into lock data object\n   * @param lockDataChunks\n   * @return lock data object or undefined\n   */\n  protected lockDataFromChunks = (\n    lockDataChunks: LockDataChunk[],\n  ): MinimalOnChainRosenData | undefined => {\n    let lockData: MinimalOnChainRosenData | undefined;\n\n    try {\n      lockData = parseAggregatedData(\n        lockDataChunks.map((chunk) => chunk.data).join(''),\n      );\n    } catch (e) {\n      this.logger.debug(\n        `Failed to extract data from chunks [${JsonBigInt.stringify(\n          lockDataChunks,\n        )}]: ${e}`,\n      );\n    }\n\n    return lockData;\n  };\n\n  /**\n   * check lock box exists in the tx outputs\n   * @param outputs\n   * @return boolean\n   */\n  protected validateLock = (outputs: BitcoinRpcTxOutput[]): boolean => {\n    for (let i = 0; i < outputs.length; i++) {\n      if (outputs[i].scriptPubKey.hex === this.lockScriptPubKey) {\n        return true;\n      }\n    }\n    return false;\n  };\n}\n"]}

package/dist/getRosenData/bitcoin-runes/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../lib/getRosenData/bitcoin-runes/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,MAAM,CAAC"}

package/dist/getRosenData/bitcoin-runes/constants.js

@@ -0,0 +1,2 @@
+export const minUtxoValue = 294;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vbGliL2dldFJvc2VuRGF0YS9iaXRjb2luLXJ1bmVzL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsR0FBRyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IG1pblV0eG9WYWx1ZSA9IDI5NDtcbiJdfQ==

package/dist/getRosenData/bitcoin-runes/types.d.ts

@@ -0,0 +1,30 @@
+export type LockDataChunk = {
+    index: number;
+    data: string;
+};
+export interface BitcoinRunesAssets {
+    runeId: string;
+    quantity: bigint;
+}
+export interface BitcoinRunesUtxo {
+    txId: string;
+    index: number;
+    value: bigint;
+    runes: Array<BitcoinRunesAssets>;
+}
+export interface BitcoinRunesTxInput {
+    txId: string;
+    index: number;
+    scriptPubKey: string;
+}
+export interface BitcoinRunesTxOutput {
+    scriptPubKey: string;
+    value: bigint;
+    runes: Array<BitcoinRunesAssets>;
+}
+export interface BitcoinRunesTx {
+    id: string;
+    inputs: BitcoinRunesTxInput[];
+    outputs: BitcoinRunesTxOutput[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/getRosenData/bitcoin-runes/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../lib/getRosenData/bitcoin-runes/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5D,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,mBAAmB,EAAE,CAAC;IAC9B,OAAO,EAAE,oBAAoB,EAAE,CAAC;CACjC"}

package/dist/getRosenData/bitcoin-runes/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvZ2V0Um9zZW5EYXRhL2JpdGNvaW4tcnVuZXMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIExvY2tEYXRhQ2h1bmsgPSB7IGluZGV4OiBudW1iZXI7IGRhdGE6IHN0cmluZyB9O1xuXG5leHBvcnQgaW50ZXJmYWNlIEJpdGNvaW5SdW5lc0Fzc2V0cyB7XG4gIHJ1bmVJZDogc3RyaW5nO1xuICBxdWFudGl0eTogYmlnaW50O1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEJpdGNvaW5SdW5lc1V0eG8ge1xuICB0eElkOiBzdHJpbmc7XG4gIGluZGV4OiBudW1iZXI7XG4gIHZhbHVlOiBiaWdpbnQ7XG4gIHJ1bmVzOiBBcnJheTxCaXRjb2luUnVuZXNBc3NldHM+O1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEJpdGNvaW5SdW5lc1R4SW5wdXQge1xuICB0eElkOiBzdHJpbmc7XG4gIGluZGV4OiBudW1iZXI7XG4gIHNjcmlwdFB1YktleTogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEJpdGNvaW5SdW5lc1R4T3V0cHV0IHtcbiAgc2NyaXB0UHViS2V5OiBzdHJpbmc7XG4gIHZhbHVlOiBiaWdpbnQ7XG4gIHJ1bmVzOiBBcnJheTxCaXRjb2luUnVuZXNBc3NldHM+O1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEJpdGNvaW5SdW5lc1R4IHtcbiAgaWQ6IHN0cmluZztcbiAgaW5wdXRzOiBCaXRjb2luUnVuZXNUeElucHV0W107XG4gIG91dHB1dHM6IEJpdGNvaW5SdW5lc1R4T3V0cHV0W107XG59XG4iXX0=

package/dist/getRosenData/bitcoin-runes/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../lib/getRosenData/bitcoin-runes/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAEtD;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAC9B,iBAAiB,MAAM,KACtB,uBAEF,CAAC"}

package/dist/getRosenData/bitcoin-runes/utils.js

@@ -0,0 +1,9 @@
+import { parseRosenData } from '../../utils';
+/**
+ * extracts rosen data from raw hex data
+ * @param scriptPubKeyHex
+ */
+export const parseAggregatedData = (scriptPubKeyHex) => {
+    return parseRosenData(scriptPubKeyHex);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvZ2V0Um9zZW5EYXRhL2JpdGNvaW4tcnVuZXMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUc3Qzs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxDQUNqQyxlQUF1QixFQUNFLEVBQUU7SUFDM0IsT0FBTyxjQUFjLENBQUMsZUFBZSxDQUFDLENBQUM7QUFDekMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgcGFyc2VSb3NlbkRhdGEgfSBmcm9tICcuLi8uLi91dGlscyc7XG5pbXBvcnQgeyBNaW5pbWFsT25DaGFpblJvc2VuRGF0YSB9IGZyb20gJy4uLy4uL3R5cGVzJztcblxuLyoqXG4gKiBleHRyYWN0cyByb3NlbiBkYXRhIGZyb20gcmF3IGhleCBkYXRhXG4gKiBAcGFyYW0gc2NyaXB0UHViS2V5SGV4XG4gKi9cbmV4cG9ydCBjb25zdCBwYXJzZUFnZ3JlZ2F0ZWREYXRhID0gKFxuICBzY3JpcHRQdWJLZXlIZXg6IHN0cmluZyxcbik6IE1pbmltYWxPbkNoYWluUm9zZW5EYXRhID0+IHtcbiAgcmV0dXJuIHBhcnNlUm9zZW5EYXRhKHNjcmlwdFB1YktleUhleCk7XG59O1xuIl19

package/dist/getRosenData/cardano/{CardanoBlockFrostRosenExtractor.d.ts → cardanoBlockFrostRosenExtractor.d.ts}

@@ -1,5 +1,5 @@
 import { RosenData, TokenTransformation } from '../abstract/types';
-import AbstractRosenDataExtractor from '../abstract/AbstractRosenDataExtractor';
+import AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';
 import { BlockFrostOutputBox, BlockFrostTransaction } from './types';
 export declare class CardanoBlockFrostRosenExtractor extends AbstractRosenDataExtractor<BlockFrostTransaction> {
     readonly chain = "cardano";
@@ -15,4 +15,4 @@ export declare class CardanoBlockFrostRosenExtractor extends AbstractRosenDataEx
      */
     getAssetTransformation: (box: BlockFrostOutputBox, toChain: string) => TokenTransformation | undefined;
 }
-//# sourceMappingURL=CardanoBlockFrostRosenExtractor.d.ts.map
+//# sourceMappingURL=cardanoBlockFrostRosenExtractor.d.ts.map

package/dist/getRosenData/cardano/{CardanoBlockFrostRosenExtractor.d.ts.map → cardanoBlockFrostRosenExtractor.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"CardanoBlockFrostRosenExtractor.d.ts","sourceRoot":"","sources":["../../../lib/getRosenData/cardano/CardanoBlockFrostRosenExtractor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,0BAA0B,MAAM,wCAAwC,CAAC;AAEhF,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAIrE,qBAAa,+BAAgC,SAAQ,0BAA0B,CAAC,qBAAqB,CAAC;IACpG,QAAQ,CAAC,KAAK,aAAiB;IAC/B;;;OAGG;IACH,cAAc,GACZ,aAAa,qBAAqB,KACjC,SAAS,GAAG,SAAS,CAsDtB;IAEF;;;;OAIG;IACH,sBAAsB,GACpB,KAAK,mBAAmB,EACxB,SAAS,MAAM,KACd,mBAAmB,GAAG,SAAS,CAsChC;CACH"}
+{"version":3,"file":"cardanoBlockFrostRosenExtractor.d.ts","sourceRoot":"","sources":["../../../lib/getRosenData/cardano/cardanoBlockFrostRosenExtractor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,0BAA0B,MAAM,wCAAwC,CAAC;AAEhF,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAIrE,qBAAa,+BAAgC,SAAQ,0BAA0B,CAAC,qBAAqB,CAAC;IACpG,QAAQ,CAAC,KAAK,aAAiB;IAC/B;;;OAGG;IACH,cAAc,GACZ,aAAa,qBAAqB,KACjC,SAAS,GAAG,SAAS,CAsDtB;IAEF;;;;OAIG;IACH,sBAAsB,GACpB,KAAK,mBAAmB,EACxB,SAAS,MAAM,KACd,mBAAmB,GAAG,SAAS,CAsChC;CACH"}