@rosen-bridge/rosen-extractor 11.2.1 → 11.3.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @rosen-bridge/rosen-extractor
 
+## 11.3.0
+
+### Minor Changes
+
+- Add Handshake chain rosen-extractor
+
+### Patch Changes
+
+- Update dependencies
+  - @rosen-bridge/address-codec@1.2.0
+
+## 11.2.2
+
+### Patch Changes
+
+- Update dependencies
+  - @rosen-bridge/tokens@6.0.0
+
 ## 11.2.1
 
 ### Patch Changes

package/dist/getRosenData/const.d.ts

@@ -9,6 +9,8 @@ export declare const ERGO_CHAIN = "ergo";
 export declare const DOGE_CHAIN = "doge";
 export declare const DOGE_NATIVE_TOKEN = "doge";
 export declare const BITCOIN_RUNES_CHAIN = "bitcoin-runes";
+export declare const HANDSHAKE_CHAIN = "handshake";
+export declare const HANDSHAKE_NATIVE_TOKEN = "hns";
 export declare const FIRO_CHAIN = "firo";
 export declare const FIRO_NATIVE_TOKEN = "firo";
 export declare const SUPPORTED_CHAINS: string[];

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

@@ -1 +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,UAAU,SAAS,CAAC;AACjC,eAAO,MAAM,iBAAiB,SAAS,CAAC;AACxC,eAAO,MAAM,gBAAgB,UAS5B,CAAC"}
+{"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,eAAe,cAAc,CAAC;AAC3C,eAAO,MAAM,sBAAsB,QAAQ,CAAC;AAC5C,eAAO,MAAM,UAAU,SAAS,CAAC;AACjC,eAAO,MAAM,iBAAiB,SAAS,CAAC;AACxC,eAAO,MAAM,gBAAgB,UAU5B,CAAC"}

package/dist/getRosenData/const.js

