@rosen-bridge/rosen-extractor 7.2.2 → 7.3.0

package/dist/lib/getRosenData/runes/RunesEsploraRosenExtractor.js

@@ -0,0 +1,113 @@
+import AbstractRosenDataExtractor from '../abstract/AbstractRosenDataExtractor';
+import { 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 RunesEsploraRosenExtractor extends AbstractRosenDataExtractor {
+    chain = 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++) {
+            for (let boxIndex = 0; 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":"RunesEsploraRosenExtractor.js","sourceRoot":"","sources":["../../../../lib/getRosenData/runes/RunesEsploraRosenExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["import { RosenData } from '../abstract/types';\nimport AbstractRosenDataExtractor from '../abstract/AbstractRosenDataExtractor';\nimport { 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 RunesEsploraRosenExtractor extends AbstractRosenDataExtractor<BitcoinEsploraTransaction> {\n  readonly chain = 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      for (let boxIndex = 0; 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

@@ -0,0 +1,36 @@
+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 { MinimalOnChainRosenData } from '../../types';
+export declare class RunesRosenExtractor 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
+     */
+    extractRawData: (serializedTransaction: string) => RosenData | undefined;
+    /**
+     * extracts RosenData chunks from tx outputs
+     * @param outputs
+     * @return array of LockDataChunk
+     */
+    protected getLockDataChunks: (outputs: BitcoinTxOutput[]) => LockDataChunk[];
+    /**
+     * combines lock data chunks into lock data object
+     * @param lockDataChunks
+     * @return lock data object or undefined
+     */
+    protected lockDataFromChunks: (lockDataChunks: LockDataChunk[]) => MinimalOnChainRosenData | undefined;
+    /**
+     * check lock box exists in the tx outputs
+     * @param outputs
+     * @return boolean
+     */
+    protected validateLock: (outputs: BitcoinTxOutput[]) => boolean;
+}
+//# sourceMappingURL=RunesRosenExtractor.d.ts.map

package/dist/lib/getRosenData/runes/RunesRosenExtractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunesRosenExtractor.d.ts","sourceRoot":"","sources":["../../../../lib/getRosenData/runes/RunesRosenExtractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,0BAA0B,MAAM,wCAAwC,CAAC;AAEhF,OAAO,EAAE,eAAe,EAAa,MAAM,kBAAkB,CAAC;AAC9D,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,mBAAoB,SAAQ,0BAA0B,CAAC,MAAM,CAAC;IACzE,QAAQ,CAAC,KAAK,mBAAe;IAC7B,SAAS,CAAC,gBAAgB,EAAE,MAAM,CAAC;gBAEvB,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,cAAc;IAK1E;;;OAGG;IACH,cAAc,0BAA2B,MAAM,KAAG,SAAS,GAAG,SAAS,CAyDrE;IAEF;;;;OAIG;IACH,SAAS,CAAC,iBAAiB,YAChB,eAAe,EAAE,KACzB,aAAa,EAAE,CAmBhB;IAEF;;;;OAIG;IACH,SAAS,CAAC,kBAAkB,mBACV,aAAa,EAAE,KAC9B,uBAAuB,GAAG,SAAS,CAgBpC;IAEF;;;;OAIG;IACH,SAAS,CAAC,YAAY,YAAa,eAAe,EAAE,KAAG,OAAO,CAO5D;CACH"}

package/dist/lib/getRosenData/runes/RunesRosenExtractor.js

@@ -0,0 +1,120 @@
+import AbstractRosenDataExtractor from '../abstract/AbstractRosenDataExtractor';
+import { 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 RunesRosenExtractor extends AbstractRosenDataExtractor {
+    chain = 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 BitcoinTx format
+     * @param serializedTransaction stringified transaction in BitcoinTx format
+     */
+    extractRawData = (serializedTransaction) => {
+        let transaction;
+        try {
+            transaction = JsonBigInt.parse(serializedTransaction);
+        }
+        catch (e) {
+            throw new Error(`Failed to parse transaction json to BitcoinTx 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 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.inputs[0].txId}.${transaction.inputs[0].index}`;
+            return {
+                toChain: lockData.toChain,
+                toAddress: lockData.toAddress,
+                bridgeFee: lockData.bridgeFee,
+                networkFee: lockData.networkFee,
+                fromAddress: fromAddress,
+                sourceChainTokenId: '',
+                amount: '',
+                targetChainTokenId: '',
+                sourceTxId: transaction.id,
+            };
+        }
+        catch (e) {
+            this.logger.debug(`An error occurred while getting Runes rosen data from BitcoinTx: ${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++) {
+            for (let boxIndex = 0; 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;
+    };
+    /**
+     * 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":"RunesRosenExtractor.js","sourceRoot":"","sources":["../../../../lib/getRosenData/runes/RunesRosenExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["import { RosenData } from '../abstract/types';\nimport AbstractRosenDataExtractor from '../abstract/AbstractRosenDataExtractor';\nimport { RUNES_CHAIN } from '../const';\nimport { BitcoinTxOutput, BitcoinTx } 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 RunesRosenExtractor extends AbstractRosenDataExtractor<string> {\n  readonly chain = 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 BitcoinTx format\n   * @param serializedTransaction stringified transaction in BitcoinTx format\n   */\n  extractRawData = (serializedTransaction: string): RosenData | undefined => {\n    let transaction: BitcoinTx;\n    try {\n      transaction = JsonBigInt.parse(serializedTransaction);\n    } catch (e) {\n      throw new Error(\n        `Failed to parse transaction json to BitcoinTx 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 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\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.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: '',\n        amount: '',\n        targetChainTokenId: '',\n        sourceTxId: transaction.id,\n      };\n    } catch (e) {\n      this.logger.debug(\n        `An error occurred while getting Runes rosen data from BitcoinTx: ${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: BitcoinTxOutput[]\n  ): LockDataChunk[] => {\n    const lockDataChunks: LockDataChunk[] = [];\n\n    for (let i = 0; i < 4; i++) {\n      for (let boxIndex = 0; 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   * check lock box exists in the tx outputs\n   * @param outputs\n   * @return boolean\n   */\n  protected validateLock = (outputs: BitcoinTxOutput[]): 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/RunesRpcRosenExtractor.d.ts

@@ -0,0 +1,36 @@
+import { RosenData } from '../abstract/types';
+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> {
+    readonly chain = "bitcoin-runes";
+    protected lockScriptPubKey: string;
+    constructor(lockAddress: string, tokens: TokenMap, logger?: AbstractLogger);
+    /**
+     * extracts RosenData from given lock transaction in Rpc format
+     * @param transaction the lock transaction in Rpc format
+     */
+    extractRawData: (transaction: BitcoinRpcTransaction) => RosenData | undefined;
+    /**
+     * extracts RosenData chunks from tx outputs
+     * @param outputs
+     * @return array of LockDataChunk
+     */
+    protected getLockDataChunks: (outputs: BitcoinRpcTxOutput[]) => LockDataChunk[];
+    /**
+     * combines lock data chunks into lock data object
+     * @param lockDataChunks
+     * @return lock data object or undefined
+     */
+    protected lockDataFromChunks: (lockDataChunks: LockDataChunk[]) => MinimalOnChainRosenData | undefined;
+    /**
+     * check lock box exists in the tx outputs
+     * @param outputs
+     * @return boolean
+     */
+    protected validateLock: (outputs: BitcoinRpcTxOutput[]) => boolean;
+}
+//# sourceMappingURL=RunesRpcRosenExtractor.d.ts.map

package/dist/lib/getRosenData/runes/RunesRpcRosenExtractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunesRpcRosenExtractor.d.ts","sourceRoot":"","sources":["../../../../lib/getRosenData/runes/RunesRpcRosenExtractor.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,sBAAuB,SAAQ,0BAA0B,CAAC,qBAAqB,CAAC;IAC3F,QAAQ,CAAC,KAAK,mBAAe;IAC7B,SAAS,CAAC,gBAAgB,EAAE,MAAM,CAAC;gBAEvB,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,cAAc;IAK1E;;;OAGG;IACH,cAAc,gBACC,qBAAqB,KACjC,SAAS,GAAG,SAAS,CAkDtB;IAEF;;;;OAIG;IACH,SAAS,CAAC,iBAAiB,YAChB,kBAAkB,EAAE,KAC5B,aAAa,EAAE,CAmBhB;IAEF;;;;OAIG;IACH,SAAS,CAAC,kBAAkB,mBACV,aAAa,EAAE,KAC9B,uBAAuB,GAAG,SAAS,CAgBpC;IAEF;;;;OAIG;IACH,SAAS,CAAC,YAAY,YAAa,kBAAkB,EAAE,KAAG,OAAO,CAO/D;CACH"}

package/dist/lib/getRosenData/runes/RunesRpcRosenExtractor.js

@@ -0,0 +1,113 @@
+import AbstractRosenDataExtractor from '../abstract/AbstractRosenDataExtractor';
+import { 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 RunesRpcRosenExtractor extends AbstractRosenDataExtractor {
+    chain = 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++) {
+            for (let boxIndex = 0; 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":"RunesRpcRosenExtractor.js","sourceRoot":"","sources":["../../../../lib/getRosenData/runes/RunesRpcRosenExtractor.ts"],"names":[],"mappings":"AACA,OAAO,0BAA0B,MAAM,wCAAwC,CAAC;AAChF,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAIvC,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,UAAU,MAAM,2BAA2B,CAAC;AAGnD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,MAAM,OAAO,sBAAuB,SAAQ,0BAAiD;IAClF,KAAK,GAAG,WAAW,CAAC;IACnB,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,CACf,WAAkC,EACX,EAAE;QACzB,MAAM,SAAS,GAAG,kCAAkC,WAAW,CAAC,IAAI,GAAG,CAAC;QACxE,IAAI;YACF,kCAAkC;YAClC,MAAM,OAAO,GAAG,WAAW,CAAC,IAAI,CAAC;YACjC,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;gBACtB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,GAAG,gCAAgC,CAAC,CAAC;gBAChE,OAAO,SAAS,CAAC;aAClB;YAED,2BAA2B;YAC3B,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;YAE7C,IAAI,CAAC,SAAS,EAAE;gBACd,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,GAAG,kCAAkC,CAAC,CAAC;gBAClE,OAAO,SAAS,CAAC;aAClB;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;gBACb,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,SAAS,GAAG,2CAA2C,CACxD,CAAC;gBACF,OAAO,SAAS,CAAC;aAClB;YAED,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;YAChF,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,EAAE;gBACtB,MAAM,EAAE,EAAE;gBACV,kBAAkB,EAAE,EAAE;gBACtB,UAAU,EAAE,WAAW,CAAC,IAAI;aAC7B,CAAC;SACH;QAAC,OAAO,CAAC,EAAE;YACV,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,8DAA8D,CAAC,EAAE,CAClE,CAAC;YACF,IAAI,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC,KAAK,EAAE;gBACjC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;aAC5B;SACF;QACD,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC;IAEF;;;;OAIG;IACO,iBAAiB,GAAG,CAC5B,OAA6B,EACZ,EAAE;QACnB,MAAM,cAAc,GAAoB,EAAE,CAAC;QAE3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;YAC1B,KAAK,IAAI,QAAQ,GAAG,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE;gBAC5D,MAAM,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;gBAEjC,IAAI,MAAM,CAAC,KAAK,GAAG,EAAE,IAAI,CAAC,KAAK,YAAY,GAAG,CAAC;oBAAE,SAAS,CAAC,mBAAmB;gBAC9E,IAAI,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM;oBAAE,SAAS,CAAC,2BAA2B;gBAEzF,cAAc,CAAC,IAAI,CAAC;oBAClB,KAAK,EAAE,CAAC;oBACR,IAAI,EAAE,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;iBACvC,CAAC,CAAC;gBACH,MAAM;aACP;SACF;QAED,OAAO,cAAc,CAAC;IACxB,CAAC,CAAC;IAEF;;;;OAIG;IACO,kBAAkB,GAAG,CAC7B,cAA+B,EACM,EAAE;QACvC,IAAI,QAA6C,CAAC;QAElD,IAAI;YACF,QAAQ,GAAG,mBAAmB,CAC5B,cAAc,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CACnD,CAAC;SACH;QAAC,OAAO,CAAC,EAAE;YACV,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,uCAAuC,UAAU,CAAC,SAAS,CACzD,cAAc,CACf,MAAM,CAAC,EAAE,CACX,CAAC;SACH;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC,CAAC;IAEF;;;;OAIG;IACO,YAAY,GAAG,CAAC,OAA6B,EAAW,EAAE;QAClE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACvC,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,GAAG,KAAK,IAAI,CAAC,gBAAgB,EAAE;gBACzD,OAAO,IAAI,CAAC;aACb;SACF;QACD,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;CACH","sourcesContent":["import { RosenData } from '../abstract/types';\nimport AbstractRosenDataExtractor from '../abstract/AbstractRosenDataExtractor';\nimport { 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 RunesRpcRosenExtractor extends AbstractRosenDataExtractor<BitcoinRpcTransaction> {\n  readonly chain = 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      for (let boxIndex = 0; 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/lib/getRosenData/runes/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const minUtxoValue = 294;
+//# sourceMappingURL=constants.d.ts.map

package/dist/lib/getRosenData/runes/constants.d.ts.map

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

package/dist/lib/getRosenData/runes/constants.js

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

package/dist/lib/getRosenData/runes/types.d.ts

@@ -0,0 +1,5 @@
+export type LockDataChunk = {
+    index: number;
+    data: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/getRosenData/runes/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../lib/getRosenData/runes/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC"}

package/dist/lib/getRosenData/runes/types.js

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

package/dist/lib/getRosenData/runes/utils.d.ts

@@ -0,0 +1,7 @@
+import { MinimalOnChainRosenData } from '../../types';
+/**
+ * extracts rosen data from raw hex data
+ * @param scriptPubKeyHex
+ */
+export declare const parseAggregatedData: (scriptPubKeyHex: string) => MinimalOnChainRosenData;
+//# sourceMappingURL=utils.d.ts.map

package/dist/lib/getRosenData/runes/utils.d.ts.map

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

package/dist/lib/getRosenData/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWIvZ2V0Um9zZW5EYXRhL3J1bmVzL3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFHN0M7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUcsQ0FDakMsZUFBdUIsRUFDRSxFQUFFO0lBQzNCLE9BQU8sY0FBYyxDQUFDLGVBQWUsQ0FBQyxDQUFDO0FBQ3pDLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHBhcnNlUm9zZW5EYXRhIH0gZnJvbSAnLi4vLi4vdXRpbHMnO1xuaW1wb3J0IHsgTWluaW1hbE9uQ2hhaW5Sb3NlbkRhdGEgfSBmcm9tICcuLi8uLi90eXBlcyc7XG5cbi8qKlxuICogZXh0cmFjdHMgcm9zZW4gZGF0YSBmcm9tIHJhdyBoZXggZGF0YVxuICogQHBhcmFtIHNjcmlwdFB1YktleUhleFxuICovXG5leHBvcnQgY29uc3QgcGFyc2VBZ2dyZWdhdGVkRGF0YSA9IChcbiAgc2NyaXB0UHViS2V5SGV4OiBzdHJpbmdcbik6IE1pbmltYWxPbkNoYWluUm9zZW5EYXRhID0+IHtcbiAgcmV0dXJuIHBhcnNlUm9zZW5EYXRhKHNjcmlwdFB1YktleUhleCk7XG59O1xuIl19

package/dist/lib/index.d.ts

@@ -16,4 +16,8 @@ export { RosenData } from './getRosenData/abstract/types';
 export { DogeEsploraRosenExtractor } from './getRosenData/doge/DogeEsploraRosenExtractor';
 export { DogeRosenExtractor } from './getRosenData/doge/DogeRosenExtractor';
 export { DogeRpcRosenExtractor } from './getRosenData/doge/DogeRpcRosenExtractor';
+export { RunesEsploraRosenExtractor } from './getRosenData/runes/RunesEsploraRosenExtractor';
+export { RunesRosenExtractor } from './getRosenData/runes/RunesRosenExtractor';
+export { RunesRpcRosenExtractor } from './getRosenData/runes/RunesRpcRosenExtractor';
+export { parseRosenData } from './utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,0BAA0B,EAAE,MAAM,oDAAoD,CAAC;AAC3G,OAAO,EAAE,4BAA4B,EAAE,MAAM,qDAAqD,CAAC;AACnG,OAAO,EAAE,qBAAqB,EAAE,MAAM,8CAA8C,CAAC;AACrF,OAAO,EAAE,wBAAwB,EAAE,MAAM,iDAAiD,CAAC;AAC3F,OAAO,EAAE,uBAAuB,EAAE,MAAM,4CAA4C,CAAC;AACrF,OAAO,EAAE,oBAAoB,EAAE,MAAM,yCAAyC,CAAC;AAC/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAC;AACzE,OAAO,EAAE,0BAA0B,EAAE,MAAM,mDAAmD,CAAC;AAC/F,OAAO,EAAE,2BAA2B,EAAE,MAAM,oDAAoD,CAAC;AACjG,OAAO,EAAE,qBAAqB,EAAE,MAAM,8CAA8C,CAAC;AACrF,OAAO,EAAE,+BAA+B,EAAE,MAAM,wDAAwD,CAAC;AACzG,OAAO,EAAE,4BAA4B,EAAE,MAAM,qDAAqD,CAAC;AACnG,OAAO,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAC5E,OAAO,EAAE,sBAAsB,EAAE,MAAM,4CAA4C,CAAC;AACpF,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAC1D,OAAO,EAAE,yBAAyB,EAAE,MAAM,+CAA+C,CAAC;AAC1F,OAAO,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAC5E,OAAO,EAAE,qBAAqB,EAAE,MAAM,2CAA2C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,OAAO,IAAI,0BAA0B,EAAE,MAAM,oDAAoD,CAAC;AAC3G,OAAO,EAAE,4BAA4B,EAAE,MAAM,qDAAqD,CAAC;AACnG,OAAO,EAAE,qBAAqB,EAAE,MAAM,8CAA8C,CAAC;AACrF,OAAO,EAAE,wBAAwB,EAAE,MAAM,iDAAiD,CAAC;AAC3F,OAAO,EAAE,uBAAuB,EAAE,MAAM,4CAA4C,CAAC;AACrF,OAAO,EAAE,oBAAoB,EAAE,MAAM,yCAAyC,CAAC;AAC/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAC;AACzE,OAAO,EAAE,0BAA0B,EAAE,MAAM,mDAAmD,CAAC;AAC/F,OAAO,EAAE,2BAA2B,EAAE,MAAM,oDAAoD,CAAC;AACjG,OAAO,EAAE,qBAAqB,EAAE,MAAM,8CAA8C,CAAC;AACrF,OAAO,EAAE,+BAA+B,EAAE,MAAM,wDAAwD,CAAC;AACzG,OAAO,EAAE,4BAA4B,EAAE,MAAM,qDAAqD,CAAC;AACnG,OAAO,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAC5E,OAAO,EAAE,sBAAsB,EAAE,MAAM,4CAA4C,CAAC;AACpF,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAC1D,OAAO,EAAE,yBAAyB,EAAE,MAAM,+CAA+C,CAAC;AAC1F,OAAO,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAC5E,OAAO,EAAE,qBAAqB,EAAE,MAAM,2CAA2C,CAAC;AAClF,OAAO,EAAE,0BAA0B,EAAE,MAAM,iDAAiD,CAAC;AAC7F,OAAO,EAAE,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AAC/E,OAAO,EAAE,sBAAsB,EAAE,MAAM,6CAA6C,CAAC;AACrF,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC"}

package/dist/lib/index.js

@@ -1,3 +1,6 @@
+import { initEccLib } from 'bitcoinjs-lib';
+import * as tinySecp from 'tiny-secp256k1';
+initEccLib(tinySecp);
 export { default as AbstractRosenDataExtractor } from './getRosenData/abstract/AbstractRosenDataExtractor';
 export { BitcoinEsploraRosenExtractor } from './getRosenData/bitcoin/BitcoinEsploraRosenExtractor';
 export { BitcoinRosenExtractor } from './getRosenData/bitcoin/BitcoinRosenExtractor';
@@ -15,4 +18,8 @@ export { ErgoNodeRosenExtractor } from './getRosenData/ergo/ErgoNodeRosenExtract
 export { DogeEsploraRosenExtractor } from './getRosenData/doge/DogeEsploraRosenExtractor';
 export { DogeRosenExtractor } from './getRosenData/doge/DogeRosenExtractor';
 export { DogeRpcRosenExtractor } from './getRosenData/doge/DogeRpcRosenExtractor';
-//# sourceMappingURL=data:application/json;base64,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
+export { RunesEsploraRosenExtractor } from './getRosenData/runes/RunesEsploraRosenExtractor';
+export { RunesRosenExtractor } from './getRosenData/runes/RunesRosenExtractor';
+export { RunesRpcRosenExtractor } from './getRosenData/runes/RunesRpcRosenExtractor';
+export { parseRosenData } from './utils';
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/types.d.ts

@@ -0,0 +1,7 @@
+export interface MinimalOnChainRosenData {
+    toChain: string;
+    toAddress: string;
+    bridgeFee: string;
+    networkFee: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../lib/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB"}

package/dist/lib/types.js

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

package/dist/lib/utils.d.ts

@@ -0,0 +1,7 @@
+import { MinimalOnChainRosenData } from './types';
+/**
+ * extracts rosen data from raw hex data
+ * @param scriptPubKeyHex
+ */
+export declare const parseRosenData: (scriptPubKeyHex: string) => MinimalOnChainRosenData;
+//# sourceMappingURL=utils.d.ts.map

package/dist/lib/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../lib/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAElD;;;GAGG;AACH,eAAO,MAAM,cAAc,oBACR,MAAM,KACtB,uBAgCF,CAAC"}