@rosen-bridge/rosen-extractor 9.0.0 → 10.1.0

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

@@ -0,0 +1,117 @@
+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,
+                rawData: outputs
+                    .map((output) => `${output.scriptPubKey.hex}:${output.value}`)
+                    .join(','),
+            };
+        }
+        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        rawData: outputs\n          .map((output) => `${output.scriptPubKey.hex}:${output.value}`)\n          .join(','),\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/types.d.ts

@@ -2,4 +2,29 @@ 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

@@ -1 +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"}
+{"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

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

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

@@ -6,4 +6,4 @@ import { parseRosenData } from '../../utils';
 export const parseAggregatedData = (scriptPubKeyHex) => {
     return parseRosenData(scriptPubKeyHex);
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvZ2V0Um9zZW5EYXRhL2JpdGNvaW4tcnVuZXMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUc3Qzs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxDQUNqQyxlQUF1QixFQUNFLEVBQUU7SUFDM0IsT0FBTyxjQUFjLENBQUMsZUFBZSxDQUFDLENBQUM7QUFDekMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgcGFyc2VSb3NlbkRhdGEgfSBmcm9tICcuLi8uLi91dGlscyc7XG5pbXBvcnQgeyBNaW5pbWFsT25DaGFpblJvc2VuRGF0YSB9IGZyb20gJy4uLy4uL3R5cGVzJztcblxuLyoqXG4gKiBleHRyYWN0cyByb3NlbiBkYXRhIGZyb20gcmF3IGhleCBkYXRhXG4gKiBAcGFyYW0gc2NyaXB0UHViS2V5SGV4XG4gKi9cbmV4cG9ydCBjb25zdCBwYXJzZUFnZ3JlZ2F0ZWREYXRhID0gKFxuICBzY3JpcHRQdWJLZXlIZXg6IHN0cmluZ1xuKTogTWluaW1hbE9uQ2hhaW5Sb3NlbkRhdGEgPT4ge1xuICByZXR1cm4gcGFyc2VSb3NlbkRhdGEoc2NyaXB0UHViS2V5SGV4KTtcbn07XG4iXX0=
+//# 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,CAwDtB;IAEF;;;;OAIG;IACH,sBAAsB,GACpB,KAAK,mBAAmB,EACxB,SAAS,MAAM,KACd,mBAAmB,GAAG,SAAS,CAsChC;CACH"}

package/dist/getRosenData/cardano/cardanoBlockFrostRosenExtractor.js

@@ -0,0 +1,96 @@
+import { isPlainObject } from 'lodash-es';
+import AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';
+import { CARDANO_CHAIN, CARDANO_NATIVE_TOKEN } from '../const';
+import JsonBigInt from '@rosen-bridge/json-bigint';
+import { getCardanoTokenId, parseRosenData } from './utils';
+export class CardanoBlockFrostRosenExtractor extends AbstractRosenDataExtractor {
+    chain = CARDANO_CHAIN;
+    /**
+     * extracts RosenData from given lock transaction in blockfrost format
+     * @param transaction the lock transaction in blockfrost format
+     */
+    extractRawData = (transaction) => {
+        const baseError = `No rosen data found for tx [${transaction.utxos.hash}]`;
+        const metadata = transaction.metadata;
+        try {
+            if (metadata.length === 0) {
+                this.logger.debug(baseError + `: No metadata`);
+                return undefined;
+            }
+            const data = metadata.find((data) => data.label === '0')?.json_metadata;
+            const rosenData = parseRosenData(data);
+            if (rosenData) {
+                const lockOutputs = transaction.utxos.outputs.filter((output) => output.address === this.lockAddress);
+                for (let i = 0; i < lockOutputs.length; i++) {
+                    const output = lockOutputs[i];
+                    const assetTransformation = this.getAssetTransformation(output, rosenData.toChain);
+                    if (assetTransformation) {
+                        return {
+                            ...rosenData,
+                            sourceChainTokenId: assetTransformation.from,
+                            amount: assetTransformation.amount,
+                            targetChainTokenId: assetTransformation.to,
+                            sourceTxId: transaction.utxos.hash,
+                            // TODO: save rawData in CBOR (local:ergo/rosen-bridge/utils#293)
+                            rawData: JsonBigInt.stringify(data),
+                        };
+                    }
+                    else
+                        this.logger.debug(`No rosen asset transformation found for box [${transaction.utxos.hash}.${i}]: box assets: ${JsonBigInt.stringify(output.amount)}`);
+                }
+                this.logger.debug(baseError + `: No valid transformation found in any output boxes`);
+            }
+            else
+                this.logger.debug(baseError +
+                    `: Incomplete metadata. isPlain: ${isPlainObject(data)}, data: ${JsonBigInt.stringify(data)}`);
+        }
+        catch (e) {
+            this.logger.debug(`An error occurred while getting Cardano rosen data from BlockFrost: ${e}`);
+            if (e instanceof Error && e.stack) {
+                this.logger.debug(e.stack);
+            }
+        }
+        return undefined;
+    };
+    /**
+     * 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.amount) {
+            if (asset.unit === 'lovelace')
+                continue;
+            const policyId = asset.unit.slice(0, 56);
+            const assetName = asset.unit.slice(56);
+            const token = this.tokens.search(CARDANO_CHAIN, {
+                tokenId: getCardanoTokenId(policyId, assetName),
+            });
+            if (token.length > 0 && Object.hasOwn(token[0], toChain))
+                return {
+                    from: this.tokens.getID(token[0], CARDANO_CHAIN),
+                    to: this.tokens.getID(token[0], toChain),
+                    amount: asset.quantity,
+                };
+        }
+        // try to build transformation using locked ADA
+        const lovelace = this.tokens.search(CARDANO_CHAIN, {
+            tokenId: CARDANO_NATIVE_TOKEN,
+        });
+        if (lovelace.length > 0 && Object.hasOwn(lovelace[0], toChain)) {
+            const boxLovelaceAmount = box.amount.find((asset) => asset.unit === 'lovelace');
+            if (!boxLovelaceAmount)
+                throw Error(`ImpossibleBehavior: Found blockfrost tx output with no lovelace amount`);
+            return {
+                from: CARDANO_NATIVE_TOKEN,
+                to: this.tokens.getID(lovelace[0], toChain),
+                amount: boxLovelaceAmount.quantity,
+            };
+        }
+        else {
+            return undefined;
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cardanoBlockFrostRosenExtractor.js","sourceRoot":"","sources":["../../../lib/getRosenData/cardano/cardanoBlockFrostRosenExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["import { isPlainObject } from 'lodash-es';\nimport { RosenData, TokenTransformation } from '../abstract/types';\nimport AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';\nimport { CARDANO_CHAIN, CARDANO_NATIVE_TOKEN } from '../const';\nimport { BlockFrostOutputBox, BlockFrostTransaction } from './types';\nimport JsonBigInt from '@rosen-bridge/json-bigint';\nimport { getCardanoTokenId, parseRosenData } from './utils';\n\nexport class CardanoBlockFrostRosenExtractor extends AbstractRosenDataExtractor<BlockFrostTransaction> {\n  readonly chain = CARDANO_CHAIN;\n  /**\n   * extracts RosenData from given lock transaction in blockfrost format\n   * @param transaction the lock transaction in blockfrost format\n   */\n  extractRawData = (\n    transaction: BlockFrostTransaction,\n  ): RosenData | undefined => {\n    const baseError = `No rosen data found for tx [${transaction.utxos.hash}]`;\n    const metadata = transaction.metadata;\n    try {\n      if (metadata.length === 0) {\n        this.logger.debug(baseError + `: No metadata`);\n        return undefined;\n      }\n      const data = metadata.find((data) => data.label === '0')?.json_metadata;\n      const rosenData = parseRosenData(data);\n      if (rosenData) {\n        const lockOutputs = transaction.utxos.outputs.filter(\n          (output) => output.address === this.lockAddress,\n        );\n        for (let i = 0; i < lockOutputs.length; i++) {\n          const output = lockOutputs[i];\n          const assetTransformation = this.getAssetTransformation(\n            output,\n            rosenData.toChain,\n          );\n          if (assetTransformation) {\n            return {\n              ...rosenData,\n              sourceChainTokenId: assetTransformation.from,\n              amount: assetTransformation.amount,\n              targetChainTokenId: assetTransformation.to,\n              sourceTxId: transaction.utxos.hash,\n              // TODO: save rawData in CBOR (local:ergo/rosen-bridge/utils#293)\n              rawData: JsonBigInt.stringify(data),\n            };\n          } else\n            this.logger.debug(\n              `No rosen asset transformation found for box [${\n                transaction.utxos.hash\n              }.${i}]: box assets: ${JsonBigInt.stringify(output.amount)}`,\n            );\n        }\n        this.logger.debug(\n          baseError + `: No valid transformation found in any output boxes`,\n        );\n      } else\n        this.logger.debug(\n          baseError +\n            `: Incomplete metadata. isPlain: ${isPlainObject(\n              data,\n            )}, data: ${JsonBigInt.stringify(data)}`,\n        );\n    } catch (e) {\n      this.logger.debug(\n        `An error occurred while getting Cardano rosen data from BlockFrost: ${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 and builds token transformation from UTXO and tokenMap\n   * @param box transaction output\n   * @param toChain event target chain\n   */\n  getAssetTransformation = (\n    box: BlockFrostOutputBox,\n    toChain: string,\n  ): TokenTransformation | undefined => {\n    // try to build transformation using locked assets\n    for (const asset of box.amount) {\n      if (asset.unit === 'lovelace') continue;\n      const policyId = asset.unit.slice(0, 56);\n      const assetName = asset.unit.slice(56);\n      const token = this.tokens.search(CARDANO_CHAIN, {\n        tokenId: getCardanoTokenId(policyId, assetName),\n      });\n      if (token.length > 0 && Object.hasOwn(token[0], toChain))\n        return {\n          from: this.tokens.getID(token[0], CARDANO_CHAIN),\n          to: this.tokens.getID(token[0], toChain),\n          amount: asset.quantity,\n        };\n    }\n\n    // try to build transformation using locked ADA\n    const lovelace = this.tokens.search(CARDANO_CHAIN, {\n      tokenId: CARDANO_NATIVE_TOKEN,\n    });\n    if (lovelace.length > 0 && Object.hasOwn(lovelace[0], toChain)) {\n      const boxLovelaceAmount = box.amount.find(\n        (asset) => asset.unit === 'lovelace',\n      );\n      if (!boxLovelaceAmount)\n        throw Error(\n          `ImpossibleBehavior: Found blockfrost tx output with no lovelace amount`,\n        );\n\n      return {\n        from: CARDANO_NATIVE_TOKEN,\n        to: this.tokens.getID(lovelace[0], toChain),\n        amount: boxLovelaceAmount.quantity,\n      };\n    } else {\n      return undefined;\n    }\n  };\n}\n"]}

package/dist/getRosenData/cardano/{CardanoGraphQLRosenExtractor.d.ts → cardanoGraphQLRosenExtractor.d.ts}

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

package/dist/getRosenData/cardano/{CardanoGraphQLRosenExtractor.d.ts.map → cardanoGraphQLRosenExtractor.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"CardanoGraphQLRosenExtractor.d.ts","sourceRoot":"","sources":["../../../lib/getRosenData/cardano/CardanoGraphQLRosenExtractor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,0BAA0B,MAAM,wCAAwC,CAAC;AAEhF,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAI9D,qBAAa,4BAA6B,SAAQ,0BAA0B,CAAC,kBAAkB,CAAC;IAC9F,QAAQ,CAAC,KAAK,aAAiB;IAC/B;;;OAGG;IACH,cAAc,GAAI,aAAa,kBAAkB,KAAG,SAAS,GAAG,SAAS,CA4DvE;IAEF;;;;OAIG;IACH,sBAAsB,GACpB,KAAK,eAAe,EACpB,SAAS,MAAM,KACd,mBAAmB,GAAG,SAAS,CA8BhC;CACH"}
+{"version":3,"file":"cardanoGraphQLRosenExtractor.d.ts","sourceRoot":"","sources":["../../../lib/getRosenData/cardano/cardanoGraphQLRosenExtractor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,0BAA0B,MAAM,wCAAwC,CAAC;AAEhF,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAI9D,qBAAa,4BAA6B,SAAQ,0BAA0B,CAAC,kBAAkB,CAAC;IAC9F,QAAQ,CAAC,KAAK,aAAiB;IAC/B;;;OAGG;IACH,cAAc,GAAI,aAAa,kBAAkB,KAAG,SAAS,GAAG,SAAS,CA8DvE;IAEF;;;;OAIG;IACH,sBAAsB,GACpB,KAAK,eAAe,EACpB,SAAS,MAAM,KACd,mBAAmB,GAAG,SAAS,CA8BhC;CACH"}

package/dist/getRosenData/cardano/cardanoGraphQLRosenExtractor.js

@@ -0,0 +1,94 @@
+import { isPlainObject } from 'lodash-es';
+import AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';
+import { CARDANO_CHAIN, CARDANO_NATIVE_TOKEN } from '../const';
+import JsonBigInt from '@rosen-bridge/json-bigint';
+import { getCardanoTokenId, parseRosenData } from './utils';
+export class CardanoGraphQLRosenExtractor extends AbstractRosenDataExtractor {
+    chain = CARDANO_CHAIN;
+    /**
+     * extracts RosenData from given lock transaction in graphql format
+     * @param transaction the lock transaction in graphql format
+     */
+    extractRawData = (transaction) => {
+        const baseError = `No rosen data found for tx [${transaction.hash}]`;
+        const metadata = transaction.metadata;
+        try {
+            if (!metadata || metadata.length === 0) {
+                this.logger.debug(baseError + `: No metadata`);
+                return undefined;
+            }
+            const data = metadata.find((data) => data?.key === '0')?.value;
+            const rosenData = parseRosenData(data);
+            if (rosenData) {
+                const lockOutputs = transaction.outputs.filter((output) => output?.address === this.lockAddress);
+                for (let i = 0; i < lockOutputs.length; i++) {
+                    const output = lockOutputs[i];
+                    if (!output) {
+                        this.logger.debug(`No rosen asset transformation found for box [${transaction.hash}.${i}]: box is undefined!`);
+                    }
+                    else {
+                        const assetTransformation = this.getAssetTransformation(output, rosenData.toChain);
+                        if (assetTransformation) {
+                            return {
+                                ...rosenData,
+                                sourceChainTokenId: assetTransformation.from,
+                                amount: assetTransformation.amount,
+                                targetChainTokenId: assetTransformation.to,
+                                sourceTxId: transaction.hash,
+                                // TODO: save rawData in CBOR (local:ergo/rosen-bridge/utils#293)
+                                rawData: JsonBigInt.stringify(data),
+                            };
+                        }
+                        else
+                            this.logger.debug(`No rosen asset transformation found for box [${transaction.hash}.${i}]: box assets: ${JsonBigInt.stringify(output.tokens)}`);
+                    }
+                }
+                this.logger.debug(baseError + `: No valid transformation found in any output boxes`);
+            }
+            else
+                this.logger.debug(baseError +
+                    `: Incomplete metadata. isPlain: ${isPlainObject(data)}, data: ${JsonBigInt.stringify(data)}`);
+        }
+        catch (e) {
+            this.logger.debug(`An error occurred while getting Cardano rosen data from GraphQL: ${e}`);
+            if (e instanceof Error && e.stack) {
+                this.logger.debug(e.stack);
+            }
+        }
+        return undefined;
+    };
+    /**
+     * 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 boxToken of box.tokens) {
+            const token = this.tokens.search(CARDANO_CHAIN, {
+                tokenId: getCardanoTokenId(boxToken.asset.policyId, boxToken.asset.assetName),
+            });
+            if (token.length > 0 && Object.hasOwn(token[0], toChain))
+                return {
+                    from: this.tokens.getID(token[0], CARDANO_CHAIN),
+                    to: this.tokens.getID(token[0], toChain),
+                    amount: boxToken.quantity,
+                };
+        }
+        // try to build transformation using locked ADA
+        const lovelace = this.tokens.search(CARDANO_CHAIN, {
+            tokenId: CARDANO_NATIVE_TOKEN,
+        });
+        if (lovelace.length > 0 && Object.hasOwn(lovelace[0], toChain)) {
+            return {
+                from: CARDANO_NATIVE_TOKEN,
+                to: this.tokens.getID(lovelace[0], toChain),
+                amount: box.value,
+            };
+        }
+        else {
+            return undefined;
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cardanoGraphQLRosenExtractor.js","sourceRoot":"","sources":["../../../lib/getRosenData/cardano/cardanoGraphQLRosenExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["import { isPlainObject } from 'lodash-es';\nimport { RosenData, TokenTransformation } from '../abstract/types';\nimport AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';\nimport { CARDANO_CHAIN, CARDANO_NATIVE_TOKEN } from '../const';\nimport { GraphQLTransaction, GraphQLTxOutput } from './types';\nimport JsonBigInt from '@rosen-bridge/json-bigint';\nimport { getCardanoTokenId, parseRosenData } from './utils';\n\nexport class CardanoGraphQLRosenExtractor extends AbstractRosenDataExtractor<GraphQLTransaction> {\n  readonly chain = CARDANO_CHAIN;\n  /**\n   * extracts RosenData from given lock transaction in graphql format\n   * @param transaction the lock transaction in graphql format\n   */\n  extractRawData = (transaction: GraphQLTransaction): RosenData | undefined => {\n    const baseError = `No rosen data found for tx [${transaction.hash}]`;\n    const metadata = transaction.metadata;\n    try {\n      if (!metadata || metadata.length === 0) {\n        this.logger.debug(baseError + `: No metadata`);\n        return undefined;\n      }\n      const data = metadata.find((data) => data?.key === '0')?.value;\n      const rosenData = parseRosenData(data);\n      if (rosenData) {\n        const lockOutputs = transaction.outputs.filter(\n          (output) => output?.address === this.lockAddress,\n        );\n        for (let i = 0; i < lockOutputs.length; i++) {\n          const output = lockOutputs[i];\n          if (!output) {\n            this.logger.debug(\n              `No rosen asset transformation found for box [${transaction.hash}.${i}]: box is undefined!`,\n            );\n          } else {\n            const assetTransformation = this.getAssetTransformation(\n              output,\n              rosenData.toChain,\n            );\n            if (assetTransformation) {\n              return {\n                ...rosenData,\n                sourceChainTokenId: assetTransformation.from,\n                amount: assetTransformation.amount,\n                targetChainTokenId: assetTransformation.to,\n                sourceTxId: transaction.hash,\n                // TODO: save rawData in CBOR (local:ergo/rosen-bridge/utils#293)\n                rawData: JsonBigInt.stringify(data),\n              };\n            } else\n              this.logger.debug(\n                `No rosen asset transformation found for box [${\n                  transaction.hash\n                }.${i}]: box assets: ${JsonBigInt.stringify(output.tokens)}`,\n              );\n          }\n        }\n        this.logger.debug(\n          baseError + `: No valid transformation found in any output boxes`,\n        );\n      } else\n        this.logger.debug(\n          baseError +\n            `: Incomplete metadata. isPlain: ${isPlainObject(\n              data,\n            )}, data: ${JsonBigInt.stringify(data)}`,\n        );\n    } catch (e) {\n      this.logger.debug(\n        `An error occurred while getting Cardano rosen data from GraphQL: ${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 and builds token transformation from UTXO and tokenMap\n   * @param box transaction output\n   * @param toChain event target chain\n   */\n  getAssetTransformation = (\n    box: GraphQLTxOutput,\n    toChain: string,\n  ): TokenTransformation | undefined => {\n    // try to build transformation using locked assets\n    for (const boxToken of box.tokens) {\n      const token = this.tokens.search(CARDANO_CHAIN, {\n        tokenId: getCardanoTokenId(\n          boxToken.asset.policyId,\n          boxToken.asset.assetName,\n        ),\n      });\n      if (token.length > 0 && Object.hasOwn(token[0], toChain))\n        return {\n          from: this.tokens.getID(token[0], CARDANO_CHAIN),\n          to: this.tokens.getID(token[0], toChain),\n          amount: boxToken.quantity,\n        };\n    }\n\n    // try to build transformation using locked ADA\n    const lovelace = this.tokens.search(CARDANO_CHAIN, {\n      tokenId: CARDANO_NATIVE_TOKEN,\n    });\n    if (lovelace.length > 0 && Object.hasOwn(lovelace[0], toChain)) {\n      return {\n        from: CARDANO_NATIVE_TOKEN,\n        to: this.tokens.getID(lovelace[0], toChain),\n        amount: box.value,\n      };\n    } else {\n      return undefined;\n    }\n  };\n}\n"]}

package/dist/getRosenData/cardano/{CardanoKoiosRosenExtractor.d.ts → cardanoKoiosRosenExtractor.d.ts}

@@ -1,5 +1,5 @@
 import { RosenData, TokenTransformation } from '../abstract/types';
-import AbstractRosenDataExtractor from '../abstract/AbstractRosenDataExtractor';
+import AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';
 import { KoiosCborTransaction } from './types';
 import { TransactionOutputJSON } from '@emurgo/cardano-serialization-lib-nodejs';
 export declare class CardanoKoiosRosenExtractor extends AbstractRosenDataExtractor<KoiosCborTransaction> {
@@ -16,4 +16,4 @@ export declare class CardanoKoiosRosenExtractor extends AbstractRosenDataExtract
      */
     getAssetTransformation: (box: TransactionOutputJSON, toChain: string) => TokenTransformation | undefined;
 }
-//# sourceMappingURL=CardanoKoiosRosenExtractor.d.ts.map
+//# sourceMappingURL=cardanoKoiosRosenExtractor.d.ts.map

package/dist/getRosenData/cardano/{CardanoKoiosRosenExtractor.d.ts.map → cardanoKoiosRosenExtractor.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"CardanoKoiosRosenExtractor.d.ts","sourceRoot":"","sources":["../../../lib/getRosenData/cardano/CardanoKoiosRosenExtractor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,0BAA0B,MAAM,wCAAwC,CAAC;AAEhF,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAG/C,OAAO,EACL,qBAAqB,EAKtB,MAAM,0CAA0C,CAAC;AAElD,qBAAa,0BAA2B,SAAQ,0BAA0B,CAAC,oBAAoB,CAAC;IAC9F,QAAQ,CAAC,KAAK,aAAiB;IAE/B;;;OAGG;IACH,cAAc,GACZ,aAAa,oBAAoB,KAChC,SAAS,GAAG,SAAS,CA0DtB;IAEF;;;;OAIG;IACH,sBAAsB,GACpB,KAAK,qBAAqB,EAC1B,SAAS,MAAM,KACd,mBAAmB,GAAG,SAAS,CAsChC;CACH"}
+{"version":3,"file":"cardanoKoiosRosenExtractor.d.ts","sourceRoot":"","sources":["../../../lib/getRosenData/cardano/cardanoKoiosRosenExtractor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,0BAA0B,MAAM,wCAAwC,CAAC;AAEhF,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAG/C,OAAO,EACL,qBAAqB,EAKtB,MAAM,0CAA0C,CAAC;AAElD,qBAAa,0BAA2B,SAAQ,0BAA0B,CAAC,oBAAoB,CAAC;IAC9F,QAAQ,CAAC,KAAK,aAAiB;IAE/B;;;OAGG;IACH,cAAc,GACZ,aAAa,oBAAoB,KAChC,SAAS,GAAG,SAAS,CA4DtB;IAEF;;;;OAIG;IACH,sBAAsB,GACpB,KAAK,qBAAqB,EAC1B,SAAS,MAAM,KACd,mBAAmB,GAAG,SAAS,CAsChC;CACH"}

package/dist/getRosenData/cardano/cardanoKoiosRosenExtractor.js

@@ -0,0 +1,97 @@
+import { isPlainObject } from 'lodash-es';
+import AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';
+import { CARDANO_CHAIN, CARDANO_NATIVE_TOKEN } from '../const';
+import JsonBigInt from '@rosen-bridge/json-bigint';
+import { getCardanoTokenId, parseRosenData } from './utils';
+import { decode_metadatum_to_json_str, BigNum, GeneralTransactionMetadata, MetadataJsonSchema, } from '@emurgo/cardano-serialization-lib-nodejs';
+export class CardanoKoiosRosenExtractor extends AbstractRosenDataExtractor {
+    chain = CARDANO_CHAIN;
+    /**
+     * extracts RosenData from given lock transaction in Koios format
+     * @param transaction the lock transaction in Koios format
+     */
+    extractRawData = (transaction) => {
+        const baseError = `No rosen data found for tx [${transaction.tx_hash}]`;
+        if (!transaction.auxiliary_data)
+            return undefined;
+        const metadata = transaction.auxiliary_data.metadata;
+        try {
+            if (metadata && Object.prototype.hasOwnProperty.call(metadata, '0')) {
+                const metadataObject = GeneralTransactionMetadata.from_json(JsonBigInt.stringify(metadata));
+                const data = JsonBigInt.parse(decode_metadatum_to_json_str(metadataObject.get(BigNum.from_str('0')), MetadataJsonSchema.NoConversions));
+                const rosenData = parseRosenData(data);
+                if (rosenData) {
+                    const lockOutputs = transaction.body.outputs.filter((output) => output.address === this.lockAddress);
+                    for (const output of lockOutputs) {
+                        const assetTransformation = this.getAssetTransformation(output, rosenData.toChain);
+                        if (assetTransformation) {
+                            return {
+                                ...rosenData,
+                                sourceChainTokenId: assetTransformation.from,
+                                amount: assetTransformation.amount,
+                                targetChainTokenId: assetTransformation.to,
+                                sourceTxId: transaction.tx_hash,
+                                // TODO: save rawData in CBOR (local:ergo/rosen-bridge/utils#293)
+                                rawData: JsonBigInt.stringify(data),
+                            };
+                        }
+                    }
+                    this.logger.debug(baseError + `: No valid transformation found in any output boxes`);
+                }
+                else
+                    this.logger.debug(baseError +
+                        `: Incomplete metadata. isPlain: ${isPlainObject(data)}, data: ${JsonBigInt.stringify(data)}`);
+            }
+            else
+                this.logger.debug(baseError + `: Invalid metadata: ${JsonBigInt.stringify(metadata)}`);
+        }
+        catch (e) {
+            this.logger.debug(`An error occurred while getting Cardano rosen data from Koios: ${e}`);
+            if (e instanceof Error && e.stack) {
+                this.logger.debug(e.stack);
+            }
+        }
+        return undefined;
+    };
+    /**
+     * 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
+        if (box.amount.multiasset) {
+            const assets = box.amount.multiasset;
+            for (const policyId of Object.keys(assets)) {
+                for (const assetName of Object.keys(assets[policyId])) {
+                    const token = this.tokens.search(CARDANO_CHAIN, {
+                        tokenId: getCardanoTokenId(policyId, assetName),
+                    });
+                    if (token.length > 0 && Object.hasOwn(token[0], toChain)) {
+                        return {
+                            from: this.tokens.getID(token[0], CARDANO_CHAIN),
+                            to: this.tokens.getID(token[0], toChain),
+                            amount: assets[policyId][assetName].toString(),
+                        };
+                    }
+                }
+            }
+        }
+        // try to build transformation using locked ADA
+        const lovelace = this.tokens.search(CARDANO_CHAIN, {
+            tokenId: CARDANO_NATIVE_TOKEN,
+        });
+        if (lovelace.length > 0 && Object.hasOwn(lovelace[0], toChain)) {
+            return {
+                from: CARDANO_NATIVE_TOKEN,
+                to: this.tokens.getID(lovelace[0], toChain),
+                amount: box.amount.coin,
+            };
+        }
+        else {
+            this.logger.debug(`No rosen asset transformation found for box with assets: ${JsonBigInt.stringify(box.amount)}`);
+            return undefined;
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cardanoKoiosRosenExtractor.js","sourceRoot":"","sources":["../../../lib/getRosenData/cardano/cardanoKoiosRosenExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["import { isPlainObject } from 'lodash-es';\nimport { RosenData, TokenTransformation } from '../abstract/types';\nimport AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';\nimport { CARDANO_CHAIN, CARDANO_NATIVE_TOKEN } from '../const';\nimport { KoiosCborTransaction } from './types';\nimport JsonBigInt from '@rosen-bridge/json-bigint';\nimport { getCardanoTokenId, parseRosenData } from './utils';\nimport {\n  TransactionOutputJSON,\n  decode_metadatum_to_json_str,\n  BigNum,\n  GeneralTransactionMetadata,\n  MetadataJsonSchema,\n} from '@emurgo/cardano-serialization-lib-nodejs';\n\nexport class CardanoKoiosRosenExtractor extends AbstractRosenDataExtractor<KoiosCborTransaction> {\n  readonly chain = CARDANO_CHAIN;\n\n  /**\n   * extracts RosenData from given lock transaction in Koios format\n   * @param transaction the lock transaction in Koios format\n   */\n  extractRawData = (\n    transaction: KoiosCborTransaction,\n  ): RosenData | undefined => {\n    const baseError = `No rosen data found for tx [${transaction.tx_hash}]`;\n    if (!transaction.auxiliary_data) return undefined;\n    const metadata = transaction.auxiliary_data.metadata;\n    try {\n      if (metadata && Object.prototype.hasOwnProperty.call(metadata, '0')) {\n        const metadataObject = GeneralTransactionMetadata.from_json(\n          JsonBigInt.stringify(metadata),\n        );\n        const data = JsonBigInt.parse(\n          decode_metadatum_to_json_str(\n            metadataObject.get(BigNum.from_str('0'))!,\n            MetadataJsonSchema.NoConversions,\n          ),\n        );\n        const rosenData = parseRosenData(data);\n        if (rosenData) {\n          const lockOutputs = transaction.body.outputs.filter(\n            (output) => output.address === this.lockAddress,\n          );\n          for (const output of lockOutputs) {\n            const assetTransformation = this.getAssetTransformation(\n              output,\n              rosenData.toChain,\n            );\n            if (assetTransformation) {\n              return {\n                ...rosenData,\n                sourceChainTokenId: assetTransformation.from,\n                amount: assetTransformation.amount,\n                targetChainTokenId: assetTransformation.to,\n                sourceTxId: transaction.tx_hash,\n                // TODO: save rawData in CBOR (local:ergo/rosen-bridge/utils#293)\n                rawData: JsonBigInt.stringify(data),\n              };\n            }\n          }\n          this.logger.debug(\n            baseError + `: No valid transformation found in any output boxes`,\n          );\n        } else\n          this.logger.debug(\n            baseError +\n              `: Incomplete metadata. isPlain: ${isPlainObject(\n                data,\n              )}, data: ${JsonBigInt.stringify(data)}`,\n          );\n      } else\n        this.logger.debug(\n          baseError + `: Invalid metadata: ${JsonBigInt.stringify(metadata)}`,\n        );\n    } catch (e) {\n      this.logger.debug(\n        `An error occurred while getting Cardano rosen data from Koios: ${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 and builds token transformation from UTXO and tokenMap\n   * @param box transaction output\n   * @param toChain event target chain\n   */\n  getAssetTransformation = (\n    box: TransactionOutputJSON,\n    toChain: string,\n  ): TokenTransformation | undefined => {\n    // try to build transformation using locked assets\n    if (box.amount.multiasset) {\n      const assets = box.amount.multiasset;\n      for (const policyId of Object.keys(assets)) {\n        for (const assetName of Object.keys(assets[policyId])) {\n          const token = this.tokens.search(CARDANO_CHAIN, {\n            tokenId: getCardanoTokenId(policyId, assetName),\n          });\n          if (token.length > 0 && Object.hasOwn(token[0], toChain)) {\n            return {\n              from: this.tokens.getID(token[0], CARDANO_CHAIN),\n              to: this.tokens.getID(token[0], toChain),\n              amount: assets[policyId][assetName].toString(),\n            };\n          }\n        }\n      }\n    }\n\n    // try to build transformation using locked ADA\n    const lovelace = this.tokens.search(CARDANO_CHAIN, {\n      tokenId: CARDANO_NATIVE_TOKEN,\n    });\n    if (lovelace.length > 0 && Object.hasOwn(lovelace[0], toChain)) {\n      return {\n        from: CARDANO_NATIVE_TOKEN,\n        to: this.tokens.getID(lovelace[0], toChain),\n        amount: box.amount.coin,\n      };\n    } else {\n      this.logger.debug(\n        `No rosen asset transformation found for box with assets: ${JsonBigInt.stringify(\n          box.amount,\n        )}`,\n      );\n      return undefined;\n    }\n  };\n}\n"]}

package/dist/getRosenData/cardano/{CardanoOgmiosRosenExtractor.d.ts → cardanoOgmiosRosenExtractor.d.ts}

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

package/dist/getRosenData/cardano/{CardanoOgmiosRosenExtractor.d.ts.map → cardanoOgmiosRosenExtractor.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"CardanoOgmiosRosenExtractor.d.ts","sourceRoot":"","sources":["../../../lib/getRosenData/cardano/CardanoOgmiosRosenExtractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,0BAA0B,MAAM,wCAAwC,CAAC;AAEhF,OAAO,EAEL,WAAW,EACX,iBAAiB,EAClB,MAAM,wBAAwB,CAAC;AAIhC,qBAAa,2BAA4B,SAAQ,0BAA0B,CAAC,WAAW,CAAC;IACtF,QAAQ,CAAC,KAAK,aAAiB;IAC/B;;;OAGG;IACH,cAAc,GAAI,aAAa,WAAW,KAAG,SAAS,GAAG,SAAS,CAqDhE;IAEF;;;;OAIG;IACH,sBAAsB,GACpB,KAAK,iBAAiB,EACtB,SAAS,MAAM,KACd,mBAAmB,GAAG,SAAS,CAuChC;CACH"}
+{"version":3,"file":"cardanoOgmiosRosenExtractor.d.ts","sourceRoot":"","sources":["../../../lib/getRosenData/cardano/cardanoOgmiosRosenExtractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,0BAA0B,MAAM,wCAAwC,CAAC;AAEhF,OAAO,EAEL,WAAW,EACX,iBAAiB,EAClB,MAAM,wBAAwB,CAAC;AAIhC,qBAAa,2BAA4B,SAAQ,0BAA0B,CAAC,WAAW,CAAC;IACtF,QAAQ,CAAC,KAAK,aAAiB;IAC/B;;;OAGG;IACH,cAAc,GAAI,aAAa,WAAW,KAAG,SAAS,GAAG,SAAS,CAuDhE;IAEF;;;;OAIG;IACH,sBAAsB,GACpB,KAAK,iBAAiB,EACtB,SAAS,MAAM,KACd,mBAAmB,GAAG,SAAS,CAuChC;CACH"}