@rosen-bridge/rosen-extractor 6.2.1 → 6.3.0

package/dist/lib/getRosenData/cardano/CardanoOgmiosRosenExtractor.d.ts

@@ -2,17 +2,20 @@ import { RosenData, TokenTransformation } from '../abstract/types';
 import AbstractRosenDataExtractor from '../abstract/AbstractRosenDataExtractor';
 import { Transaction, TransactionOutput } from '@cardano-ogmios/schema';
 export declare class CardanoOgmiosRosenExtractor extends AbstractRosenDataExtractor<Transaction> {
-    readonly chain = "cardano";
-    /**
-     * extracts RosenData from given lock transaction in Ogmios format
-     * @param transaction the lock transaction in Koios format
-     */
-    extractRawData: (transaction: Transaction) => RosenData | undefined;
-    /**
-     * extracts and builds token transformation from TxOut and tokenMap
-     * @param box transaction output
-     * @param toChain event target chain
-     */
-    getAssetTransformation: (box: TransactionOutput, toChain: string) => TokenTransformation | undefined;
+  readonly chain = 'cardano';
+  /**
+   * extracts RosenData from given lock transaction in Ogmios format
+   * @param transaction the lock transaction in Koios format
+   */
+  extractRawData: (transaction: Transaction) => RosenData | undefined;
+  /**
+   * extracts and builds token transformation from TxOut and tokenMap
+   * @param box transaction output
+   * @param toChain event target chain
+   */
+  getAssetTransformation: (
+    box: TransactionOutput,
+    toChain: string
+  ) => TokenTransformation | undefined;
 }
-//# sourceMappingURL=CardanoOgmiosRosenExtractor.d.ts.map
+//# sourceMappingURL=CardanoOgmiosRosenExtractor.d.ts.map

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

@@ -2,17 +2,20 @@ import AbstractRosenDataExtractor from '../abstract/AbstractRosenDataExtractor';
 import { RosenData, TokenTransformation } from '../abstract/types';
 import { CardanoBoxCandidate } from './types';
 export declare class CardanoRosenExtractor extends AbstractRosenDataExtractor<string> {
-    readonly chain = "cardano";
-    /**
-     * extracts RosenData from given lock transaction in CardanoTx format
-     * @param serializedTransaction stringified transaction in CardanoTx format
-     */
-    extractRawData: (serializedTransaction: string) => RosenData | undefined;
-    /**
-     * extracts and builds token transformation from CardanoBoxCandidate and tokenMap
-     * @param box transaction output in CardanoBoxCandidate format
-     * @param toChain event target chain
-     */
-    getAssetTransformation: (box: CardanoBoxCandidate, toChain: string) => TokenTransformation | undefined;
+  readonly chain = 'cardano';
+  /**
+   * extracts RosenData from given lock transaction in CardanoTx format
+   * @param serializedTransaction stringified transaction in CardanoTx format
+   */
+  extractRawData: (serializedTransaction: string) => RosenData | undefined;
+  /**
+   * extracts and builds token transformation from CardanoBoxCandidate and tokenMap
+   * @param box transaction output in CardanoBoxCandidate format
+   * @param toChain event target chain
+   */
+  getAssetTransformation: (
+    box: CardanoBoxCandidate,
+    toChain: string
+  ) => TokenTransformation | undefined;
 }
-//# sourceMappingURL=CardanoRosenExtractor.d.ts.map
+//# sourceMappingURL=CardanoRosenExtractor.d.ts.map

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

