@rosen-bridge/rosen-extractor 11.2.2 → 12.0.0

package/dist/getRosenData/handshake/handshakeRosenExtractor.js

@@ -0,0 +1,104 @@
+import JsonBigInt from '@rosen-bridge/json-bigint';
+import { parseRosenData } from '../../utils';
+import AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';
+import { HANDSHAKE_CHAIN, HANDSHAKE_NATIVE_TOKEN } from '../const';
+import { addressToHash, extractDataFromOutputs } from './utils';
+export class HandshakeRosenExtractor extends AbstractRosenDataExtractor {
+    chain = HANDSHAKE_CHAIN;
+    lockAddressHash;
+    constructor(lockAddress, tokens, logger) {
+        super(lockAddress, tokens, logger);
+        this.lockAddressHash = addressToHash(lockAddress);
+    }
+    /**
+     * extracts RosenData from given lock transaction in HandshakeTx format
+     * @param serializedTransaction stringified transaction in HandshakeTx format
+     */
+    extractData = (serializedTransaction) => {
+        let transaction;
+        try {
+            transaction = JsonBigInt.parse(serializedTransaction);
+        }
+        catch (e) {
+            throw new Error(`Failed to parse transaction json to HandshakeTx format while extracting rosen data: ${e}`);
+        }
+        const baseError = `No rosen data found for tx [${transaction.id}]`;
+        try {
+            const outputs = transaction.outputs;
+            if (outputs.length < 2) {
+                this.logger.debug(baseError + `: Insufficient number of outputs`);
+                return undefined;
+            }
+            // Find lock output and position
+            const lockOutputIndex = outputs.findIndex((output) => output.address?.hash === this.lockAddressHash);
+            if (lockOutputIndex === -1) {
+                this.logger.debug(baseError + `: Lock output not found`);
+                return undefined;
+            }
+            const lockOutput = outputs[lockOutputIndex];
+            // Extract data from outputs using utility function
+            const reconstructedData = extractDataFromOutputs(outputs, lockOutputIndex);
+            if (!reconstructedData) {
+                this.logger.debug(baseError + `: No data chunks found`);
+                return undefined;
+            }
+            // Parse the reconstructed data
+            let rosenData;
+            try {
+                rosenData = parseRosenData(reconstructedData);
+                this.logger.debug(`Successfully extracted Rosen data for [${rosenData.toChain}]`);
+            }
+            catch (e) {
+                this.logger.debug(baseError + `: Failed to parse reconstructed data: ${e}`);
+                return undefined;
+            }
+            // Find asset transformation using the lock output
+            const assetTransformation = this.getAssetTransformation(lockOutput, rosenData.toChain);
+            if (!assetTransformation) {
+                this.logger.debug(baseError + `: Failed to find rosen asset transformation`);
+                return undefined;
+            }
+            const fromAddress = `box:${transaction.inputs[0].txId}.${transaction.inputs[0].index}`;
+            return {
+                toChain: rosenData.toChain,
+                toAddress: rosenData.toAddress,
+                bridgeFee: rosenData.bridgeFee,
+                networkFee: rosenData.networkFee,
+                fromAddress: fromAddress,
+                sourceChainTokenId: assetTransformation.from,
+                amount: assetTransformation.amount,
+                targetChainTokenId: assetTransformation.to,
+                sourceTxId: transaction.id,
+                rawData: outputs
+                    .map((output) => `${output.address?.hash}:${output.value}`)
+                    .join(','),
+            };
+        }
+        catch (e) {
+            this.logger.debug(`An error occurred while getting Handshake rosen data: ${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) => {
+        const wrappedHns = this.tokens.search(HANDSHAKE_CHAIN, {
+            tokenId: HANDSHAKE_NATIVE_TOKEN,
+        });
+        if (wrappedHns.length > 0 && Object.hasOwn(wrappedHns[0], toChain)) {
+            return {
+                from: HANDSHAKE_NATIVE_TOKEN,
+                to: this.tokens.getID(wrappedHns[0], toChain),
+                amount: box.value.toString(),
+            };
+        }
+        return undefined;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"handshakeRosenExtractor.js","sourceRoot":"","sources":["../../../lib/getRosenData/handshake/handshakeRosenExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractLogger } from '@rosen-bridge/abstract-logger';\nimport JsonBigInt from '@rosen-bridge/json-bigint';\nimport { TokenMap } from '@rosen-bridge/tokens';\n\nimport { parseRosenData } from '../../utils';\nimport AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';\nimport { RosenData, TokenTransformation } from '../abstract/types';\nimport { HANDSHAKE_CHAIN, HANDSHAKE_NATIVE_TOKEN } from '../const';\nimport { HandshakeTx, HandshakeTxOutput, HandshakeRosenData } from './types';\nimport { addressToHash, extractDataFromOutputs } from './utils';\n\nexport class HandshakeRosenExtractor extends AbstractRosenDataExtractor<string> {\n  readonly chain = HANDSHAKE_CHAIN;\n  protected lockAddressHash: string;\n\n  constructor(lockAddress: string, tokens: TokenMap, logger?: AbstractLogger) {\n    super(lockAddress, tokens, logger);\n    this.lockAddressHash = addressToHash(lockAddress);\n  }\n\n  /**\n   * extracts RosenData from given lock transaction in HandshakeTx format\n   * @param serializedTransaction stringified transaction in HandshakeTx format\n   */\n  extractData = (serializedTransaction: string): RosenData | undefined => {\n    let transaction: HandshakeTx;\n    try {\n      transaction = JsonBigInt.parse(serializedTransaction);\n    } catch (e) {\n      throw new Error(\n        `Failed to parse transaction json to HandshakeTx format while extracting rosen data: ${e}`,\n      );\n    }\n\n    const baseError = `No rosen data found for tx [${transaction.id}]`;\n    try {\n      const outputs = transaction.outputs;\n      if (outputs.length < 2) {\n        this.logger.debug(baseError + `: Insufficient number of outputs`);\n        return undefined;\n      }\n\n      // Find lock output and position\n      const lockOutputIndex = outputs.findIndex(\n        (output) => output.address?.hash === this.lockAddressHash,\n      );\n\n      if (lockOutputIndex === -1) {\n        this.logger.debug(baseError + `: Lock output not found`);\n        return undefined;\n      }\n\n      const lockOutput = outputs[lockOutputIndex];\n\n      // Extract data from outputs using utility function\n      const reconstructedData = extractDataFromOutputs(\n        outputs,\n        lockOutputIndex,\n      );\n\n      if (!reconstructedData) {\n        this.logger.debug(baseError + `: No data chunks found`);\n        return undefined;\n      }\n\n      // Parse the reconstructed data\n      let rosenData: HandshakeRosenData | undefined;\n      try {\n        rosenData = parseRosenData(reconstructedData);\n        this.logger.debug(\n          `Successfully extracted Rosen data for [${rosenData.toChain}]`,\n        );\n      } catch (e) {\n        this.logger.debug(\n          baseError + `: Failed to parse reconstructed data: ${e}`,\n        );\n        return undefined;\n      }\n\n      // Find asset transformation using the lock output\n      const assetTransformation = this.getAssetTransformation(\n        lockOutput,\n        rosenData.toChain,\n      );\n\n      if (!assetTransformation) {\n        this.logger.debug(\n          baseError + `: Failed to find rosen asset transformation`,\n        );\n        return undefined;\n      }\n\n      const fromAddress = `box:${transaction.inputs[0].txId}.${transaction.inputs[0].index}`;\n      return {\n        toChain: rosenData.toChain,\n        toAddress: rosenData.toAddress,\n        bridgeFee: rosenData.bridgeFee,\n        networkFee: rosenData.networkFee,\n        fromAddress: fromAddress,\n        sourceChainTokenId: assetTransformation.from,\n        amount: assetTransformation.amount,\n        targetChainTokenId: assetTransformation.to,\n        sourceTxId: transaction.id,\n        rawData: outputs\n          .map((output) => `${output.address?.hash}:${output.value}`)\n          .join(','),\n      };\n    } catch (e) {\n      this.logger.debug(\n        `An error occurred while getting Handshake rosen data: ${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: HandshakeTxOutput,\n    toChain: string,\n  ): TokenTransformation | undefined => {\n    const wrappedHns = this.tokens.search(HANDSHAKE_CHAIN, {\n      tokenId: HANDSHAKE_NATIVE_TOKEN,\n    });\n\n    if (wrappedHns.length > 0 && Object.hasOwn(wrappedHns[0], toChain)) {\n      return {\n        from: HANDSHAKE_NATIVE_TOKEN,\n        to: this.tokens.getID(wrappedHns[0], toChain),\n        amount: box.value.toString(),\n      };\n    }\n    return undefined;\n  };\n}\n"]}

package/dist/getRosenData/handshake/handshakeRpcRosenExtractor.d.ts

@@ -0,0 +1,22 @@
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { TokenMap } from '@rosen-bridge/tokens';
+import AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';
+import { RosenData, TokenTransformation } from '../abstract/types';
+import { HandshakeRpcTransaction, HandshakeRpcTxOutput } from './types';
+export declare class HandshakeRpcRosenExtractor extends AbstractRosenDataExtractor<HandshakeRpcTransaction> {
+    readonly chain = "handshake";
+    protected lockAddressHash: string;
+    constructor(lockAddress: string, tokens: TokenMap, logger?: AbstractLogger);
+    /**
+     * extracts RosenData from given lock transaction in Rpc format
+     * @param transaction the lock transaction in Rpc format
+     */
+    extractData: (transaction: HandshakeRpcTransaction) => RosenData | undefined;
+    /**
+     * extracts and builds token transformation from UTXO and tokenMap
+     * @param box transaction output
+     * @param toChain event target chain
+     */
+    getAssetTransformation: (box: HandshakeRpcTxOutput, toChain: string) => TokenTransformation | undefined;
+}
+//# sourceMappingURL=handshakeRpcRosenExtractor.d.ts.map

package/dist/getRosenData/handshake/handshakeRpcRosenExtractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handshakeRpcRosenExtractor.d.ts","sourceRoot":"","sources":["../../../lib/getRosenData/handshake/handshakeRpcRosenExtractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAGhD,OAAO,0BAA0B,MAAM,wCAAwC,CAAC;AAChF,OAAO,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAEnE,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EAErB,MAAM,SAAS,CAAC;AAOjB,qBAAa,0BAA2B,SAAQ,0BAA0B,CAAC,uBAAuB,CAAC;IACjG,QAAQ,CAAC,KAAK,eAAmB;IACjC,SAAS,CAAC,eAAe,EAAE,MAAM,CAAC;gBAEtB,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,cAAc;IAK1E;;;OAGG;IACH,WAAW,GACT,aAAa,uBAAuB,KACnC,SAAS,GAAG,SAAS,CA0FtB;IAEF;;;;OAIG;IACH,sBAAsB,GACpB,KAAK,oBAAoB,EACzB,SAAS,MAAM,KACd,mBAAmB,GAAG,SAAS,CAgBhC;CACH"}

package/dist/getRosenData/handshake/handshakeRpcRosenExtractor.js

@@ -0,0 +1,106 @@
+import { parseRosenData } from '../../utils';
+import AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';
+import { HANDSHAKE_CHAIN, HANDSHAKE_NATIVE_TOKEN } from '../const';
+import { addressToHash, convertHnsToDollarydoos, extractDataFromOutputs, } from './utils';
+export class HandshakeRpcRosenExtractor extends AbstractRosenDataExtractor {
+    chain = HANDSHAKE_CHAIN;
+    lockAddressHash;
+    constructor(lockAddress, tokens, logger) {
+        super(lockAddress, tokens, logger);
+        this.lockAddressHash = addressToHash(lockAddress);
+    }
+    /**
+     * extracts RosenData from given lock transaction in Rpc format
+     * @param transaction the lock transaction in Rpc format
+     */
+    extractData = (transaction) => {
+        const baseError = `No rosen data found for tx [${transaction.txid}]`;
+        try {
+            const outputs = transaction.vout;
+            if (outputs.length < 2) {
+                this.logger.debug(baseError + `: Insufficient number of outputs`);
+                return undefined;
+            }
+            // Find lock output first (need to use original RPC output for value)
+            const lockOutputIndex = outputs.findIndex((output) => output.address?.hash === this.lockAddressHash);
+            if (lockOutputIndex === -1) {
+                this.logger.debug(baseError + `: Lock output not found`);
+                return undefined;
+            }
+            const lockOutputRpc = outputs[lockOutputIndex];
+            // Convert RPC outputs to standard format (HNS to dollarydoos)
+            const convertedOutputs = outputs.map((output) => {
+                const dollarydoos = convertHnsToDollarydoos(output.value);
+                return {
+                    value: BigInt(dollarydoos),
+                    address: output.address,
+                };
+            });
+            // Extract data from outputs using utility function
+            const reconstructedData = extractDataFromOutputs(convertedOutputs, lockOutputIndex);
+            if (!reconstructedData) {
+                this.logger.debug(baseError + `: No data chunks found`);
+                return undefined;
+            }
+            // Parse the reconstructed data
+            let rosenData;
+            try {
+                rosenData = parseRosenData(reconstructedData);
+                this.logger.debug(`Successfully extracted Rosen data for [${rosenData.toChain}]`);
+            }
+            catch (e) {
+                this.logger.debug(baseError + `: Failed to parse extracted data: ${e}`);
+                return undefined;
+            }
+            // Find asset transformation using the lock output
+            const assetTransformation = this.getAssetTransformation(lockOutputRpc, rosenData.toChain);
+            if (!assetTransformation) {
+                this.logger.debug(baseError + `: Failed to find rosen asset transformation`);
+                return undefined;
+            }
+            const fromAddress = `box:${transaction.vin[0].txid}.${transaction.vin[0].vout}`;
+            return {
+                toChain: rosenData.toChain,
+                toAddress: rosenData.toAddress,
+                bridgeFee: rosenData.bridgeFee,
+                networkFee: rosenData.networkFee,
+                fromAddress: fromAddress,
+                sourceChainTokenId: assetTransformation.from,
+                amount: assetTransformation.amount,
+                targetChainTokenId: assetTransformation.to,
+                sourceTxId: transaction.txid,
+                rawData: outputs
+                    .map((output) => `${output.address?.hash}:${output.value}`)
+                    .join(','),
+            };
+        }
+        catch (e) {
+            this.logger.debug(`An error occurred while getting Handshake rosen data from Rpc: ${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) => {
+        const wrappedHns = this.tokens.search(HANDSHAKE_CHAIN, {
+            tokenId: HANDSHAKE_NATIVE_TOKEN,
+        });
+        if (wrappedHns.length > 0 && Object.hasOwn(wrappedHns[0], toChain)) {
+            // Convert HNS to dollarydoos
+            const dollarydoos = convertHnsToDollarydoos(box.value);
+            return {
+                from: HANDSHAKE_NATIVE_TOKEN,
+                to: this.tokens.getID(wrappedHns[0], toChain),
+                amount: dollarydoos,
+            };
+        }
+        return undefined;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"handshakeRpcRosenExtractor.js","sourceRoot":"","sources":["../../../lib/getRosenData/handshake/handshakeRpcRosenExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractLogger } from '@rosen-bridge/abstract-logger';\nimport { TokenMap } from '@rosen-bridge/tokens';\n\nimport { parseRosenData } from '../../utils';\nimport AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';\nimport { RosenData, TokenTransformation } from '../abstract/types';\nimport { HANDSHAKE_CHAIN, HANDSHAKE_NATIVE_TOKEN } from '../const';\nimport {\n  HandshakeRpcTransaction,\n  HandshakeRpcTxOutput,\n  HandshakeRosenData,\n} from './types';\nimport {\n  addressToHash,\n  convertHnsToDollarydoos,\n  extractDataFromOutputs,\n} from './utils';\n\nexport class HandshakeRpcRosenExtractor extends AbstractRosenDataExtractor<HandshakeRpcTransaction> {\n  readonly chain = HANDSHAKE_CHAIN;\n  protected lockAddressHash: string;\n\n  constructor(lockAddress: string, tokens: TokenMap, logger?: AbstractLogger) {\n    super(lockAddress, tokens, logger);\n    this.lockAddressHash = addressToHash(lockAddress);\n  }\n\n  /**\n   * extracts RosenData from given lock transaction in Rpc format\n   * @param transaction the lock transaction in Rpc format\n   */\n  extractData = (\n    transaction: HandshakeRpcTransaction,\n  ): RosenData | undefined => {\n    const baseError = `No rosen data found for tx [${transaction.txid}]`;\n    try {\n      const outputs = transaction.vout;\n      if (outputs.length < 2) {\n        this.logger.debug(baseError + `: Insufficient number of outputs`);\n        return undefined;\n      }\n\n      // Find lock output first (need to use original RPC output for value)\n      const lockOutputIndex = outputs.findIndex(\n        (output) => output.address?.hash === this.lockAddressHash,\n      );\n\n      if (lockOutputIndex === -1) {\n        this.logger.debug(baseError + `: Lock output not found`);\n        return undefined;\n      }\n\n      const lockOutputRpc = outputs[lockOutputIndex];\n\n      // Convert RPC outputs to standard format (HNS to dollarydoos)\n      const convertedOutputs = outputs.map((output) => {\n        const dollarydoos = convertHnsToDollarydoos(output.value);\n        return {\n          value: BigInt(dollarydoos),\n          address: output.address,\n        };\n      });\n\n      // Extract data from outputs using utility function\n      const reconstructedData = extractDataFromOutputs(\n        convertedOutputs,\n        lockOutputIndex,\n      );\n\n      if (!reconstructedData) {\n        this.logger.debug(baseError + `: No data chunks found`);\n        return undefined;\n      }\n\n      // Parse the reconstructed data\n      let rosenData: HandshakeRosenData | undefined;\n      try {\n        rosenData = parseRosenData(reconstructedData);\n        this.logger.debug(\n          `Successfully extracted Rosen data for [${rosenData.toChain}]`,\n        );\n      } catch (e) {\n        this.logger.debug(baseError + `: Failed to parse extracted data: ${e}`);\n        return undefined;\n      }\n\n      // Find asset transformation using the lock output\n      const assetTransformation = this.getAssetTransformation(\n        lockOutputRpc,\n        rosenData.toChain,\n      );\n\n      if (!assetTransformation) {\n        this.logger.debug(\n          baseError + `: Failed to find rosen asset transformation`,\n        );\n        return undefined;\n      }\n\n      const fromAddress = `box:${transaction.vin[0].txid}.${transaction.vin[0].vout}`;\n      return {\n        toChain: rosenData.toChain,\n        toAddress: rosenData.toAddress,\n        bridgeFee: rosenData.bridgeFee,\n        networkFee: rosenData.networkFee,\n        fromAddress: fromAddress,\n        sourceChainTokenId: assetTransformation.from,\n        amount: assetTransformation.amount,\n        targetChainTokenId: assetTransformation.to,\n        sourceTxId: transaction.txid,\n        rawData: outputs\n          .map((output) => `${output.address?.hash}:${output.value}`)\n          .join(','),\n      };\n    } catch (e) {\n      this.logger.debug(\n        `An error occurred while getting Handshake 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 and builds token transformation from UTXO and tokenMap\n   * @param box transaction output\n   * @param toChain event target chain\n   */\n  getAssetTransformation = (\n    box: HandshakeRpcTxOutput,\n    toChain: string,\n  ): TokenTransformation | undefined => {\n    const wrappedHns = this.tokens.search(HANDSHAKE_CHAIN, {\n      tokenId: HANDSHAKE_NATIVE_TOKEN,\n    });\n\n    if (wrappedHns.length > 0 && Object.hasOwn(wrappedHns[0], toChain)) {\n      // Convert HNS to dollarydoos\n      const dollarydoos = convertHnsToDollarydoos(box.value);\n\n      return {\n        from: HANDSHAKE_NATIVE_TOKEN,\n        to: this.tokens.getID(wrappedHns[0], toChain),\n        amount: dollarydoos,\n      };\n    }\n    return undefined;\n  };\n}\n"]}

package/dist/getRosenData/handshake/types.d.ts

@@ -0,0 +1,71 @@
+export interface HandshakeRosenData {
+    toChain: string;
+    toAddress: string;
+    bridgeFee: string;
+    networkFee: string;
+}
+export interface HandshakeRpcTxInput {
+    txid: string;
+    vout: number;
+    txinwitness: Array<string>;
+    sequence: number;
+}
+export interface HandshakeRpcTxOutput {
+    value: number;
+    n: number;
+    address: {
+        version: number;
+        hash: string;
+        string: string;
+    };
+    covenant: {
+        type: number;
+        action: string;
+        items: string[];
+    };
+}
+export interface HandshakeRpcTransaction {
+    txid: string;
+    version: number;
+    size: number;
+    vsize: number;
+    locktime: number;
+    vin: Array<{
+        txid: string;
+        vout: number;
+        txinwitness?: string[];
+        sequence: number;
+    }>;
+    vout: Array<HandshakeRpcTxOutput>;
+    hash: string;
+}
+export interface HandshakeTxInput {
+    txId: string;
+    index: number;
+}
+export interface HandshakeTxOutput {
+    value: bigint;
+    address: {
+        version: number;
+        hash: string;
+        string: string;
+    };
+    covenant: {
+        type: number;
+        action: string;
+        items: string[];
+    };
+}
+export interface DataExtractionOutput {
+    value: bigint;
+    address?: {
+        hash: string;
+        version?: number;
+    };
+}
+export interface HandshakeTx {
+    id: string;
+    inputs: HandshakeTxInput[];
+    outputs: HandshakeTxOutput[];
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../lib/getRosenData/handshake/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,EAAE;QACP,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,EAAE,CAAC;KACjB,CAAC;CACH;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,KAAK,CAAC;QACT,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;QACvB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC,CAAC;IACH,IAAI,EAAE,KAAK,CAAC,oBAAoB,CAAC,CAAC;IAClC,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE;QACP,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,EAAE,CAAC;KACjB,CAAC;CACH;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9C;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,OAAO,EAAE,iBAAiB,EAAE,CAAC;CAC9B"}

package/dist/getRosenData/handshake/types.js

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

package/dist/getRosenData/handshake/utils.d.ts

@@ -0,0 +1,23 @@
+import { DataExtractionOutput } from './types';
+/**
+ * Extracts the hash from a Handshake address using bitcoinjs-lib
+ * @param addr The Handshake address to convert
+ * @returns The address hash as a hex string
+ */
+export declare const addressToHash: (addr: string) => string;
+/**
+ * Extracts data chunks from transaction outputs using value-based ordering
+ * Data is encoded in P2WPKH address hashes (version 0, values 1000+)
+ * @param outputs - array of outputs with value, address.hash, address.version
+ * @param lockAddressIndex - index of the lock address output
+ * @returns reconstructedData as string or undefined
+ */
+export declare const extractDataFromOutputs: (outputs: DataExtractionOutput[], lockAddressIndex: number) => string | undefined;
+/**
+ * Converts HNS value to dollarydoos (satoshi-equivalent) using string-based arithmetic
+ * This avoids floating-point precision errors when converting from HNS decimal format
+ * @param value The HNS value as a number (e.g., 0.001, 1.5)
+ * @returns The value in dollarydoos as a string (e.g., "1000", "1500000")
+ */
+export declare const convertHnsToDollarydoos: (value: number) => string;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../lib/getRosenData/handshake/utils.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,KAAG,MAQ5C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,GACjC,SAAS,oBAAoB,EAAE,EAC/B,kBAAkB,MAAM,KACvB,MAAM,GAAG,SA2CX,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,GAAI,OAAO,MAAM,KAAG,MAIvD,CAAC"}

package/dist/getRosenData/handshake/utils.js

@@ -0,0 +1,67 @@
+import * as bitcoinLib from 'bitcoinjs-lib';
+import { HANDSHAKE_NETWORK, MIN_UTXO_VALUE } from './constants';
+/**
+ * Extracts the hash from a Handshake address using bitcoinjs-lib
+ * @param addr The Handshake address to convert
+ * @returns The address hash as a hex string
+ */
+export const addressToHash = (addr) => {
+    const outputScript = bitcoinLib.address.toOutputScript(addr, HANDSHAKE_NETWORK);
+    // Output script format for witness v0: OP_0 <length> <hash>
+    // We want just the hash part (skip first 2 bytes: OP_0 and length)
+    return outputScript.subarray(2).toString('hex');
+};
+/**
+ * Extracts data chunks from transaction outputs using value-based ordering
+ * Data is encoded in P2WPKH address hashes (version 0, values 1000+)
+ * @param outputs - array of outputs with value, address.hash, address.version
+ * @param lockAddressIndex - index of the lock address output
+ * @returns reconstructedData as string or undefined
+ */
+export const extractDataFromOutputs = (outputs, lockAddressIndex) => {
+    const extractedChunks = [];
+    // Extract data chunks step by step
+    // Search outputs before lock address (data chunks come before lock output)
+    for (let chunkIndex = 0; chunkIndex < 4; chunkIndex++) {
+        for (let outputIndex = 0; outputIndex < lockAddressIndex; outputIndex++) {
+            const output = outputs[outputIndex];
+            if (!output.address || !output.address.hash)
+                continue;
+            const value = output.value;
+            const addrHash = output.address.hash;
+            const version = typeof output.address.version === 'bigint'
+                ? Number(output.address.version)
+                : output.address.version;
+            // Check if this output matches the expected chunk
+            if (value === BigInt(MIN_UTXO_VALUE) + BigInt(chunkIndex) &&
+                version === 0 &&
+                addrHash.length === 40) {
+                extractedChunks.push({
+                    index: chunkIndex,
+                    data: addrHash,
+                });
+                break; // Move to next chunk
+            }
+        }
+    }
+    // Reconstruct data by sorting chunks by index
+    const reconstructedData = extractedChunks.length > 0
+        ? extractedChunks
+            .sort((a, b) => a.index - b.index)
+            .map((chunk) => chunk.data)
+            .join('')
+        : undefined;
+    return reconstructedData;
+};
+/**
+ * Converts HNS value to dollarydoos (satoshi-equivalent) using string-based arithmetic
+ * This avoids floating-point precision errors when converting from HNS decimal format
+ * @param value The HNS value as a number (e.g., 0.001, 1.5)
+ * @returns The value in dollarydoos as a string (e.g., "1000", "1500000")
+ */
+export const convertHnsToDollarydoos = (value) => {
+    const parts = value.toString().split('.');
+    const part1 = ((parts[1] ?? '') + '0'.repeat(6)).substring(0, 6);
+    return (parts[0] === '0' ? '' : parts[0]) + part1;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/index.d.ts

@@ -21,5 +21,7 @@ export { FiroRpcRosenExtractor } from './getRosenData/firo/firoRpcRosenExtractor
 export { BitcoinRunesEsploraRosenExtractor } from './getRosenData/bitcoin-runes/bitcoinRunesEsploraRosenExtractor';
 export { BitcoinRunesRosenExtractor } from './getRosenData/bitcoin-runes/bitcoinRunesRosenExtractor';
 export { BitcoinRunesRpcRosenExtractor } from './getRosenData/bitcoin-runes/bitcoinRunesRpcRosenExtractor';
+export { HandshakeRosenExtractor } from './getRosenData/handshake/handshakeRosenExtractor';
+export { HandshakeRpcRosenExtractor } from './getRosenData/handshake/handshakeRpcRosenExtractor';
 export { parseRosenData } from './utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -1,5 +1,5 @@
-import { initEccLib } from 'bitcoinjs-lib';
 import ecc from '@bitcoinerlab/secp256k1';
+import { initEccLib } from 'bitcoinjs-lib';
 initEccLib(ecc);
 export { default as AbstractRosenDataExtractor } from './getRosenData/abstract/abstractRosenDataExtractor';
 export { BitcoinEsploraRosenExtractor } from './getRosenData/bitcoin/bitcoinEsploraRosenExtractor';
@@ -23,5 +23,7 @@ export { FiroRpcRosenExtractor } from './getRosenData/firo/firoRpcRosenExtractor
 export { BitcoinRunesEsploraRosenExtractor } from './getRosenData/bitcoin-runes/bitcoinRunesEsploraRosenExtractor';
 export { BitcoinRunesRosenExtractor } from './getRosenData/bitcoin-runes/bitcoinRunesRosenExtractor';
 export { BitcoinRunesRpcRosenExtractor } from './getRosenData/bitcoin-runes/bitcoinRunesRpcRosenExtractor';
+export { HandshakeRosenExtractor } from './getRosenData/handshake/handshakeRosenExtractor';
+export { HandshakeRpcRosenExtractor } from './getRosenData/handshake/handshakeRpcRosenExtractor';
 export { parseRosenData } from './utils';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxHQUFHLE1BQU0seUJBQXlCLENBQUM7QUFDMUMsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUzQyxVQUFVLENBQUMsR0FBRyxDQUFDLENBQUM7QUFFaEIsT0FBTyxFQUFFLE9BQU8sSUFBSSwwQkFBMEIsRUFBRSxNQUFNLG9EQUFvRCxDQUFDO0FBQzNHLE9BQU8sRUFBRSw0QkFBNEIsRUFBRSxNQUFNLHFEQUFxRCxDQUFDO0FBQ25HLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDhDQUE4QyxDQUFDO0FBQ3JGLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLGlEQUFpRCxDQUFDO0FBQzNGLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLDRDQUE0QyxDQUFDO0FBQ3JGLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHlDQUF5QyxDQUFDO0FBQy9FLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBQ3pFLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLG1EQUFtRCxDQUFDO0FBQy9GLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLG9EQUFvRCxDQUFDO0FBQ2pHLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQ2xFLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDhDQUE4QyxDQUFDO0FBQ3JGLE9BQU8sRUFBRSwrQkFBK0IsRUFBRSxNQUFNLHdEQUF3RCxDQUFDO0FBQ3pHLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHdDQUF3QyxDQUFDO0FBQzVFLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLDRDQUE0QyxDQUFDO0FBRXBGLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLCtDQUErQyxDQUFDO0FBQzFGLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHdDQUF3QyxDQUFDO0FBQzVFLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDJDQUEyQyxDQUFDO0FBQ2xGLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHdDQUF3QyxDQUFDO0FBQzVFLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDJDQUEyQyxDQUFDO0FBQ2xGLE9BQU8sRUFBRSxpQ0FBaUMsRUFBRSxNQUFNLGdFQUFnRSxDQUFDO0FBQ25ILE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLHlEQUF5RCxDQUFDO0FBQ3JHLE9BQU8sRUFBRSw2QkFBNkIsRUFBRSxNQUFNLDREQUE0RCxDQUFDO0FBQzNHLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLGtEQUFrRCxDQUFDO0FBQzNGLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLHFEQUFxRCxDQUFDO0FBQ2pHLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgZWNjIGZyb20gJ0BiaXRjb2luZXJsYWIvc2VjcDI1NmsxJztcbmltcG9ydCB7IGluaXRFY2NMaWIgfSBmcm9tICdiaXRjb2luanMtbGliJztcblxuaW5pdEVjY0xpYihlY2MpO1xuXG5leHBvcnQgeyBkZWZhdWx0IGFzIEFic3RyYWN0Um9zZW5EYXRhRXh0cmFjdG9yIH0gZnJvbSAnLi9nZXRSb3NlbkRhdGEvYWJzdHJhY3QvYWJzdHJhY3RSb3NlbkRhdGFFeHRyYWN0b3InO1xuZXhwb3J0IHsgQml0Y29pbkVzcGxvcmFSb3NlbkV4dHJhY3RvciB9IGZyb20gJy4vZ2V0Um9zZW5EYXRhL2JpdGNvaW4vYml0Y29pbkVzcGxvcmFSb3NlbkV4dHJhY3Rvcic7XG5leHBvcnQgeyBCaXRjb2luUm9zZW5FeHRyYWN0b3IgfSBmcm9tICcuL2dldFJvc2VuRGF0YS9iaXRjb2luL2JpdGNvaW5Sb3NlbkV4dHJhY3Rvcic7XG5leHBvcnQgeyBCaXRjb2luUnBjUm9zZW5FeHRyYWN0b3IgfSBmcm9tICcuL2dldFJvc2VuRGF0YS9iaXRjb2luL2JpdGNvaW5ScGNSb3NlbkV4dHJhY3Rvcic7XG5leHBvcnQgeyBFdm1FdGhlcnNSb3NlbkV4dHJhY3RvciB9IGZyb20gJy4vZ2V0Um9zZW5EYXRhL2V2bS9ldm1FdGhlcnNSb3NlbkV4dHJhY3Rvcic7XG5leHBvcnQgeyBFdm1ScGNSb3NlbkV4dHJhY3RvciB9IGZyb20gJy4vZ2V0Um9zZW5EYXRhL2V2bS9ldm1ScGNSb3NlbkV4dHJhY3Rvcic7XG5leHBvcnQgeyBFdm1Sb3NlbkV4dHJhY3RvciB9IGZyb20gJy4vZ2V0Um9zZW5EYXRhL2V2bS9ldm1Sb3NlbkV4dHJhY3Rvcic7XG5leHBvcnQgeyBDYXJkYW5vS29pb3NSb3NlbkV4dHJhY3RvciB9IGZyb20gJy4vZ2V0Um9zZW5EYXRhL2NhcmRhbm8vY2FyZGFub0tvaW9zUm9zZW5FeHRyYWN0b3InO1xuZXhwb3J0IHsgQ2FyZGFub09nbWlvc1Jvc2VuRXh0cmFjdG9yIH0gZnJvbSAnLi9nZXRSb3NlbkRhdGEvY2FyZGFuby9jYXJkYW5vT2dtaW9zUm9zZW5FeHRyYWN0b3InO1xuZXhwb3J0IHsgT21naW9zTm9DYm9yRXJyb3IgfSBmcm9tICcuL2dldFJvc2VuRGF0YS9jYXJkYW5vL2Vycm9ycyc7XG5leHBvcnQgeyBDYXJkYW5vUm9zZW5FeHRyYWN0b3IgfSBmcm9tICcuL2dldFJvc2VuRGF0YS9jYXJkYW5vL2NhcmRhbm9Sb3NlbkV4dHJhY3Rvcic7XG5leHBvcnQgeyBDYXJkYW5vQmxvY2tGcm9zdFJvc2VuRXh0cmFjdG9yIH0gZnJvbSAnLi9nZXRSb3NlbkRhdGEvY2FyZGFuby9jYXJkYW5vQmxvY2tGcm9zdFJvc2VuRXh0cmFjdG9yJztcbmV4cG9ydCB7IEVyZ29Sb3NlbkV4dHJhY3RvciB9IGZyb20gJy4vZ2V0Um9zZW5EYXRhL2VyZ28vZXJnb1Jvc2VuRXh0cmFjdG9yJztcbmV4cG9ydCB7IEVyZ29Ob2RlUm9zZW5FeHRyYWN0b3IgfSBmcm9tICcuL2dldFJvc2VuRGF0YS9lcmdvL2VyZ29Ob2RlUm9zZW5FeHRyYWN0b3InO1xuZXhwb3J0IHsgUm9zZW5EYXRhLCBUb2tlblRyYW5zZm9ybWF0aW9uIH0gZnJvbSAnLi9nZXRSb3NlbkRhdGEvYWJzdHJhY3QvdHlwZXMnO1xuZXhwb3J0IHsgRG9nZUVzcGxvcmFSb3NlbkV4dHJhY3RvciB9IGZyb20gJy4vZ2V0Um9zZW5EYXRhL2RvZ2UvZG9nZUVzcGxvcmFSb3NlbkV4dHJhY3Rvcic7XG5leHBvcnQgeyBEb2dlUm9zZW5FeHRyYWN0b3IgfSBmcm9tICcuL2dldFJvc2VuRGF0YS9kb2dlL2RvZ2VSb3NlbkV4dHJhY3Rvcic7XG5leHBvcnQgeyBEb2dlUnBjUm9zZW5FeHRyYWN0b3IgfSBmcm9tICcuL2dldFJvc2VuRGF0YS9kb2dlL2RvZ2VScGNSb3NlbkV4dHJhY3Rvcic7XG5leHBvcnQgeyBGaXJvUm9zZW5FeHRyYWN0b3IgfSBmcm9tICcuL2dldFJvc2VuRGF0YS9maXJvL2Zpcm9Sb3NlbkV4dHJhY3Rvcic7XG5leHBvcnQgeyBGaXJvUnBjUm9zZW5FeHRyYWN0b3IgfSBmcm9tICcuL2dldFJvc2VuRGF0YS9maXJvL2Zpcm9ScGNSb3NlbkV4dHJhY3Rvcic7XG5leHBvcnQgeyBCaXRjb2luUnVuZXNFc3Bsb3JhUm9zZW5FeHRyYWN0b3IgfSBmcm9tICcuL2dldFJvc2VuRGF0YS9iaXRjb2luLXJ1bmVzL2JpdGNvaW5SdW5lc0VzcGxvcmFSb3NlbkV4dHJhY3Rvcic7XG5leHBvcnQgeyBCaXRjb2luUnVuZXNSb3NlbkV4dHJhY3RvciB9IGZyb20gJy4vZ2V0Um9zZW5EYXRhL2JpdGNvaW4tcnVuZXMvYml0Y29pblJ1bmVzUm9zZW5FeHRyYWN0b3InO1xuZXhwb3J0IHsgQml0Y29pblJ1bmVzUnBjUm9zZW5FeHRyYWN0b3IgfSBmcm9tICcuL2dldFJvc2VuRGF0YS9iaXRjb2luLXJ1bmVzL2JpdGNvaW5SdW5lc1JwY1Jvc2VuRXh0cmFjdG9yJztcbmV4cG9ydCB7IEhhbmRzaGFrZVJvc2VuRXh0cmFjdG9yIH0gZnJvbSAnLi9nZXRSb3NlbkRhdGEvaGFuZHNoYWtlL2hhbmRzaGFrZVJvc2VuRXh0cmFjdG9yJztcbmV4cG9ydCB7IEhhbmRzaGFrZVJwY1Jvc2VuRXh0cmFjdG9yIH0gZnJvbSAnLi9nZXRSb3NlbkRhdGEvaGFuZHNoYWtlL2hhbmRzaGFrZVJwY1Jvc2VuRXh0cmFjdG9yJztcbmV4cG9ydCB7IHBhcnNlUm9zZW5EYXRhIH0gZnJvbSAnLi91dGlscyc7XG4iXX0=