@rosen-bridge/rosen-extractor 6.2.0 → 6.2.2

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

@@ -1,10 +1,10 @@
-export declare const CARDANO_NATIVE_TOKEN = "ada";
-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 CARDANO_CHAIN = "cardano";
-export declare const ERGO_CHAIN = "ergo";
+export declare const CARDANO_NATIVE_TOKEN = 'ada';
+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 CARDANO_CHAIN = 'cardano';
+export declare const ERGO_CHAIN = 'ergo';
 export declare const SUPPORTED_CHAINS: string[];
-//# sourceMappingURL=const.d.ts.map
+//# sourceMappingURL=const.d.ts.map

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