@galacticcouncil/sdk-next 0.0.0

package/build/types/api/Papi.d.ts

@@ -0,0 +1,385 @@
+import { PolkadotClient } from 'polkadot-api';
+export declare abstract class Papi {
+    readonly client: PolkadotClient;
+    constructor(client: PolkadotClient);
+    get api(): import("polkadot-api").TypedApi<{
+        descriptors: {
+            pallets: {
+                __storage: {
+                    System: {
+                        Account: import("polkadot-api").StorageDescriptor<[Key: import("polkadot-api").SS58String], {
+                            nonce: number;
+                            consumers: number;
+                            providers: number;
+                            sufficients: number;
+                            data: {
+                                free: bigint;
+                                reserved: bigint;
+                                frozen: bigint;
+                                flags: bigint;
+                            };
+                        }, false, never>;
+                        Number: import("polkadot-api").StorageDescriptor<[], number, false, never>;
+                    };
+                    AssetRegistry: {
+                        Assets: import("polkadot-api").StorageDescriptor<[Key: number], {
+                            symbol: import("polkadot-api").Binary | undefined;
+                            decimals: number | undefined;
+                            name: import("polkadot-api").Binary | undefined;
+                            asset_type: import("polkadot-api").Enum<{
+                                Token: undefined;
+                                XYK: undefined;
+                                StableSwap: undefined;
+                                Bond: undefined;
+                                External: undefined;
+                                Erc20: undefined;
+                            }>;
+                            existential_deposit: bigint;
+                            xcm_rate_limit: bigint | undefined;
+                            is_sufficient: boolean;
+                        }, true, never>;
+                        AssetLocations: import("polkadot-api").StorageDescriptor<[Key: number], {
+                            parents: number;
+                            interior: import("@galacticcouncil/descriptors").XcmV3Junctions;
+                        }, true, never>;
+                    };
+                    Omnipool: {
+                        Assets: import("polkadot-api").StorageDescriptor<[Key: number], {
+                            shares: bigint;
+                            hub_reserve: bigint;
+                            protocol_shares: bigint;
+                            cap: bigint;
+                            tradable: number;
+                        }, true, never>;
+                        HubAssetTradability: import("polkadot-api").StorageDescriptor<[], number, false, never>;
+                    };
+                    DynamicFees: {
+                        AssetFee: import("polkadot-api").StorageDescriptor<[Key: number], {
+                            asset_fee: number;
+                            protocol_fee: number;
+                            timestamp: number;
+                        }, true, never>;
+                    };
+                    Stableswap: {
+                        Pools: import("polkadot-api").StorageDescriptor<[Key: number], {
+                            assets: number[];
+                            initial_amplification: number;
+                            final_amplification: number;
+                            initial_block: number;
+                            final_block: number;
+                            fee: number;
+                        }, true, never>;
+                        AssetTradability: import("polkadot-api").StorageDescriptor<import("polkadot-api").FixedSizeArray<2, number>, number, false, never>;
+                    };
+                    Bonds: {
+                        Bonds: import("polkadot-api").StorageDescriptor<[Key: number], [number, bigint], true, never>;
+                    };
+                    LBP: {
+                        PoolData: import("polkadot-api").StorageDescriptor<[Key: import("polkadot-api").SS58String], {
+                            assets: import("polkadot-api").FixedSizeArray<2, number>;
+                            fee: import("polkadot-api").FixedSizeArray<2, number>;
+                            owner: import("polkadot-api").SS58String;
+                            start: number | undefined;
+                            end: number | undefined;
+                            initial_weight: number;
+                            final_weight: number;
+                            weight_curve: {
+                                type: "Linear";
+                                value: undefined;
+                            };
+                            fee_collector: import("polkadot-api").SS58String;
+                            repay_target: bigint;
+                        }, true, never>;
+                    };
+                    XYK: {
+                        PoolAssets: import("polkadot-api").StorageDescriptor<[Key: import("polkadot-api").SS58String], import("polkadot-api").FixedSizeArray<2, number>, true, never>;
+                    };
+                    Tokens: {
+                        TotalIssuance: import("polkadot-api").StorageDescriptor<[Key: number], bigint, false, never>;
+                        Accounts: import("polkadot-api").StorageDescriptor<[import("polkadot-api").SS58String, number], {
+                            free: bigint;
+                            frozen: bigint;
+                            reserved: bigint;
+                        }, false, never>;
+                    };
+                    ParachainSystem: {
+                        ValidationData: import("polkadot-api").StorageDescriptor<[], {
+                            parent_head: import("polkadot-api").Binary;
+                            relay_parent_number: number;
+                            relay_parent_storage_root: import("polkadot-api").FixedSizeBinary<32>;
+                            max_pov_size: number;
+                        }, true, never>;
+                    };
+                };
+                __tx: {
+                    Omnipool: {
+                        sell: import("polkadot-api").TxDescriptor<{
+                            amount: bigint;
+                            asset_in: number;
+                            asset_out: number;
+                            min_buy_amount: bigint;
+                        }>;
+                        buy: import("polkadot-api").TxDescriptor<{
+                            amount: bigint;
+                            asset_in: number;
+                            asset_out: number;
+                            max_sell_amount: bigint;
+                        }>;
+                    };
+                    Router: {
+                        sell: import("polkadot-api").TxDescriptor<{
+                            asset_in: number;
+                            asset_out: number;
+                            amount_in: bigint;
+                            route: {
+                                pool: import("polkadot-api").Enum<{
+                                    "XYK": undefined;
+                                    "LBP": undefined;
+                                    "Stableswap": number;
+                                    "Omnipool": undefined;
+                                    "Aave": undefined;
+                                }>;
+                                asset_in: number;
+                                asset_out: number;
+                            }[];
+                            min_amount_out: bigint;
+                        }>;
+                        buy: import("polkadot-api").TxDescriptor<{
+                            asset_in: number;
+                            asset_out: number;
+                            amount_out: bigint;
+                            max_amount_in: bigint;
+                            route: {
+                                pool: import("polkadot-api").Enum<{
+                                    "XYK": undefined;
+                                    "LBP": undefined;
+                                    "Stableswap": number;
+                                    "Omnipool": undefined;
+                                    "Aave": undefined;
+                                }>;
+                                asset_in: number;
+                                asset_out: number;
+                            }[];
+                        }>;
+                        sell_all: import("polkadot-api").TxDescriptor<{
+                            asset_in: number;
+                            asset_out: number;
+                            route: {
+                                pool: import("polkadot-api").Enum<{
+                                    "XYK": undefined;
+                                    "LBP": undefined;
+                                    "Stableswap": number;
+                                    "Omnipool": undefined;
+                                    "Aave": undefined;
+                                }>;
+                                asset_in: number;
+                                asset_out: number;
+                            }[];
+                            min_amount_out: bigint;
+                        }>;
+                    };
+                };
+                __event: {
+                    Router: {
+                        Executed: import("polkadot-api").PlainDescriptor<{
+                            asset_in: number;
+                            asset_out: number;
+                            amount_in: bigint;
+                            amount_out: bigint;
+                            event_id: number;
+                        }>;
+                    };
+                    EVM: {
+                        Log: import("polkadot-api").PlainDescriptor<{
+                            log: {
+                                address: import("polkadot-api").FixedSizeBinary<20>;
+                                topics: import("polkadot-api").FixedSizeBinary<32>[];
+                                data: import("polkadot-api").Binary;
+                            };
+                        }>;
+                    };
+                };
+                __error: {};
+                __const: {
+                    System: {
+                        BlockWeights: import("polkadot-api").PlainDescriptor<{
+                            base_block: {
+                                ref_time: bigint;
+                                proof_size: bigint;
+                            };
+                            max_block: {
+                                ref_time: bigint;
+                                proof_size: bigint;
+                            };
+                            per_class: {
+                                normal: {
+                                    "base_extrinsic": {
+                                        ref_time: bigint;
+                                        proof_size: bigint;
+                                    };
+                                    "max_extrinsic"?: ({
+                                        ref_time: bigint;
+                                        proof_size: bigint;
+                                    }) | undefined;
+                                    "max_total"?: ({
+                                        ref_time: bigint;
+                                        proof_size: bigint;
+                                    }) | undefined;
+                                    "reserved"?: ({
+                                        ref_time: bigint;
+                                        proof_size: bigint;
+                                    }) | undefined;
+                                };
+                                operational: {
+                                    "base_extrinsic": {
+                                        ref_time: bigint;
+                                        proof_size: bigint;
+                                    };
+                                    "max_extrinsic"?: ({
+                                        ref_time: bigint;
+                                        proof_size: bigint;
+                                    }) | undefined;
+                                    "max_total"?: ({
+                                        ref_time: bigint;
+                                        proof_size: bigint;
+                                    }) | undefined;
+                                    "reserved"?: ({
+                                        ref_time: bigint;
+                                        proof_size: bigint;
+                                    }) | undefined;
+                                };
+                                mandatory: {
+                                    "base_extrinsic": {
+                                        ref_time: bigint;
+                                        proof_size: bigint;
+                                    };
+                                    "max_extrinsic"?: ({
+                                        ref_time: bigint;
+                                        proof_size: bigint;
+                                    }) | undefined;
+                                    "max_total"?: ({
+                                        ref_time: bigint;
+                                        proof_size: bigint;
+                                    }) | undefined;
+                                    "reserved"?: ({
+                                        ref_time: bigint;
+                                        proof_size: bigint;
+                                    }) | undefined;
+                                };
+                            };
+                        }>;
+                        BlockLength: import("polkadot-api").PlainDescriptor<{
+                            normal: number;
+                            operational: number;
+                            mandatory: number;
+                        }>;
+                        BlockHashCount: import("polkadot-api").PlainDescriptor<number>;
+                        DbWeight: import("polkadot-api").PlainDescriptor<{
+                            read: bigint;
+                            write: bigint;
+                        }>;
+                        Version: import("polkadot-api").PlainDescriptor<{
+                            apis: [import("polkadot-api").FixedSizeBinary<8>, number][];
+                            spec_name: string;
+                            impl_name: string;
+                            authoring_version: number;
+                            spec_version: number;
+                            impl_version: number;
+                            transaction_version: number;
+                            state_version: number;
+                        }>;
+                        SS58Prefix: import("polkadot-api").PlainDescriptor<number>;
+                    };
+                    Omnipool: {
+                        HdxAssetId: import("polkadot-api").PlainDescriptor<number>;
+                        HubAssetId: import("polkadot-api").PlainDescriptor<number>;
+                        MinWithdrawalFee: import("polkadot-api").PlainDescriptor<number>;
+                        MinimumTradingLimit: import("polkadot-api").PlainDescriptor<bigint>;
+                        MinimumPoolLiquidity: import("polkadot-api").PlainDescriptor<bigint>;
+                        MaxInRatio: import("polkadot-api").PlainDescriptor<bigint>;
+                        MaxOutRatio: import("polkadot-api").PlainDescriptor<bigint>;
+                        NFTCollectionId: import("polkadot-api").PlainDescriptor<bigint>;
+                        BurnProtocolFee: import("polkadot-api").PlainDescriptor<number>;
+                    };
+                    DynamicFees: {
+                        AssetFeeParameters: import("polkadot-api").PlainDescriptor<{
+                            min_fee: number;
+                            max_fee: number;
+                            decay: bigint;
+                            amplification: bigint;
+                        }>;
+                        ProtocolFeeParameters: import("polkadot-api").PlainDescriptor<{
+                            min_fee: number;
+                            max_fee: number;
+                            decay: bigint;
+                            amplification: bigint;
+                        }>;
+                    };
+                    Stableswap: {
+                        MinPoolLiquidity: import("polkadot-api").PlainDescriptor<bigint>;
+                        MinTradingLimit: import("polkadot-api").PlainDescriptor<bigint>;
+                        AmplificationRange: import("polkadot-api").PlainDescriptor<{
+                            start: number;
+                            end: number;
+                        }>;
+                    };
+                    LBP: {
+                        MinTradingLimit: import("polkadot-api").PlainDescriptor<bigint>;
+                        MinPoolLiquidity: import("polkadot-api").PlainDescriptor<bigint>;
+                        MaxInRatio: import("polkadot-api").PlainDescriptor<bigint>;
+                        MaxOutRatio: import("polkadot-api").PlainDescriptor<bigint>;
+                        repay_fee: import("polkadot-api").PlainDescriptor<import("polkadot-api").FixedSizeArray<2, number>>;
+                    };
+                    XYK: {
+                        NativeAssetId: import("polkadot-api").PlainDescriptor<number>;
+                        GetExchangeFee: import("polkadot-api").PlainDescriptor<import("polkadot-api").FixedSizeArray<2, number>>;
+                        MinTradingLimit: import("polkadot-api").PlainDescriptor<bigint>;
+                        MinPoolLiquidity: import("polkadot-api").PlainDescriptor<bigint>;
+                        MaxInRatio: import("polkadot-api").PlainDescriptor<bigint>;
+                        MaxOutRatio: import("polkadot-api").PlainDescriptor<bigint>;
+                        OracleSource: import("polkadot-api").PlainDescriptor<import("polkadot-api").FixedSizeBinary<8>>;
+                    };
+                };
+                __view: {};
+            };
+            apis: {
+                CurrenciesApi: {
+                    account: import("polkadot-api").RuntimeDescriptor<[asset_id: number, who: import("polkadot-api").SS58String], {
+                        free: bigint;
+                        frozen: bigint;
+                        reserved: bigint;
+                    }>;
+                    accounts: import("polkadot-api").RuntimeDescriptor<[who: import("polkadot-api").SS58String], [number, {
+                        free: bigint;
+                        frozen: bigint;
+                        reserved: bigint;
+                    }][]>;
+                    free_balance: import("polkadot-api").RuntimeDescriptor<[asset_id: number, who: import("polkadot-api").SS58String], bigint>;
+                };
+                AaveTradeExecutor: {
+                    pairs: import("polkadot-api").RuntimeDescriptor<[], import("polkadot-api").FixedSizeArray<2, number>[]>;
+                    liquidity_depth: import("polkadot-api").RuntimeDescriptor<[asset_in: number, asset_out: number], bigint | undefined>;
+                    pool: import("polkadot-api").RuntimeDescriptor<[reserve: number, atoken: number], {
+                        reserve: number;
+                        atoken: number;
+                        liqudity_in: bigint;
+                        liqudity_out: bigint;
+                    }>;
+                    pools: import("polkadot-api").RuntimeDescriptor<[], {
+                        reserve: number;
+                        atoken: number;
+                        liqudity_in: bigint;
+                        liqudity_out: bigint;
+                    }[]>;
+                };
+            };
+        } & Promise<any>;
+        metadataTypes: Promise<Uint8Array>;
+        asset: {
+            _type?: void | undefined;
+        };
+        getMetadata: () => Promise<Uint8Array>;
+        genesis: string | undefined;
+    }>;
+    logSync(who: string, action: string, payload: any): void;
+}

