@rosen-bridge/rosen-extractor 8.0.1 → 9.0.0

package/dist/getRosenData/cardano/CardanoGraphQLRosenExtractor.js

@@ -0,0 +1,92 @@
+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,
+                            };
+                        }
+                        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              };\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.map

@@ -0,0 +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"}

package/dist/getRosenData/cardano/CardanoKoiosRosenExtractor.js

@@ -0,0 +1,95 @@
+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,
+                            };
+                        }
+                    }
+                    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              };\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.map

@@ -0,0 +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"}

package/dist/getRosenData/cardano/CardanoOgmiosRosenExtractor.js

@@ -0,0 +1,97 @@
+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 CardanoOgmiosRosenExtractor extends AbstractRosenDataExtractor {
+    chain = CARDANO_CHAIN;
+    /**
+     * extracts RosenData from given lock transaction in Ogmios format
+     * @param transaction the lock transaction in Koios format
+     */
+    extractRawData = (transaction) => {
+        const baseError = `No rosen data found for tx [${transaction.id}]`;
+        const metadata = transaction.metadata;
+        try {
+            if (metadata) {
+                const blob = metadata.labels;
+                if (blob && blob['0'] && blob['0'].json) {
+                    const data = blob['0'].json;
+                    const rosenData = parseRosenData(data);
+                    if (rosenData) {
+                        const lockOutputs = transaction.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.id,
+                                };
+                            }
+                        }
+                        this.logger.debug(baseError + `: No valid transformation found in any output boxes`);
+                    }
+                    else
+                        this.logger.debug(baseError +
+                            `: Incomplete metadata: ${JsonBigInt.stringify(metadata)}`);
+                }
+                else
+                    this.logger.debug(baseError + `: Invalid blob: ${JsonBigInt.stringify(metadata)}`);
+            }
+            else
+                this.logger.debug(baseError + `: Invalid metadata: ${JsonBigInt.stringify(metadata)}`);
+        }
+        catch (e) {
+            this.logger.debug(`An error occurred while getting Cardano rosen data from Ogmios: ${e}`);
+            if (e instanceof Error && e.stack) {
+                this.logger.debug(e.stack);
+            }
+        }
+        return undefined;
+    };
+    /**
+     * extracts and builds token transformation from TxOut and tokenMap
+     * @param box transaction output
+     * @param toChain event target chain
+     */
+    getAssetTransformation = (box, toChain) => {
+        // try to build transformation using locked assets
+        const assets = box.value;
+        for (const policyId of Object.keys(assets)) {
+            if (policyId === CARDANO_NATIVE_TOKEN)
+                continue;
+            // according to ogmios v6 docs assets are stores as
+            //      [policyId]: {[assetName]: amount}
+            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: assets.ada.lovelace.toString(),
+            };
+        }
+        else {
+            this.logger.debug(`No rosen asset transformation found for Ogmios box with assets: ${JsonBigInt.stringify(box.value.assets)}`);
+            return undefined;
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CardanoOgmiosRosenExtractor.js","sourceRoot":"","sources":["../../../lib/getRosenData/cardano/CardanoOgmiosRosenExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["import { RosenData, TokenTransformation } from '../abstract/types';\nimport AbstractRosenDataExtractor from '../abstract/AbstractRosenDataExtractor';\nimport { CARDANO_CHAIN, CARDANO_NATIVE_TOKEN } from '../const';\nimport {\n  ObjectNoSchema,\n  Transaction,\n  TransactionOutput,\n} from '@cardano-ogmios/schema';\nimport JsonBigInt from '@rosen-bridge/json-bigint';\nimport { getCardanoTokenId, parseRosenData } from './utils';\n\nexport class CardanoOgmiosRosenExtractor extends AbstractRosenDataExtractor<Transaction> {\n  readonly chain = CARDANO_CHAIN;\n  /**\n   * extracts RosenData from given lock transaction in Ogmios format\n   * @param transaction the lock transaction in Koios format\n   */\n  extractRawData = (transaction: Transaction): RosenData | undefined => {\n    const baseError = `No rosen data found for tx [${transaction.id}]`;\n    const metadata = transaction.metadata;\n    try {\n      if (metadata) {\n        const blob = metadata.labels;\n        if (blob && blob['0'] && blob['0'].json) {\n          const data = blob['0'].json as ObjectNoSchema;\n          const rosenData = parseRosenData(data);\n          if (rosenData) {\n            const lockOutputs = transaction.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.id,\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: ${JsonBigInt.stringify(metadata)}`\n            );\n        } else\n          this.logger.debug(\n            baseError + `: Invalid blob: ${JsonBigInt.stringify(metadata)}`\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 Ogmios: ${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 TxOut and tokenMap\n   * @param box transaction output\n   * @param toChain event target chain\n   */\n  getAssetTransformation = (\n    box: TransactionOutput,\n    toChain: string\n  ): TokenTransformation | undefined => {\n    // try to build transformation using locked assets\n    const assets = box.value;\n    for (const policyId of Object.keys(assets)) {\n      if (policyId === CARDANO_NATIVE_TOKEN) continue;\n      // according to ogmios v6 docs assets are stores as\n      //      [policyId]: {[assetName]: amount}\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    // 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: assets.ada.lovelace.toString(),\n      };\n    } else {\n      this.logger.debug(\n        `No rosen asset transformation found for Ogmios box with assets: ${JsonBigInt.stringify(\n          box.value.assets\n        )}`\n      );\n      return undefined;\n    }\n  };\n}\n"]}

