@rosen-bridge/rosen-extractor 3.4.0 → 4.0.0

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

@@ -2,13 +2,17 @@ import { RosenTokens, TokenMap } from '@rosen-bridge/tokens';
 import { RosenData } from './types';
 import { AbstractLogger } from '@rosen-bridge/abstract-logger';
 export default abstract class AbstractRosenDataExtractor<TransactionType> {
-    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
-     */
-    abstract get: (transaction: TransactionType) => RosenData | undefined;
+  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
+   */
+  abstract get: (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,18 +4,25 @@ 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> {
-    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
-     */
-    get: (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;
+  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
+   */
+  get: (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,18 +4,25 @@ import { BitcoinTxOutput } from './types';
 import { RosenTokens } from '@rosen-bridge/tokens';
 import { AbstractLogger } from '@rosen-bridge/abstract-logger';
 export declare class BitcoinRosenExtractor extends AbstractRosenDataExtractor<string> {
-    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
-     */
-    get: (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;
+  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
+   */
+  get: (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/types.d.ts

@@ -1,59 +1,59 @@
 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: {
-        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 {
+  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;
 }
 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[];
 }
-//# 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,16 +2,19 @@ import { RosenData, TokenTransformation } from '../abstract/types';
 import AbstractRosenDataExtractor from '../abstract/AbstractRosenDataExtractor';
 import { BlockFrostOutputBox, BlockFrostTransaction } from './types';
 export declare class CardanoBlockFrostRosenExtractor extends AbstractRosenDataExtractor<BlockFrostTransaction> {
-    /**
-     * extracts RosenData from given lock transaction in blockfrost format
-     * @param transaction the lock transaction in blockfrost format
-     */
-    get: (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;
+  /**
+   * extracts RosenData from given lock transaction in blockfrost format
+   * @param transaction the lock transaction in blockfrost format
+   */
+  get: (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,16 +2,19 @@ import { RosenData, TokenTransformation } from '../abstract/types';
 import AbstractRosenDataExtractor from '../abstract/AbstractRosenDataExtractor';
 import { GraphQLTransaction, GraphQLTxOutput } from './types';
 export declare class CardanoGraphQLRosenExtractor extends AbstractRosenDataExtractor<GraphQLTransaction> {
-    /**
-     * extracts RosenData from given lock transaction in graphql format
-     * @param transaction the lock transaction in graphql format
-     */
-    get: (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;
+  /**
+   * extracts RosenData from given lock transaction in graphql format
+   * @param transaction the lock transaction in graphql format
+   */
+  get: (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,16 +2,19 @@ import { RosenData, TokenTransformation } from '../abstract/types';
 import AbstractRosenDataExtractor from '../abstract/AbstractRosenDataExtractor';
 import { KoiosTransaction, Utxo } from './types';
 export declare class CardanoKoiosRosenExtractor extends AbstractRosenDataExtractor<KoiosTransaction> {
-    /**
-     * extracts RosenData from given lock transaction in Koios format
-     * @param transaction the lock transaction in Koios format
-     */
-    get: (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;
+  /**
+   * extracts RosenData from given lock transaction in Koios format
+   * @param transaction the lock transaction in Koios format
+   */
+  get: (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,16 +2,19 @@ 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> {
-    /**
-     * extracts RosenData from given lock transaction in Ogmios format
-     * @param transaction the lock transaction in Koios format
-     */
-    get: (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;
+  /**
+   * extracts RosenData from given lock transaction in Ogmios format
+   * @param transaction the lock transaction in Koios format
+   */
+  get: (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,16 +2,19 @@ import AbstractRosenDataExtractor from '../abstract/AbstractRosenDataExtractor';
 import { RosenData, TokenTransformation } from '../abstract/types';
 import { CardanoBoxCandidate } from './types';
 export declare class CardanoRosenExtractor extends AbstractRosenDataExtractor<string> {
-    /**
-     * extracts RosenData from given lock transaction in CardanoTx format
-     * @param serializedTransaction stringified transaction in CardanoTx format
-     */
-    get: (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;
+  /**
+   * extracts RosenData from given lock transaction in CardanoTx format
+   * @param serializedTransaction stringified transaction in CardanoTx format
+   */
+  get: (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