package/build/types/api/client.d.ts

@@ -0,0 +1,2 @@
+import { PolkadotClient } from 'polkadot-api';
+export declare const getWs: (wsUrl: string | string[]) => Promise<PolkadotClient>;

package/build/types/api/index.d.ts

@@ -0,0 +1,2 @@
+export * from './client';
+export * from './Papi';

package/build/types/client/AssetClient.d.ts

@@ -0,0 +1,24 @@
+import { PolkadotClient } from 'polkadot-api';
+import { HydrationQueries } from '@galacticcouncil/descriptors';
+import { Papi } from '../api';
+import { Asset, ExternalAsset } from '../types';
+type TStableswapPool = HydrationQueries['Stableswap']['Pools']['Value'];
+type TBond = HydrationQueries['Bonds']['Bonds']['Value'];
+type TAssetDetails = HydrationQueries['AssetRegistry']['Assets']['Value'];
+type TAssetLocation = HydrationQueries['AssetRegistry']['AssetLocations']['Value'];
+export declare class AssetClient extends Papi {
+    private SUPPORTED_TYPES;
+    constructor(client: PolkadotClient);
+    queryShares(): Promise<Map<number, TStableswapPool>>;
+    queryBonds(): Promise<Map<number, TBond>>;
+    queryAssets(): Promise<Map<number, TAssetDetails>>;
+    queryAssetLocations(): Promise<Map<number, TAssetLocation>>;
+    private mapToken;
+    private mapBond;
+    private mapShares;
+    private mapExternal;
+    private parseMetadata;
+    getOnChainAssets(includeInvalid?: boolean, external?: ExternalAsset[]): Promise<Asset[]>;
+    private isValidAsset;
+}
+export {};