package/dist/getRosenData/cardano/CardanoRosenExtractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CardanoRosenExtractor.d.ts","sourceRoot":"","sources":["../../../lib/getRosenData/cardano/CardanoRosenExtractor.ts"],"names":[],"mappings":"AAAA,OAAO,0BAA0B,MAAM,wCAAwC,CAAC;AAChF,OAAO,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,EAAE,mBAAmB,EAAa,MAAM,SAAS,CAAC;AAKzD,qBAAa,qBAAsB,SAAQ,0BAA0B,CAAC,MAAM,CAAC;IAC3E,QAAQ,CAAC,KAAK,aAAiB;IAC/B;;;OAGG;IACH,cAAc,GAAI,uBAAuB,MAAM,KAAG,SAAS,GAAG,SAAS,CAiDrE;IAEF;;;;OAIG;IACH,sBAAsB,GACpB,KAAK,mBAAmB,EACxB,SAAS,MAAM,KACd,mBAAmB,GAAG,SAAS,CAkChC;CACH"}

package/dist/getRosenData/cardano/CardanoRosenExtractor.js

@@ -0,0 +1,88 @@
+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 CardanoRosenExtractor extends AbstractRosenDataExtractor {
+    chain = CARDANO_CHAIN;
+    /**
+     * extracts RosenData from given lock transaction in CardanoTx format
+     * @param serializedTransaction stringified transaction in CardanoTx format
+     */
+    extractRawData = (serializedTransaction) => {
+        let transaction;
+        try {
+            transaction = JsonBigInt.parse(serializedTransaction);
+        }
+        catch (e) {
+            throw new Error(`Failed to parse transaction json to CardanoTx format while extracting rosen data: ${e}`);
+        }
+        try {
+            const baseError = `No rosen data found for tx [${transaction.id}]`;
+            const data = transaction.metadata?.['0'];
+            const rosenData = parseRosenData(data);
+            if (rosenData) {
+                const lockOutputs = transaction.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.id,
+                        };
+                    }
+                }
+                this.logger.debug(baseError + `: No valid transformation found in any output boxes`);
+            }
+            else
+                this.logger.debug(baseError +
+                    `: Incomplete metadata: ${JsonBigInt.stringify(transaction.metadata)}`);
+        }
+        catch (e) {
+            this.logger.debug(`An error occurred while extracting rosen data: ${e}`);
+            if (e instanceof Error && e.stack) {
+                this.logger.debug(e.stack);
+            }
+        }
+        return undefined;
+    };
+    /**
+     * extracts and builds token transformation from CardanoBoxCandidate and tokenMap
+     * @param box transaction output in CardanoBoxCandidate format
+     * @param toChain event target chain
+     */
+    getAssetTransformation = (box, toChain) => {
+        // try to build transformation using locked assets
+        if (box.assets.length > 0) {
+            for (const asset of box.assets) {
+                const token = this.tokens.search(CARDANO_CHAIN, {
+                    tokenId: getCardanoTokenId(asset.policyId, 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: 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)) {
+            return {
+                from: CARDANO_NATIVE_TOKEN,
+                to: this.tokens.getID(lovelace[0], toChain),
+                amount: box.value.toString(),
+            };
+        }
+        else {
+            this.logger.debug(`No rosen asset transformation found for CardanoBoxCandidate with assets: ${JsonBigInt.stringify(box.assets)}`);
+            return undefined;
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CardanoRosenExtractor.js","sourceRoot":"","sources":["../../../lib/getRosenData/cardano/CardanoRosenExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["import AbstractRosenDataExtractor from '../abstract/AbstractRosenDataExtractor';\nimport { RosenData, TokenTransformation } from '../abstract/types';\nimport { CardanoBoxCandidate, CardanoTx } from './types';\nimport { CARDANO_CHAIN, CARDANO_NATIVE_TOKEN } from '../const';\nimport JsonBigInt from '@rosen-bridge/json-bigint';\nimport { getCardanoTokenId, parseRosenData } from './utils';\n\nexport class CardanoRosenExtractor extends AbstractRosenDataExtractor<string> {\n  readonly chain = CARDANO_CHAIN;\n  /**\n   * extracts RosenData from given lock transaction in CardanoTx format\n   * @param serializedTransaction stringified transaction in CardanoTx format\n   */\n  extractRawData = (serializedTransaction: string): RosenData | undefined => {\n    let transaction: CardanoTx;\n    try {\n      transaction = JsonBigInt.parse(serializedTransaction);\n    } catch (e) {\n      throw new Error(\n        `Failed to parse transaction json to CardanoTx format while extracting rosen data: ${e}`\n      );\n    }\n    try {\n      const baseError = `No rosen data found for tx [${transaction.id}]`;\n      const data = transaction.metadata?.['0'];\n      const rosenData = parseRosenData(data);\n      if (rosenData) {\n        const lockOutputs = transaction.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.id,\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: ${JsonBigInt.stringify(\n              transaction.metadata\n            )}`\n        );\n    } catch (e) {\n      this.logger.debug(`An error occurred while extracting rosen data: ${e}`);\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 CardanoBoxCandidate and tokenMap\n   * @param box transaction output in CardanoBoxCandidate format\n   * @param toChain event target chain\n   */\n  getAssetTransformation = (\n    box: CardanoBoxCandidate,\n    toChain: string\n  ): TokenTransformation | undefined => {\n    // try to build transformation using locked assets\n    if (box.assets.length > 0) {\n      for (const asset of box.assets) {\n        const token = this.tokens.search(CARDANO_CHAIN, {\n          tokenId: getCardanoTokenId(asset.policyId, asset.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\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.toString(),\n      };\n    } else {\n      this.logger.debug(\n        `No rosen asset transformation found for CardanoBoxCandidate with assets: ${JsonBigInt.stringify(\n          box.assets\n        )}`\n      );\n      return undefined;\n    }\n  };\n}\n"]}

package/dist/getRosenData/cardano/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../lib/getRosenData/cardano/types.ts"],"names":[],"mappings":"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"}

package/dist/getRosenData/cardano/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/getRosenData/cardano/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../lib/getRosenData/cardano/utils.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,cAAc,GAAI,MAAM,GAAG;;;;;;aAoBvC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,UAAU,MAAM,EAAE,WAAW,MAAM,WACzC,CAAC"}

package/dist/getRosenData/cardano/utils.js

@@ -0,0 +1,32 @@
+import { isArray, isString, isPlainObject } from 'lodash-es';
+/**
+ * Parse and validate Rosen data encoded in transaction metadata
+ * @param data
+ * @returns Rosen data or undefined if metadata is invalid
+ */
+export const parseRosenData = (data) => {
+    if (data &&
+        isPlainObject(data) &&
+        isString(data.to) &&
+        isString(data.networkFee) &&
+        isString(data.bridgeFee) &&
+        isString(data.toAddress) &&
+        isArray(data.fromAddress) &&
+        data.fromAddress.every(isString)) {
+        return {
+            toChain: data.to,
+            toAddress: data.toAddress,
+            bridgeFee: data.bridgeFee,
+            networkFee: data.networkFee,
+            fromAddress: data.fromAddress.join(''),
+        };
+    }
+    return undefined;
+};
+/**
+ * @param policyId
+ * @param assetName
+ * @returns the concatenation of policyId and assetName by '.' which represents the token Id in Rosen packages and services
+ */
+export const getCardanoTokenId = (policyId, assetName) => `${policyId}.${assetName}`;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/{lib/getRosenData → getRosenData}/const.d.ts

@@ -8,6 +8,6 @@ export declare const CARDANO_CHAIN = "cardano";
 export declare const ERGO_CHAIN = "ergo";
 export declare const DOGE_CHAIN = "doge";
 export declare const DOGE_NATIVE_TOKEN = "doge";
-export declare const RUNES_CHAIN = "bitcoin-runes";
+export declare const BITCOIN_RUNES_CHAIN = "bitcoin-runes";
 export declare const SUPPORTED_CHAINS: string[];
 //# sourceMappingURL=const.d.ts.map

package/dist/getRosenData/const.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../../lib/getRosenData/const.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,QAAQ,CAAC;AAC1C,eAAO,MAAM,iBAAiB,QAAQ,CAAC;AACvC,eAAO,MAAM,oBAAoB,QAAQ,CAAC;AAC1C,eAAO,MAAM,aAAa,YAAY,CAAC;AACvC,eAAO,MAAM,cAAc,aAAa,CAAC;AACzC,eAAO,MAAM,aAAa,YAAY,CAAC;AACvC,eAAO,MAAM,aAAa,YAAY,CAAC;AACvC,eAAO,MAAM,UAAU,SAAS,CAAC;AACjC,eAAO,MAAM,UAAU,SAAS,CAAC;AACjC,eAAO,MAAM,iBAAiB,SAAS,CAAC;AACxC,eAAO,MAAM,mBAAmB,kBAAkB,CAAC;AACnD,eAAO,MAAM,gBAAgB,UAQ5B,CAAC"}

package/dist/getRosenData/const.js

@@ -0,0 +1,21 @@
+export const CARDANO_NATIVE_TOKEN = 'ada';
+export const ERGO_NATIVE_TOKEN = 'erg';
+export const BITCOIN_NATIVE_TOKEN = 'btc';
+export const BITCOIN_CHAIN = 'bitcoin';
+export const ETHEREUM_CHAIN = 'ethereum';
+export const BINANCE_CHAIN = 'binance';
+export const CARDANO_CHAIN = 'cardano';
+export const ERGO_CHAIN = 'ergo';
+export const DOGE_CHAIN = 'doge';
+export const DOGE_NATIVE_TOKEN = 'doge';
+export const BITCOIN_RUNES_CHAIN = 'bitcoin-runes';
+export const SUPPORTED_CHAINS = [
+    ERGO_CHAIN,
+    CARDANO_CHAIN,
+    BITCOIN_CHAIN,
+    ETHEREUM_CHAIN,
+    BINANCE_CHAIN,
+    DOGE_CHAIN,
+    BITCOIN_RUNES_CHAIN,
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9saWIvZ2V0Um9zZW5EYXRhL2NvbnN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFHLEtBQUssQ0FBQztBQUMxQyxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRyxLQUFLLENBQUM7QUFDdkMsTUFBTSxDQUFDLE1BQU0sb0JBQW9CLEdBQUcsS0FBSyxDQUFDO0FBQzFDLE1BQU0sQ0FBQyxNQUFNLGFBQWEsR0FBRyxTQUFTLENBQUM7QUFDdkMsTUFBTSxDQUFDLE1BQU0sY0FBYyxHQUFHLFVBQVUsQ0FBQztBQUN6QyxNQUFNLENBQUMsTUFBTSxhQUFhLEdBQUcsU0FBUyxDQUFDO0FBQ3ZDLE1BQU0sQ0FBQyxNQUFNLGFBQWEsR0FBRyxTQUFTLENBQUM7QUFDdkMsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHLE1BQU0sQ0FBQztBQUNqQyxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQUcsTUFBTSxDQUFDO0FBQ2pDLE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUFHLE1BQU0sQ0FBQztBQUN4QyxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxlQUFlLENBQUM7QUFDbkQsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUc7SUFDOUIsVUFBVTtJQUNWLGFBQWE7SUFDYixhQUFhO0lBQ2IsY0FBYztJQUNkLGFBQWE7SUFDYixVQUFVO0lBQ1YsbUJBQW1CO0NBQ3BCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgQ0FSREFOT19OQVRJVkVfVE9LRU4gPSAnYWRhJztcbmV4cG9ydCBjb25zdCBFUkdPX05BVElWRV9UT0tFTiA9ICdlcmcnO1xuZXhwb3J0IGNvbnN0IEJJVENPSU5fTkFUSVZFX1RPS0VOID0gJ2J0Yyc7XG5leHBvcnQgY29uc3QgQklUQ09JTl9DSEFJTiA9ICdiaXRjb2luJztcbmV4cG9ydCBjb25zdCBFVEhFUkVVTV9DSEFJTiA9ICdldGhlcmV1bSc7XG5leHBvcnQgY29uc3QgQklOQU5DRV9DSEFJTiA9ICdiaW5hbmNlJztcbmV4cG9ydCBjb25zdCBDQVJEQU5PX0NIQUlOID0gJ2NhcmRhbm8nO1xuZXhwb3J0IGNvbnN0IEVSR09fQ0hBSU4gPSAnZXJnbyc7XG5leHBvcnQgY29uc3QgRE9HRV9DSEFJTiA9ICdkb2dlJztcbmV4cG9ydCBjb25zdCBET0dFX05BVElWRV9UT0tFTiA9ICdkb2dlJztcbmV4cG9ydCBjb25zdCBCSVRDT0lOX1JVTkVTX0NIQUlOID0gJ2JpdGNvaW4tcnVuZXMnO1xuZXhwb3J0IGNvbnN0IFNVUFBPUlRFRF9DSEFJTlMgPSBbXG4gIEVSR09fQ0hBSU4sXG4gIENBUkRBTk9fQ0hBSU4sXG4gIEJJVENPSU5fQ0hBSU4sXG4gIEVUSEVSRVVNX0NIQUlOLFxuICBCSU5BTkNFX0NIQUlOLFxuICBET0dFX0NIQUlOLFxuICBCSVRDT0lOX1JVTkVTX0NIQUlOLFxuXTtcbiJdfQ==

package/dist/getRosenData/doge/DogeEsploraRosenExtractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DogeEsploraRosenExtractor.d.ts","sourceRoot":"","sources":["../../../lib/getRosenData/doge/DogeEsploraRosenExtractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,0BAA0B,MAAM,wCAAwC,CAAC;AAEhF,OAAO,EAAE,sBAAsB,EAAE,eAAe,EAAgB,MAAM,SAAS,CAAC;AAChF,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAG/D,qBAAa,yBAA0B,SAAQ,0BAA0B,CAAC,sBAAsB,CAAC;IAC/F,QAAQ,CAAC,KAAK,UAAc;IAC5B,SAAS,CAAC,gBAAgB,EAAE,MAAM,CAAC;gBAEvB,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,cAAc;IAK1E;;;OAGG;IACH,cAAc,GACZ,aAAa,sBAAsB,KAClC,SAAS,GAAG,SAAS,CA6EtB;IAEF;;;;OAIG;IACH,sBAAsB,GACpB,KAAK,eAAe,EACpB,SAAS,MAAM,KACd,mBAAmB,GAAG,SAAS,CAehC;CACH"}