@@ -9,6 +9,8 @@ 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 HANDSHAKE_CHAIN = 'handshake';
+export const HANDSHAKE_NATIVE_TOKEN = 'hns';
 export const FIRO_CHAIN = 'firo';
 export const FIRO_NATIVE_TOKEN = 'firo';
 export const SUPPORTED_CHAINS = [
@@ -19,6 +21,7 @@ export const SUPPORTED_CHAINS = [
     BINANCE_CHAIN,
     DOGE_CHAIN,
     BITCOIN_RUNES_CHAIN,
+    HANDSHAKE_CHAIN,
     FIRO_CHAIN,
 ];
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,13 @@
+export declare const HANDSHAKE_NETWORK: {
+    messagePrefix: string;
+    bech32: string;
+    bip32: {
+        public: number;
+        private: number;
+    };
+    pubKeyHash: number;
+    scriptHash: number;
+    wif: number;
+};
+export declare const MIN_UTXO_VALUE = 1000;
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../lib/getRosenData/handshake/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB;;;;;;;;;;CAU7B,CAAC;AAEF,eAAO,MAAM,cAAc,OAAO,CAAC"}

package/dist/getRosenData/handshake/constants.js

@@ -0,0 +1,13 @@
+export const HANDSHAKE_NETWORK = {
+    messagePrefix: '\x18Handshake Signed Message:\n',
+    bech32: 'hs',
+    bip32: {
+        public: 0x0488b21e,
+        private: 0x0488ade4,
+    },
+    pubKeyHash: -1,
+    scriptHash: -1,
+    wif: -1,
+};
+export const MIN_UTXO_VALUE = 1000;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vbGliL2dldFJvc2VuRGF0YS9oYW5kc2hha2UvY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUFHO0lBQy9CLGFBQWEsRUFBRSxpQ0FBaUM7SUFDaEQsTUFBTSxFQUFFLElBQUk7SUFDWixLQUFLLEVBQUU7UUFDTCxNQUFNLEVBQUUsVUFBVTtRQUNsQixPQUFPLEVBQUUsVUFBVTtLQUNwQjtJQUNELFVBQVUsRUFBRSxDQUFDLENBQUM7SUFDZCxVQUFVLEVBQUUsQ0FBQyxDQUFDO0lBQ2QsR0FBRyxFQUFFLENBQUMsQ0FBQztDQUNSLENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUcsSUFBSSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IEhBTkRTSEFLRV9ORVRXT1JLID0ge1xuICBtZXNzYWdlUHJlZml4OiAnXFx4MThIYW5kc2hha2UgU2lnbmVkIE1lc3NhZ2U6XFxuJyxcbiAgYmVjaDMyOiAnaHMnLFxuICBiaXAzMjoge1xuICAgIHB1YmxpYzogMHgwNDg4YjIxZSxcbiAgICBwcml2YXRlOiAweDA0ODhhZGU0LFxuICB9LFxuICBwdWJLZXlIYXNoOiAtMSxcbiAgc2NyaXB0SGFzaDogLTEsXG4gIHdpZjogLTEsXG59O1xuXG5leHBvcnQgY29uc3QgTUlOX1VUWE9fVkFMVUUgPSAxMDAwO1xuIl19

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"handshakeRosenExtractor.d.ts","sourceRoot":"","sources":["../../../lib/getRosenData/handshake/handshakeRosenExtractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,0BAA0B,MAAM,wCAAwC,CAAC;AAEhF,OAAO,EAAe,iBAAiB,EAAsB,MAAM,SAAS,CAAC;AAC7E,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAK/D,qBAAa,uBAAwB,SAAQ,0BAA0B,CAAC,MAAM,CAAC;IAC7E,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,GAAI,uBAAuB,MAAM,KAAG,SAAS,GAAG,SAAS,CA4FlE;IAEF;;;;OAIG;IACH,sBAAsB,GACpB,KAAK,iBAAiB,EACtB,SAAS,MAAM,KACd,mBAAmB,GAAG,SAAS,CAahC;CACH"}

package/dist/getRosenData/handshake/handshakeRosenExtractor.js

@@ -0,0 +1,104 @@
+import AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';
+import { HANDSHAKE_CHAIN, HANDSHAKE_NATIVE_TOKEN } from '../const';
+import { addressToHash, extractDataFromOutputs } from './utils';
+import { parseRosenData } from '../../utils';
+import JsonBigInt from '@rosen-bridge/json-bigint';
+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 { RosenData, TokenTransformation } from '../abstract/types';\nimport AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';\nimport { HANDSHAKE_CHAIN, HANDSHAKE_NATIVE_TOKEN } from '../const';\nimport { HandshakeTx, HandshakeTxOutput, HandshakeRosenData } from './types';\nimport { TokenMap } from '@rosen-bridge/tokens';\nimport { AbstractLogger } from '@rosen-bridge/abstract-logger';\nimport { addressToHash, extractDataFromOutputs } from './utils';\nimport { parseRosenData } from '../../utils';\nimport JsonBigInt from '@rosen-bridge/json-bigint';\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 { RosenData, TokenTransformation } from '../abstract/types';
+import AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';
+import { HandshakeRpcTransaction, HandshakeRpcTxOutput } from './types';
+import { TokenMap } from '@rosen-bridge/tokens';
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+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,SAAS,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,0BAA0B,MAAM,wCAAwC,CAAC;AAEhF,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EAErB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAQ/D,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 AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';
+import { HANDSHAKE_CHAIN, HANDSHAKE_NATIVE_TOKEN } from '../const';
+import { addressToHash, convertHnsToDollarydoos, extractDataFromOutputs, } from './utils';
+import { parseRosenData } 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":"AACA,OAAO,0BAA0B,MAAM,wCAAwC,CAAC;AAChF,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAQnE,OAAO,EACL,aAAa,EACb,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C,MAAM,OAAO,0BAA2B,SAAQ,0BAAmD;IACxF,KAAK,GAAG,eAAe,CAAC;IACvB,eAAe,CAAS;IAElC,YAAY,WAAmB,EAAE,MAAgB,EAAE,MAAuB;QACxE,KAAK,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QACnC,IAAI,CAAC,eAAe,GAAG,aAAa,CAAC,WAAW,CAAC,CAAC;IACpD,CAAC;IAED;;;OAGG;IACH,WAAW,GAAG,CACZ,WAAoC,EACb,EAAE;QACzB,MAAM,SAAS,GAAG,+BAA+B,WAAW,CAAC,IAAI,GAAG,CAAC;QACrE,IAAI,CAAC;YACH,MAAM,OAAO,GAAG,WAAW,CAAC,IAAI,CAAC;YACjC,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACvB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,GAAG,kCAAkC,CAAC,CAAC;gBAClE,OAAO,SAAS,CAAC;YACnB,CAAC;YAED,qEAAqE;YACrE,MAAM,eAAe,GAAG,OAAO,CAAC,SAAS,CACvC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,KAAK,IAAI,CAAC,eAAe,CAC1D,CAAC;YAEF,IAAI,eAAe,KAAK,CAAC,CAAC,EAAE,CAAC;gBAC3B,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,GAAG,yBAAyB,CAAC,CAAC;gBACzD,OAAO,SAAS,CAAC;YACnB,CAAC;YAED,MAAM,aAAa,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;YAE/C,8DAA8D;YAC9D,MAAM,gBAAgB,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE;gBAC9C,MAAM,WAAW,GAAG,uBAAuB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBAC1D,OAAO;oBACL,KAAK,EAAE,MAAM,CAAC,WAAW,CAAC;oBAC1B,OAAO,EAAE,MAAM,CAAC,OAAO;iBACxB,CAAC;YACJ,CAAC,CAAC,CAAC;YAEH,mDAAmD;YACnD,MAAM,iBAAiB,GAAG,sBAAsB,CAC9C,gBAAgB,EAChB,eAAe,CAChB,CAAC;YAEF,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBACvB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,GAAG,wBAAwB,CAAC,CAAC;gBACxD,OAAO,SAAS,CAAC;YACnB,CAAC;YAED,+BAA+B;YAC/B,IAAI,SAAyC,CAAC;YAC9C,IAAI,CAAC;gBACH,SAAS,GAAG,cAAc,CAAC,iBAAiB,CAAC,CAAC;gBAC9C,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,0CAA0C,SAAS,CAAC,OAAO,GAAG,CAC/D,CAAC;YACJ,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,GAAG,qCAAqC,CAAC,EAAE,CAAC,CAAC;gBACxE,OAAO,SAAS,CAAC;YACnB,CAAC;YAED,kDAAkD;YAClD,MAAM,mBAAmB,GAAG,IAAI,CAAC,sBAAsB,CACrD,aAAa,EACb,SAAS,CAAC,OAAO,CAClB,CAAC;YAEF,IAAI,CAAC,mBAAmB,EAAE,CAAC;gBACzB,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,SAAS,GAAG,6CAA6C,CAC1D,CAAC;gBACF,OAAO,SAAS,CAAC;YACnB,CAAC;YAED,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;YAChF,OAAO;gBACL,OAAO,EAAE,SAAS,CAAC,OAAO;gBAC1B,SAAS,EAAE,SAAS,CAAC,SAAS;gBAC9B,SAAS,EAAE,SAAS,CAAC,SAAS;gBAC9B,UAAU,EAAE,SAAS,CAAC,UAAU;gBAChC,WAAW,EAAE,WAAW;gBACxB,kBAAkB,EAAE,mBAAmB,CAAC,IAAI;gBAC5C,MAAM,EAAE,mBAAmB,CAAC,MAAM;gBAClC,kBAAkB,EAAE,mBAAmB,CAAC,EAAE;gBAC1C,UAAU,EAAE,WAAW,CAAC,IAAI;gBAC5B,OAAO,EAAE,OAAO;qBACb,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,GAAG,MAAM,CAAC,OAAO,EAAE,IAAI,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;qBAC1D,IAAI,CAAC,GAAG,CAAC;aACb,CAAC;QACJ,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,kEAAkE,CAAC,EAAE,CACtE,CAAC;YACF,IAAI,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC;gBAClC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;YAC7B,CAAC;QACH,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC;IAEF;;;;OAIG;IACH,sBAAsB,GAAG,CACvB,GAAyB,EACzB,OAAe,EACkB,EAAE;QACnC,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE;YACrD,OAAO,EAAE,sBAAsB;SAChC,CAAC,CAAC;QAEH,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,CAAC;YACnE,6BAA6B;YAC7B,MAAM,WAAW,GAAG,uBAAuB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YAEvD,OAAO;gBACL,IAAI,EAAE,sBAAsB;gBAC5B,EAAE,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC;gBAC7C,MAAM,EAAE,WAAW;aACpB,CAAC;QACJ,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC;CACH","sourcesContent":["import { RosenData, TokenTransformation } from '../abstract/types';\nimport AbstractRosenDataExtractor from '../abstract/abstractRosenDataExtractor';\nimport { HANDSHAKE_CHAIN, HANDSHAKE_NATIVE_TOKEN } from '../const';\nimport {\n  HandshakeRpcTransaction,\n  HandshakeRpcTxOutput,\n  HandshakeRosenData,\n} from './types';\nimport { TokenMap } from '@rosen-bridge/tokens';\nimport { AbstractLogger } from '@rosen-bridge/abstract-logger';\nimport {\n  addressToHash,\n  convertHnsToDollarydoos,\n  extractDataFromOutputs,\n} from './utils';\nimport { parseRosenData } 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":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAG/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 { HANDSHAKE_NETWORK, MIN_UTXO_VALUE } from './constants';
+import * as bitcoinLib from 'bitcoinjs-lib';
+/**
+ * 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

@@ -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,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rosen-bridge/rosen-extractor",
-  "version": "11.2.1",
+  "version": "11.3.0",
   "description": "this project contains methods to get rosen data from blockchain",
   "repository": {
     "type": "git",
@@ -32,9 +32,9 @@
     "@cardano-ogmios/schema": "^6.0.3",
     "@emurgo/cardano-serialization-lib-nodejs": "^13.2.1",
     "@rosen-bridge/abstract-logger": "^4.0.0",
-    "@rosen-bridge/address-codec": "^1.1.1",
+    "@rosen-bridge/address-codec": "^1.2.0",
     "@rosen-bridge/json-bigint": "^1.1.0",
-    "@rosen-bridge/tokens": "^5.0.1",
+    "@rosen-bridge/tokens": "^6.0.0",
     "bitcoinjs-lib": "^6.1.5",
     "ergo-lib-wasm-nodejs": "^0.24.1",
     "ethers": "6.16.0",