package/build/types/client/BalanceClient.d.ts

@@ -0,0 +1,17 @@
+import { PolkadotClient } from 'polkadot-api';
+import { type Observable } from 'rxjs';
+import { Papi } from '../api';
+import { AssetAmount } from '../types';
+export declare class BalanceClient extends Papi {
+    constructor(client: PolkadotClient);
+    getBalance(account: string, assetId: number): Promise<bigint>;
+    getSystemBalance(account: string): Promise<bigint>;
+    getTokenBalance(account: string, assetId: number): Promise<bigint>;
+    getErc20Balance(account: string, assetId: number): Promise<bigint>;
+    subscribeBalance(address: string): Observable<AssetAmount[]>;
+    subscribeSystemBalance(address: string): Observable<AssetAmount>;
+    subscribeTokenBalance(address: string, assetId: number): Observable<AssetAmount>;
+    subscribeTokensBalance(address: string): Observable<AssetAmount[]>;
+    subscribeErc20Balance(address: string, includeOnly?: number[]): Observable<AssetAmount[]>;
+    private getTokenBalanceData;
+}

package/build/types/client/index.d.ts

@@ -0,0 +1,2 @@
+export { AssetClient } from './AssetClient';
+export { BalanceClient } from './BalanceClient';

package/build/types/consts.d.ts

