@rosen-bridge/rosen-extractor 6.3.0 → 6.3.1

package/dist/lib/getRosenData/abstract/AbstractRosenDataExtractor.d.ts

@@ -2,24 +2,18 @@ import { RosenTokens, TokenMap } from '@rosen-bridge/tokens';
 import { RosenData } from './types';
 import { AbstractLogger } from '@rosen-bridge/abstract-logger';
 export default abstract class AbstractRosenDataExtractor<TransactionType> {
-  abstract readonly chain: string;
-  protected readonly logger: AbstractLogger;
-  protected readonly tokens: TokenMap;
-  protected readonly lockAddress: string;
-  constructor(
-    lockAddress: string,
-    tokens: RosenTokens,
-    logger?: AbstractLogger
-  );
-  /**
-   * extracts RosenData from given lock transaction and wrap the amount
-   */
-  get: (transaction: TransactionType) => RosenData | undefined;
-  /**
-   * extracts RosenData from given lock transaction
-   */
-  abstract extractRawData: (
-    transaction: TransactionType
-  ) => RosenData | undefined;
+    abstract readonly chain: string;
+    protected readonly logger: AbstractLogger;
+    protected readonly tokens: TokenMap;
+    protected readonly lockAddress: string;
+    constructor(lockAddress: string, tokens: RosenTokens, logger?: AbstractLogger);
+    /**
+     * extracts RosenData from given lock transaction and wrap the amount
+     */
+    get: (transaction: TransactionType) => RosenData | undefined;
+    /**
+     * extracts RosenData from given lock transaction
+     */
+    abstract extractRawData: (transaction: TransactionType) => RosenData | undefined;
 }
-//# sourceMappingURL=AbstractRosenDataExtractor.d.ts.map
+//# sourceMappingURL=AbstractRosenDataExtractor.d.ts.map

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

@@ -1,18 +1,18 @@
 interface RosenData {
-  toChain: string;
-  toAddress: string;
-  bridgeFee: string;
-  networkFee: string;
-  fromAddress: string;
-  sourceChainTokenId: string;
-  amount: string;
-  targetChainTokenId: string;
-  sourceTxId: string;
+    toChain: string;
+    toAddress: string;
+    bridgeFee: string;
+    networkFee: string;
+    fromAddress: string;
+    sourceChainTokenId: string;
+    amount: string;
+    targetChainTokenId: string;
+    sourceTxId: string;
 }
 interface TokenTransformation {
-  from: string;
-  to: string;
-  amount: string;
+    from: string;
+    to: string;
+    amount: string;
 }
 export { RosenData, TokenTransformation };
-//# sourceMappingURL=types.d.ts.map
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/getRosenData/bitcoin/BitcoinEsploraRosenExtractor.d.ts

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

package/dist/lib/getRosenData/bitcoin/BitcoinRosenExtractor.d.ts

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

package/dist/lib/getRosenData/bitcoin/BitcoinRpcRosenExtractor.d.ts

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

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

@@ -1,89 +1,89 @@
 export interface OpReturnData {
-  toChain: string;
-  toAddress: string;
-  bridgeFee: string;
-  networkFee: string;
+    toChain: string;
+    toAddress: string;
+    bridgeFee: string;
+    networkFee: string;
 }
 export interface EsploraTxInput {
-  txid: string;
-  vout: number;
-  prevout: {
+    txid: string;
+    vout: number;
+    prevout: {
+        scriptpubkey: string;
+        scriptpubkey_asm: string;
+        scriptpubkey_type: string;
+        scriptpubkey_address: string;
+        value: number;
+    };
+    scriptsig: string;
+    scriptsig_asm: string;
+    is_coinbase: false;
+    sequence: number;
+}
+export interface EsploraTxOutput {
     scriptpubkey: string;
     scriptpubkey_asm: string;
     scriptpubkey_type: string;
     scriptpubkey_address: string;
     value: number;
-  };
-  scriptsig: string;
-  scriptsig_asm: string;
-  is_coinbase: false;
-  sequence: number;
-}
-export interface EsploraTxOutput {
-  scriptpubkey: string;
-  scriptpubkey_asm: string;
-  scriptpubkey_type: string;
-  scriptpubkey_address: string;
-  value: number;
 }
 export interface BitcoinEsploraTransaction {
-  txid: string;
-  version: number;
-  locktime: number;
-  vin: Array<EsploraTxInput>;
-  vout: Array<EsploraTxOutput>;
-  size: number;
-  weight: number;
-  fee: number;
-  status: {
-    confirmed: true;
-    block_height: number;
-    block_hash: string;
-    block_time: number;
-  };
+    txid: string;
+    version: number;
+    locktime: number;
+    vin: Array<EsploraTxInput>;
+    vout: Array<EsploraTxOutput>;
+    size: number;
+    weight: number;
+    fee: number;
+    status: {
+        confirmed: true;
+        block_height: number;
+        block_hash: string;
+        block_time: number;
+    };
 }
 export interface BitcoinTxInput {
-  txId: string;
-  index: number;
-  scriptPubKey: string;
+    txId: string;
+    index: number;
+    scriptPubKey: string;
 }
 export interface BitcoinTxOutput {
-  scriptPubKey: string;
-  value: bigint;
+    scriptPubKey: string;
+    value: bigint;
 }
 export interface BitcoinTx {
-  id: string;
-  inputs: BitcoinTxInput[];
-  outputs: BitcoinTxOutput[];
+    id: string;
+    inputs: BitcoinTxInput[];
+    outputs: BitcoinTxOutput[];
 }
 export interface BitcoinRpcTxInput {
-  txid: string;
-  vout: number;
-  scriptSig: {
-    asm: string;
-    hex: string;
-  };
-  txinwitness: Array<string>;
-  sequence: number;
+    txid: string;
+    vout: number;
+    scriptSig: {
+        asm: string;
+        hex: string;
+    };
+    txinwitness: Array<string>;
+    sequence: number;
 }
 export interface BitcoinRpcTxOutput {
-  value: number;
-  n: number;
-  scriptPubKey: {
-    asm: string;
-    hex: string;
-  };
+    value: number;
+    n: number;
+    scriptPubKey: {
+        asm: string;
+        hex: string;
+    };
 }
 export interface BitcoinRpcTransaction {
-  txid: string;
-  hash: string;
-  version: number;
-  size: number;
-  vsize: number;
-  weight: number;
-  locktime: number;
-  vin: Array<BitcoinRpcTxInput>;
-  vout: Array<BitcoinRpcTxOutput>;
-  hex: string;
+    txid: string;
+    hash: string;
+    version: number;
+    size: number;
+    vsize: number;
+    weight: number;
+    locktime: number;
+    vin: Array<BitcoinRpcTxInput>;
+    vout: Array<BitcoinRpcTxOutput>;
+    hex: string;
 }
-//# sourceMappingURL=types.d.ts.map
+//# sourceMappingURL=types.d.ts.map

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

@@ -4,4 +4,4 @@ import { OpReturnData } from './types';
  * @param scriptPubKeyHex
  */
 export declare const parseRosenData: (scriptPubKeyHex: string) => OpReturnData;
-//# sourceMappingURL=utils.d.ts.map
+//# sourceMappingURL=utils.d.ts.map

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

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

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

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

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

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

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

@@ -2,20 +2,17 @@ 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,20 +2,17 @@ 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