@@ -1,126 +1,146 @@
 import { components } from '@blockfrost/openapi';
 interface PaymentAddr {
-    bech32: string;
-    cred: string;
+  bech32: string;
+  cred: string;
 }
 interface Asset {
-    policy_id: string;
-    asset_name: string;
-    quantity: string;
+  policy_id: string;
+  asset_name: string;
+  quantity: string;
 }
 interface Utxo {
-    payment_addr: PaymentAddr;
-    stake_addr?: string | null;
-    tx_hash: string;
-    tx_index: number;
-    value: string;
-    asset_list: Array<Asset>;
+  payment_addr: PaymentAddr;
+  stake_addr?: string | null;
+  tx_hash: string;
+  tx_index: number;
+  value: string;
+  asset_list: Array<Asset>;
 }
 interface Metadata {
-    [key: string]: Record<string, unknown>;
+  [key: string]: Record<string, unknown>;
 }
 interface KoiosTransaction {
-    tx_hash: string;
-    block_hash: string;
-    inputs: Array<Utxo>;
-    outputs: Array<Utxo>;
-    metadata?: Metadata;
+  tx_hash: string;
+  block_hash: string;
+  inputs: Array<Utxo>;
+  outputs: Array<Utxo>;
+  metadata?: Metadata;
 }
 interface CardanoRosenData {
-    toChain: string;
-    toAddress: string;
-    bridgeFee: string;
-    networkFee: string;
-    fromAddress: string;
+  toChain: string;
+  toAddress: string;
+  bridgeFee: string;
+  networkFee: string;
+  fromAddress: string;
 }
 interface CardanoMetadataRosenData {
-    to: string;
-    networkFee: string;
-    bridgeFee: string;
-    toAddress: string;
-    fromAddress: string[];
+  to: string;
+  networkFee: string;
+  bridgeFee: string;
+  toAddress: string;
+  fromAddress: string[];
 }
 type ListObject = Array<MetadataObject>;
 type NativeValue = string | undefined;
 interface JsonObject {
-    [key: string]: MetadataObject;
+  [key: string]: MetadataObject;
 }
 type MetadataObject = JsonObject | ListObject | NativeValue;
 interface CardanoAsset {
-    policy_id: string;
-    asset_name: string;
-    quantity: string;
+  policy_id: string;
+  asset_name: string;
+  quantity: string;
 }
 interface CardanoUtxo {
-    txId: string;
-    index: number;
-    value: bigint;
-    assets: Array<CardanoAsset>;
+  txId: string;
+  index: number;
+  value: bigint;
+  assets: Array<CardanoAsset>;
 }
 interface CardanoBoxCandidate {
-    address: string;
-    value: bigint;
-    assets: Array<CardanoAsset>;
+  address: string;
+  value: bigint;
+  assets: Array<CardanoAsset>;
 }
 type CardanoMetadata = Record<string, string | Record<string, any>>;
 interface CardanoTx {
-    id: string;
-    inputs: CardanoUtxo[];
-    outputs: CardanoBoxCandidate[];
-    fee: bigint;
-    metadata?: CardanoMetadata;
+  id: string;
+  inputs: CardanoUtxo[];
+  outputs: CardanoBoxCandidate[];
+  fee: bigint;
+  metadata?: CardanoMetadata;
 }
 interface BlockFrostTransaction {
-    utxos: components['schemas']['tx_content_utxo'];
-    metadata: components['schemas']['tx_content_metadata'];
+  utxos: components['schemas']['tx_content_utxo'];
+  metadata: components['schemas']['tx_content_metadata'];
 }