@@ -0,0 +1,8 @@
+export declare const RUNTIME_DECIMALS = 18;
+export declare const SYSTEM_ASSET_ID = 0;
+export declare const SYSTEM_ASSET_DECIMALS = 12;
+export declare const HYDRATION_PARACHAIN_ID = 2034;
+export declare const HYDRATION_SS58_PREFIX = 63;
+export declare const HYDRATION_OMNIPOOL_ADDRESS = "7L53bUTBbfuj14UpdCNPwmgzzHSsrsTWBHX5pys32mVWM3C1";
+export declare const HUB_ASSET_ID = 1;
+export declare const TRADEABLE_DEFAULT = 15;

package/build/types/errors.d.ts

@@ -0,0 +1,10 @@
+import { PoolType } from './pool';
+export declare class AssetNotFound extends Error {
+    constructor(asset: number);
+}
+export declare class PoolNotFound extends Error {
+    constructor(poolType: PoolType);
+}
+export declare class RouteNotFound extends Error {
+    constructor(assetIn: number, assetOut: number);
+}

package/build/types/index.d.ts

@@ -0,0 +1,8 @@
+export * as api from './api';
+export * as client from './client';
+export * as const from './consts';
+export * as error from './errors';
+export * as pool from './pool';
+export * as sor from './sor';
+export * from './types';
+export * from './utils';