-type BlockFrostOutputBox = components['schemas']['tx_content_utxo']['outputs'][0];
+type BlockFrostOutputBox =
+  components['schemas']['tx_content_utxo']['outputs'][0];
 type GraphQLBlockTxsQuery = {
-    __typename?: 'Query';
-    blocks: Array<{
-        __typename?: 'Block';
-        transactions: Array<{
-            __typename?: 'Transaction';
-            hash: any;
-            fee: any;
-            inputs: Array<{
-                __typename?: 'TransactionInput';
-                sourceTxIndex: number;
-                sourceTxHash: any;
-                value: any;
-                tokens: Array<{
-                    __typename?: 'Token';
-                    quantity: string;
-                    asset: {
-                        __typename?: 'Asset';
-                        assetName?: any | null;
-                        policyId: any;
-                    };
-                } | null>;
-            }>;
-            outputs: Array<{
-                __typename?: 'TransactionOutput';
-                address: string;
-                value: any;
-                tokens: Array<{
-                    __typename?: 'Token';
-                    quantity: string;
-                    asset: {
-                        __typename?: 'Asset';
-                        assetName?: any | null;
-                        policyId: any;
-                    };
-                }>;
-            } | null>;
-            metadata?: Array<{
-                __typename?: 'TransactionMetadata';
-                key: string;
-                value: any;
-            } | null> | null;
+  __typename?: 'Query';
+  blocks: Array<{
+    __typename?: 'Block';
+    transactions: Array<{
+      __typename?: 'Transaction';
+      hash: any;
+      fee: any;
+      inputs: Array<{
+        __typename?: 'TransactionInput';
+        sourceTxIndex: number;
+        sourceTxHash: any;
+        value: any;
+        tokens: Array<{
+          __typename?: 'Token';
+          quantity: string;
+          asset: {
+            __typename?: 'Asset';
+            assetName?: any | null;
+            policyId: any;
+          };
         } | null>;
+      }>;
+      outputs: Array<{
+        __typename?: 'TransactionOutput';
+        address: string;
+        value: any;
+        tokens: Array<{
+          __typename?: 'Token';
+          quantity: string;
+          asset: {
+            __typename?: 'Asset';
+            assetName?: any | null;
+            policyId: any;
+          };
+        }>;
+      } | null>;
+      metadata?: Array<{
+        __typename?: 'TransactionMetadata';
+        key: string;
+        value: any;
+      } | null> | null;
     } | null>;
+  } | null>;
 };
-type GraphQLTransaction = NonNullable<NonNullable<GraphQLBlockTxsQuery['blocks'][0]>['transactions'][0]>;
+type GraphQLTransaction = NonNullable<
+  NonNullable<GraphQLBlockTxsQuery['blocks'][0]>['transactions'][0]
+>;
 type GraphQLTxOutput = NonNullable<GraphQLTransaction['outputs'][0]>;
-export { Utxo, KoiosTransaction, CardanoRosenData, CardanoMetadataRosenData, Metadata, MetadataObject, JsonObject, ListObject, NativeValue, CardanoMetadata, CardanoTx, CardanoBoxCandidate, BlockFrostTransaction, BlockFrostOutputBox, GraphQLTransaction, GraphQLTxOutput, };
-//# sourceMappingURL=types.d.ts.map
+export {
+  Utxo,
+  KoiosTransaction,
+  CardanoRosenData,
+  CardanoMetadataRosenData,
+  Metadata,
+  MetadataObject,
+  JsonObject,
+  ListObject,
+  NativeValue,
+  CardanoMetadata,
+  CardanoTx,
+  CardanoBoxCandidate,
+  BlockFrostTransaction,
+  BlockFrostOutputBox,
+  GraphQLTransaction,
+  GraphQLTxOutput,
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -3,11 +3,13 @@
  * @param data
  * @returns Rosen data or undefined if metadata is invalid
  */
-export declare const parseRosenData: (data: any) => {
-    toChain: any;
-    toAddress: any;
-    bridgeFee: any;
-    networkFee: any;
-    fromAddress: any;
-} | undefined;
-//# sourceMappingURL=utils.d.ts.map
+export declare const parseRosenData: (data: any) =>
+  | {
+      toChain: any;
+      toAddress: any;
+      bridgeFee: any;
+      networkFee: any;
+      fromAddress: any;
+    }
+  | undefined;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -3,7 +3,7 @@ export declare const ERGO_NATIVE_TOKEN = "erg";
 export declare const BITCOIN_NATIVE_TOKEN = "btc";
 export declare const BITCOIN_CHAIN = "bitcoin";
 export declare const ETHEREUM_CHAIN = "ethereum";
-export declare const ETHEREUM_NATIVE_TOKEN = "eth";
+export declare const BINANCE_CHAIN = "binance";
 export declare const CARDANO_CHAIN = "cardano";
 export declare const ERGO_CHAIN = "ergo";
 export declare const SUPPORTED_CHAINS: string[];

package/dist/lib/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,qBAAqB,QAAQ,CAAC;AAC3C,eAAO,MAAM,aAAa,YAAY,CAAC;AACvC,eAAO,MAAM,UAAU,SAAS,CAAC;AACjC,eAAO,MAAM,gBAAgB,UAK5B,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,gBAAgB,UAM5B,CAAC"}

package/dist/lib/getRosenData/const.js

@@ -3,7 +3,7 @@ export const ERGO_NATIVE_TOKEN = 'erg';
 export const BITCOIN_NATIVE_TOKEN = 'btc';
 export const BITCOIN_CHAIN = 'bitcoin';
 export const ETHEREUM_CHAIN = 'ethereum';
-export const ETHEREUM_NATIVE_TOKEN = 'eth';
+export const BINANCE_CHAIN = 'binance';
 export const CARDANO_CHAIN = 'cardano';
 export const ERGO_CHAIN = 'ergo';
 export const SUPPORTED_CHAINS = [
@@ -11,5 +11,6 @@ export const SUPPORTED_CHAINS = [
     CARDANO_CHAIN,
     BITCOIN_CHAIN,
     ETHEREUM_CHAIN,
+    BINANCE_CHAIN,
 ];
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvZ2V0Um9zZW5EYXRhL2NvbnN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFHLEtBQUssQ0FBQztBQUMxQyxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRyxLQUFLLENBQUM7QUFDdkMsTUFBTSxDQUFDLE1BQU0sb0JBQW9CLEdBQUcsS0FBSyxDQUFDO0FBQzFDLE1BQU0sQ0FBQyxNQUFNLGFBQWEsR0FBRyxTQUFTLENBQUM7QUFDdkMsTUFBTSxDQUFDLE1BQU0sY0FBYyxHQUFHLFVBQVUsQ0FBQztBQUN6QyxNQUFNLENBQUMsTUFBTSxxQkFBcUIsR0FBRyxLQUFLLENBQUM7QUFDM0MsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLFNBQVMsQ0FBQztBQUN2QyxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQUcsTUFBTSxDQUFDO0FBQ2pDLE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHO0lBQzlCLFVBQVU7SUFDVixhQUFhO0lBQ2IsYUFBYTtJQUNiLGNBQWM7Q0FDZixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IENBUkRBTk9fTkFUSVZFX1RPS0VOID0gJ2FkYSc7XG5leHBvcnQgY29uc3QgRVJHT19OQVRJVkVfVE9LRU4gPSAnZXJnJztcbmV4cG9ydCBjb25zdCBCSVRDT0lOX05BVElWRV9UT0tFTiA9ICdidGMnO1xuZXhwb3J0IGNvbnN0IEJJVENPSU5fQ0hBSU4gPSAnYml0Y29pbic7XG5leHBvcnQgY29uc3QgRVRIRVJFVU1fQ0hBSU4gPSAnZXRoZXJldW0nO1xuZXhwb3J0IGNvbnN0IEVUSEVSRVVNX05BVElWRV9UT0tFTiA9ICdldGgnO1xuZXhwb3J0IGNvbnN0IENBUkRBTk9fQ0hBSU4gPSAnY2FyZGFubyc7XG5leHBvcnQgY29uc3QgRVJHT19DSEFJTiA9ICdlcmdvJztcbmV4cG9ydCBjb25zdCBTVVBQT1JURURfQ0hBSU5TID0gW1xuICBFUkdPX0NIQUlOLFxuICBDQVJEQU5PX0NIQUlOLFxuICBCSVRDT0lOX0NIQUlOLFxuICBFVEhFUkVVTV9DSEFJTixcbl07XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvZ2V0Um9zZW5EYXRhL2NvbnN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFHLEtBQUssQ0FBQztBQUMxQyxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRyxLQUFLLENBQUM7QUFDdkMsTUFBTSxDQUFDLE1BQU0sb0JBQW9CLEdBQUcsS0FBSyxDQUFDO0FBQzFDLE1BQU0sQ0FBQyxNQUFNLGFBQWEsR0FBRyxTQUFTLENBQUM7QUFDdkMsTUFBTSxDQUFDLE1BQU0sY0FBYyxHQUFHLFVBQVUsQ0FBQztBQUN6QyxNQUFNLENBQUMsTUFBTSxhQUFhLEdBQUcsU0FBUyxDQUFDO0FBQ3ZDLE1BQU0sQ0FBQyxNQUFNLGFBQWEsR0FBRyxTQUFTLENBQUM7QUFDdkMsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHLE1BQU0sQ0FBQztBQUNqQyxNQUFNLENBQUMsTUFBTSxnQkFBZ0IsR0FBRztJQUM5QixVQUFVO0lBQ1YsYUFBYTtJQUNiLGFBQWE7SUFDYixjQUFjO0lBQ2QsYUFBYTtDQUNkLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgQ0FSREFOT19OQVRJVkVfVE9LRU4gPSAnYWRhJztcbmV4cG9ydCBjb25zdCBFUkdPX05BVElWRV9UT0tFTiA9ICdlcmcnO1xuZXhwb3J0IGNvbnN0IEJJVENPSU5fTkFUSVZFX1RPS0VOID0gJ2J0Yyc7XG5leHBvcnQgY29uc3QgQklUQ09JTl9DSEFJTiA9ICdiaXRjb2luJztcbmV4cG9ydCBjb25zdCBFVEhFUkVVTV9DSEFJTiA9ICdldGhlcmV1bSc7XG5leHBvcnQgY29uc3QgQklOQU5DRV9DSEFJTiA9ICdiaW5hbmNlJztcbmV4cG9ydCBjb25zdCBDQVJEQU5PX0NIQUlOID0gJ2NhcmRhbm8nO1xuZXhwb3J0IGNvbnN0IEVSR09fQ0hBSU4gPSAnZXJnbyc7XG5leHBvcnQgY29uc3QgU1VQUE9SVEVEX0NIQUlOUyA9IFtcbiAgRVJHT19DSEFJTixcbiAgQ0FSREFOT19DSEFJTixcbiAgQklUQ09JTl9DSEFJTixcbiAgRVRIRVJFVU1fQ0hBSU4sXG4gIEJJTkFOQ0VfQ0hBSU4sXG5dO1xuIl19

package/dist/lib/getRosenData/ergo/ErgoNodeRosenExtractor.d.ts

@@ -4,19 +4,26 @@ import { NodeOutputBox, NodeTransaction } from './types';
 import { RosenTokens } from '@rosen-bridge/tokens';
 import { AbstractLogger } from '@rosen-bridge/abstract-logger';
 export declare class ErgoNodeRosenExtractor extends AbstractRosenDataExtractor<NodeTransaction> {
-    readonly chain = "ergo";
-    lockErgoTree: string;
-    constructor(lockAddress: string, tokens: RosenTokens, logger?: AbstractLogger);
-    /**
-     * extracts RosenData from given lock transaction in Node format
-     * @param transaction the lock transaction in Node format
-     */
-    extractRawData: (transaction: NodeTransaction) => RosenData | undefined;
-    /**
-     * extracts and builds token transformation from NodeOutputBox and tokenMap
-     * @param box transaction output
-     * @param toChain event target chain
-     */
-    getAssetTransformation: (box: NodeOutputBox, toChain: string) => TokenTransformation | undefined;
+  readonly chain = 'ergo';
+  lockErgoTree: string;
+  constructor(
+    lockAddress: string,
+    tokens: RosenTokens,
+    logger?: AbstractLogger
+  );
+  /**
+   * extracts RosenData from given lock transaction in Node format
+   * @param transaction the lock transaction in Node format
+   */
+  extractRawData: (transaction: NodeTransaction) => RosenData | undefined;
+  /**
+   * extracts and builds token transformation from NodeOutputBox and tokenMap
+   * @param box transaction output
+   * @param toChain event target chain
+   */
+  getAssetTransformation: (
+    box: NodeOutputBox,
+    toChain: string
+  ) => TokenTransformation | undefined;
 }
-//# sourceMappingURL=ErgoNodeRosenExtractor.d.ts.map
+//# sourceMappingURL=ErgoNodeRosenExtractor.d.ts.map

package/dist/lib/getRosenData/ergo/ErgoRosenExtractor.d.ts

@@ -3,13 +3,17 @@ import AbstractRosenDataExtractor from '../abstract/AbstractRosenDataExtractor';
 import { RosenTokens } from '@rosen-bridge/tokens';
 import { AbstractLogger } from '@rosen-bridge/abstract-logger';
 export declare class ErgoRosenExtractor extends AbstractRosenDataExtractor<string> {
-    readonly chain = "ergo";
-    private nodeExtractor;
-    constructor(lockAddress: string, tokens: RosenTokens, logger?: AbstractLogger);
-    /**
-     * extracts RosenData from given lock transaction in wasm sigma serialized bytes
-     * @param serializedTransaction the sigma serialized bytes of transaction
-     */
-    extractRawData: (serializedTransaction: string) => RosenData | undefined;
+  readonly chain = 'ergo';
+  private nodeExtractor;
+  constructor(
+    lockAddress: string,
+    tokens: RosenTokens,
+    logger?: AbstractLogger
+  );
+  /**
+   * extracts RosenData from given lock transaction in wasm sigma serialized bytes
+   * @param serializedTransaction the sigma serialized bytes of transaction
+   */
+  extractRawData: (serializedTransaction: string) => RosenData | undefined;
 }
-//# sourceMappingURL=ErgoRosenExtractor.d.ts.map
+//# sourceMappingURL=ErgoRosenExtractor.d.ts.map

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

@@ -1,37 +1,37 @@
 interface NodeAsset {
-    tokenId: string;
-    amount: bigint;
+  tokenId: string;
+  amount: bigint;
 }
 interface NodeAdditionalRegisters {
-    R4?: string;
-    R5?: string;
-    R6?: string;
-    R7?: string;
-    R8?: string;
-    R9?: string;
+  R4?: string;
+  R5?: string;
+  R6?: string;
+  R7?: string;
+  R8?: string;
+  R9?: string;
 }
 interface NodeOutputBox {
-    boxId: string;
-    value: bigint;
-    ergoTree: string;
-    creationHeight: bigint | number;
-    assets?: Array<NodeAsset>;
-    additionalRegisters?: NodeAdditionalRegisters;
-    transactionId: string;
-    index: bigint | number;
+  boxId: string;
+  value: bigint;
+  ergoTree: string;
+  creationHeight: bigint | number;
+  assets?: Array<NodeAsset>;
+  additionalRegisters?: NodeAdditionalRegisters;
+  transactionId: string;
+  index: bigint | number;
 }
 interface NodeInputBox {
-    boxId: string;
+  boxId: string;
 }
 interface NodeDataInput {
-    boxId: string;
+  boxId: string;
 }
 interface NodeTransaction {
-    id: string;
-    inputs: Array<NodeInputBox>;
-    dataInputs: Array<NodeDataInput>;
-    outputs: Array<NodeOutputBox>;
-    size?: bigint;
+  id: string;
+  inputs: Array<NodeInputBox>;
+  dataInputs: Array<NodeDataInput>;
+  outputs: Array<NodeOutputBox>;
+  size?: bigint;
 }
 export { NodeOutputBox, NodeTransaction };
-//# sourceMappingURL=types.d.ts.map
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/getRosenData/evm/EvmEthersRosenExtractor.d.ts

@@ -5,13 +5,19 @@ import { RosenTokens } from '@rosen-bridge/tokens';
 import { AbstractLogger } from '@rosen-bridge/abstract-logger';
 import { EvmRpcRosenExtractor } from './EvmRpcRosenExtractor';
 export declare class EvmEthersRosenExtractor extends AbstractRosenDataExtractor<TransactionResponse> {
-    readonly chain: string;
-    protected rpcExtractor: EvmRpcRosenExtractor;
-    constructor(lockAddress: string, tokens: RosenTokens, chain: string, nativeToken: string, logger?: AbstractLogger);
-    /**
-     * extracts RosenData from given lock transaction in ethers TransactionResponse format
-     * @param txRes the lock transaction in ethers TransactionResponse format
-     */
-    extractRawData: (txRes: TransactionResponse) => RosenData | undefined;
+  readonly chain: string;
+  protected rpcExtractor: EvmRpcRosenExtractor;
+  constructor(
+    lockAddress: string,
+    tokens: RosenTokens,
+    chain: string,
+    nativeToken: string,
+    logger?: AbstractLogger
+  );
+  /**
+   * extracts RosenData from given lock transaction in ethers TransactionResponse format
+   * @param txRes the lock transaction in ethers TransactionResponse format
+   */
+  extractRawData: (txRes: TransactionResponse) => RosenData | undefined;
 }
-//# sourceMappingURL=EvmEthersRosenExtractor.d.ts.map
+//# sourceMappingURL=EvmEthersRosenExtractor.d.ts.map

package/dist/lib/getRosenData/evm/EvmRosenExtractor.d.ts

@@ -4,13 +4,19 @@ import { RosenTokens } from '@rosen-bridge/tokens';
 import { AbstractLogger } from '@rosen-bridge/abstract-logger';
 import { EvmRpcRosenExtractor } from './EvmRpcRosenExtractor';
 export declare class EvmRosenExtractor extends AbstractRosenDataExtractor<string> {
-    readonly chain: string;
-    protected rpcExtractor: EvmRpcRosenExtractor;
-    constructor(lockAddress: string, tokens: RosenTokens, chain: string, nativeToken: string, logger?: AbstractLogger);
-    /**
-     * extracts RosenData from given lock transaction in ethers Transaction format
-     * @param serializedTransaction signed serialized transaction in ethers Transaction format
-     */
-    extractRawData: (serializedTransaction: string) => RosenData | undefined;
+  readonly chain: string;
+  protected rpcExtractor: EvmRpcRosenExtractor;
+  constructor(
+    lockAddress: string,
+    tokens: RosenTokens,
+    chain: string,
+    nativeToken: string,
+    logger?: AbstractLogger
+  );
+  /**
+   * extracts RosenData from given lock transaction in ethers Transaction format
+   * @param serializedTransaction signed serialized transaction in ethers Transaction format
+   */
+  extractRawData: (serializedTransaction: string) => RosenData | undefined;
 }
-//# sourceMappingURL=EvmRosenExtractor.d.ts.map
+//# sourceMappingURL=EvmRosenExtractor.d.ts.map

package/dist/lib/getRosenData/evm/EvmRpcRosenExtractor.d.ts

@@ -4,23 +4,29 @@ import { Transaction } from 'ethers';
 import { RosenTokens } from '@rosen-bridge/tokens';
 import { AbstractLogger } from '@rosen-bridge/abstract-logger';
 export declare class EvmRpcRosenExtractor extends AbstractRosenDataExtractor<Transaction> {
-    readonly chain: string;
-    protected nativeToken: string;
-    constructor(lockAddress: string, tokens: RosenTokens, chain: string, nativeToken: string, logger?: AbstractLogger);
-    /**
-     * extracts RosenData from given lock transaction in ethers Transaction object
-     * checks:
-     *     Native token transfer:
-     *         1. `to` must be the lock address
-     *         2. the entire calldata must represent a valid CallDataRosenData
-     *     ERC20 transfer:
-     *         1. `to` address is one of the supported assets
-     *         2. first four bytes of the call data indicate `transfer` function call: a9059cbb
-     *         3. bytes from 5 to 37 must be the lock address
-     *         4. bytes from 37 to 69 show the amount
-     *         5. bytes after 69 must represent a valid CallDataRosenData
-     * @param transaction the lock transaction in ethers Transaction object
-     */
-    extractRawData: (transaction: Transaction) => RosenData | undefined;
+  readonly chain: string;
+  protected nativeToken: string;
+  constructor(
+    lockAddress: string,
+    tokens: RosenTokens,
+    chain: string,
+    nativeToken: string,
+    logger?: AbstractLogger
+  );
+  /**
+   * extracts RosenData from given lock transaction in ethers Transaction object
+   * checks:
+   *     Native token transfer:
+   *         1. `to` must be the lock address
+   *         2. the entire calldata must represent a valid CallDataRosenData
+   *     ERC20 transfer:
+   *         1. `to` address is one of the supported assets
+   *         2. first four bytes of the call data indicate `transfer` function call: a9059cbb
+   *         3. bytes from 5 to 37 must be the lock address
+   *         4. bytes from 37 to 69 show the amount
+   *         5. bytes after 69 must represent a valid CallDataRosenData
+   * @param transaction the lock transaction in ethers Transaction object
+   */
+  extractRawData: (transaction: Transaction) => RosenData | undefined;
 }
-//# sourceMappingURL=EvmRpcRosenExtractor.d.ts.map
+//# sourceMappingURL=EvmRpcRosenExtractor.d.ts.map

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

@@ -1,8 +1,8 @@
 interface CallDataRosenData {
-    toChain: string;
-    toAddress: string;
-    bridgeFee: string;
-    networkFee: string;
+  toChain: string;
+  toAddress: string;
+  bridgeFee: string;
+  networkFee: string;
 }
 /**
  * extracts rosen data from transaction's remaining call data
@@ -10,4 +10,4 @@ interface CallDataRosenData {
  */
 export declare const parseRosenData: (callData: string) => CallDataRosenData;
 export {};
-//# sourceMappingURL=utils.d.ts.map
+//# sourceMappingURL=utils.d.ts.map

package/dist/lib/index.d.ts

@@ -13,4 +13,4 @@ export { CardanoGraphQLRosenExtractor } from './getRosenData/cardano/CardanoGrap
 export { ErgoRosenExtractor } from './getRosenData/ergo/ErgoRosenExtractor';
 export { ErgoNodeRosenExtractor } from './getRosenData/ergo/ErgoNodeRosenExtractor';
 export { RosenData } from './getRosenData/abstract/types';
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=index.d.ts.map