package/build/types/pool/PoolClient.d.ts

@@ -0,0 +1,25 @@
+import { PolkadotClient } from 'polkadot-api';
+import { type Observable } from 'rxjs';
+import { BalanceClient } from '../client';
+import { PoolBase, PoolFees, PoolTokenOverride, PoolType } from './types';
+export declare abstract class PoolClient<T extends PoolBase> extends BalanceClient {
+    private override;
+    private mem;
+    private memPools;
+    constructor(client: PolkadotClient);
+    protected abstract loadPools(): Promise<T[]>;
+    abstract getPoolFees(pool: T, feeAsset: number): Promise<PoolFees>;
+    abstract getPoolType(): PoolType;
+    abstract isSupported(): Promise<boolean>;
+    abstract subscribePoolChange(pool: T): Observable<T>;
+    withOverride(override?: PoolTokenOverride[]): Promise<void>;
+    getPoolsMem(): Promise<T[]>;
+    getPools(): Promise<T[]>;
+    getSubscriber(): Observable<T>;
+    private subscribe;
+    private subscribePoolBalance;
+    private hasSystemAsset;
+    private hasErc20Asset;
+    private hasValidAssets;
+    private updatePool;
+}

package/build/types/pool/PoolContextProvider.d.ts

@@ -0,0 +1,30 @@
+import { PolkadotClient } from 'polkadot-api';
+import { Papi } from '../api';
+import { IPoolCtxProvider, PoolBase, PoolFees, PoolTokenOverride } from './types';
+export declare class PoolContextProvider extends Papi implements IPoolCtxProvider {
+    private readonly lbpClient;
+    private readonly omniClient;
+    private readonly stableClient;
+    private readonly xykClient;
+    private readonly aaveClient;
+    private readonly active;
+    private readonly clients;
+    private readonly pools;
+    private lbpSub;
+    private omniSub;
+    private stableSub;
+    private xykSub;
+    private aaveSub;
+    private isReady;
+    private isDestroyed;
+    constructor(client: PolkadotClient);
+    private subscribe;
+    withOmnipool(): this;
+    withStableswap(): this;
+    withLbp(): this;
+    withAave(): this;
+    withXyk(override?: PoolTokenOverride[]): this;
+    destroy(): void;
+    getPools(): Promise<PoolBase[]>;
+    getPoolFees(pool: PoolBase, feeAsset: number): Promise<PoolFees>;
+}

package/build/types/pool/PoolFactory.d.ts

@@ -0,0 +1,4 @@
+import { Pool, PoolBase } from './types';
+export declare class PoolFactory {
+    static get(pool: PoolBase): Pool;
+}

package/build/types/pool/aave/AaveAbi.d.ts

@@ -0,0 +1,126 @@
+export declare const AAVE_ABI: readonly [{
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "reserve";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "onBehalfOf";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "uint16";
+        readonly name: "referralCode";
+        readonly type: "uint16";
+    }];
+    readonly name: "Supply";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "reserve";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "Withdraw";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "reserve";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "onBehalfOf";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "enum DataTypes.InterestRateMode";
+        readonly name: "interestRateMode";
+        readonly type: "uint8";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "borrowRate";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "uint16";
+        readonly name: "referralCode";
+        readonly type: "uint16";
+    }];
+    readonly name: "Borrow";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "reserve";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "repayer";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "bool";
+        readonly name: "useATokens";
+        readonly type: "bool";
+    }];
+    readonly name: "Repay";
+    readonly type: "event";
+}];