@cryptorubic/web3 0.14.0-alpha.solana-gas.12 → 1.0.0-alpha.no-sdk.1

package/src/lib/errors/swap/swap-error-on-provider-side.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SdkSwapErrorOnProviderSide = void 0;
+const rubic_sdk_error_1 = require("../rubic-sdk.error");
+/**
+ * Thrown, when provider rejects swap by internal reason.
+ */
+class SdkSwapErrorOnProviderSide extends rubic_sdk_error_1.RubicSdkError {
+    constructor() {
+        super();
+        Object.setPrototypeOf(this, SdkSwapErrorOnProviderSide.prototype);
+    }
+}
+exports.SdkSwapErrorOnProviderSide = SdkSwapErrorOnProviderSide;

package/src/lib/errors/swap/swap-request.error.d.ts

@@ -0,0 +1,7 @@
+import { RubicSdkError } from '../rubic-sdk.error';
+/**
+ * Thrown, when `swap` request to API is failed.
+ */
+export declare class SwapRequestError extends RubicSdkError {
+    constructor();
+}

package/src/lib/errors/swap/swap-request.error.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapRequestError = void 0;
+const rubic_sdk_error_1 = require("../rubic-sdk.error");
+/**
+ * Thrown, when `swap` request to API is failed.
+ */
+class SwapRequestError extends rubic_sdk_error_1.RubicSdkError {
+    constructor() {
+        super("Unfortunately, the provider couldn't generate the transaction. Please try again later.");
+        Object.setPrototypeOf(this, SwapRequestError.prototype);
+    }
+}
+exports.SwapRequestError = SwapRequestError;

package/src/lib/errors/swap/trade-expired.error.d.ts

@@ -0,0 +1,4 @@
+import { RubicSdkError } from '../rubic-sdk.error';
+export declare class TradeExpiredError extends RubicSdkError {
+    constructor();
+}

package/src/lib/errors/swap/trade-expired.error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradeExpiredError = void 0;
+const rubic_sdk_error_1 = require("../rubic-sdk.error");
+class TradeExpiredError extends rubic_sdk_error_1.RubicSdkError {
+    constructor() {
+        super();
+        Object.setPrototypeOf(this, TradeExpiredError.prototype);
+    }
+}
+exports.TradeExpiredError = TradeExpiredError;

package/src/lib/errors/swap/unnecessary-approve.error.d.ts

@@ -0,0 +1,7 @@
+import { RubicSdkError } from '../rubic-sdk.error';
+/**
+ * Thrown, when approve method is called, but there is enough allowance.
+ */
+export declare class UnnecessaryApproveError extends RubicSdkError {
+    constructor();
+}

package/src/lib/errors/swap/unnecessary-approve.error.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnnecessaryApproveError = void 0;
+const rubic_sdk_error_1 = require("../rubic-sdk.error");
+/**
+ * Thrown, when approve method is called, but there is enough allowance.
+ */
+class UnnecessaryApproveError extends rubic_sdk_error_1.RubicSdkError {
+    constructor() {
+        super();
+        Object.setPrototypeOf(this, UnnecessaryApproveError.prototype);
+    }
+}
+exports.UnnecessaryApproveError = UnnecessaryApproveError;

package/src/lib/errors/swap/wallet-not-connected.error.d.ts

@@ -0,0 +1,8 @@
+import { RubicSdkError } from '../rubic-sdk.error';
+/**
+ * Thrown, when method, which requires connected wallet, is called without
+ * wallet being connected.
+ */
+export declare class WalletNotConnectedError extends RubicSdkError {
+    constructor();
+}

package/src/lib/errors/swap/wallet-not-connected.error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletNotConnectedError = void 0;
+const rubic_sdk_error_1 = require("../rubic-sdk.error");
+/**
+ * Thrown, when method, which requires connected wallet, is called without
+ * wallet being connected.
+ */
+class WalletNotConnectedError extends rubic_sdk_error_1.RubicSdkError {
+    constructor() {
+        super();
+        Object.setPrototypeOf(this, WalletNotConnectedError.prototype);
+    }
+}
+exports.WalletNotConnectedError = WalletNotConnectedError;

package/src/lib/errors/swap/wrong-network.error.d.ts

@@ -0,0 +1,10 @@
+import { BlockchainName } from '@cryptorubic/core';
+import { RubicSdkError } from '../rubic-sdk.error';
+/**
+ * Thrown during swap, if user's selected network does not match source blockchain
+ * in swap parameters.
+ */
+export declare class WrongNetworkError extends RubicSdkError {
+    readonly requiredBlockchain: BlockchainName;
+    constructor(requiredBlockchain: BlockchainName);
+}

package/src/lib/errors/swap/wrong-network.error.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WrongNetworkError = void 0;
+const rubic_sdk_error_1 = require("../rubic-sdk.error");
+/**
+ * Thrown during swap, if user's selected network does not match source blockchain
+ * in swap parameters.
+ */
+class WrongNetworkError extends rubic_sdk_error_1.RubicSdkError {
+    constructor(requiredBlockchain) {
+        super();
+        this.requiredBlockchain = requiredBlockchain;
+        Object.setPrototypeOf(this, WrongNetworkError.prototype);
+    }
+}
+exports.WrongNetworkError = WrongNetworkError;

package/src/lib/utils/web3-types/common-web3-pure.js

@@ -3,11 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonWeb3Pure = void 0;
 const axios_1 = require("axios");
 class CommonWeb3Pure {
-    nativeTokenAddress = '0x0000000000000000000000000000000000000000';
-    emptyAddress = '0x0000000000000000000000000000000000000000';
-    cnApiKey;
-    regEx;
     constructor(commonParams) {
+        this.nativeTokenAddress = '0x0000000000000000000000000000000000000000';
+        this.emptyAddress = '0x0000000000000000000000000000000000000000';
         this.cnApiKey = commonParams?.cnApiKey || undefined;
         this.regEx = commonParams?.regex || undefined;
     }

package/src/lib/utils/web3-types/near-web3-pure.js

@@ -4,12 +4,12 @@ exports.NearWeb3Pure = void 0;
 const changenow_api_blockchain_1 = require("../constants/changenow-api-blockchain");
 const common_web3_pure_1 = require("./common-web3-pure");
 class NearWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
-    nativeTokenAddress = 'near';
     constructor() {
         super({
             cnApiKey: changenow_api_blockchain_1.changenowApiBlockchain.NEAR,
             regex: /(^(?=.{2,64}$)([a-z0-9][a-z0-9\-_]*(?<![-_])\.)*[a-z0-9][a-z0-9\-_]*(?<![-_])(\.near)$)|(^[0-9a-f]{64}$)/
         });
+        this.nativeTokenAddress = 'near';
     }
     async isAddressCorrect(address) {
         if (this.isNativeAddress(address)) {

package/src/lib/utils/web3-types/solana-web3-pure.js

@@ -5,12 +5,12 @@ const changenow_api_blockchain_1 = require("../constants/changenow-api-blockchai
 const common_web3_pure_1 = require("./common-web3-pure");
 const core_1 = require("@cryptorubic/core");
 class SolanaWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
-    nativeTokenAddress = 'So11111111111111111111111111111111111111111';
     constructor() {
         super({
             cnApiKey: changenow_api_blockchain_1.changenowApiBlockchain.SOLANA,
             regex: /^(?!.*([1-9A-HJ-NP-Za-km-z])\1{31,43}$)[1-9A-HJ-NP-Za-km-z]{32,44}$/
         });
+        this.nativeTokenAddress = 'So11111111111111111111111111111111111111111';
     }
     async isAddressCorrect(address) {
         if ((0, core_1.compareAddresses)(address, this.nativeTokenAddress)) {

package/src/lib/utils/web3-types/sui-web3-pure.js

@@ -5,8 +5,6 @@ const common_web3_pure_1 = require("./common-web3-pure");
 const core_1 = require("@cryptorubic/core");
 const bignumber_js_1 = require("bignumber.js");
 class SuiWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
-    nativeTokenAddress = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
-    emptyAddress = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
     static compareAddress(addressA, addressB) {
         const pureAddressA = addressA.split(':')[0];
         const pureAddressB = addressB.split(':')[0];
@@ -22,6 +20,8 @@ class SuiWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
         super({
             regex: /(^0[xX][a-fA-F0-9]{0,64}::[a-zA-Z0-9_]*::[A-Z0-9_]*$)|(^0[xX][a-fA-F0-9]{64}$)/
         });
+        this.nativeTokenAddress = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
+        this.emptyAddress = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
     }
 }
 exports.SuiWeb3Pure = SuiWeb3Pure;

package/src/lib/adapter/adapters/abstract-adapter.d.ts

@@ -1,23 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { ICustomLogger, Token, TokenAmount, BlockchainName, PriceTokenAmount } from '@cryptorubic/core';
-export declare abstract class AbstractAdapter<P, W, B extends BlockchainName> {
-    protected readonly logger?: ICustomLogger;
-    protected readonly blockchain: B;
-    private _public;
-    protected set public(value: P | null);
-    get public(): P;
-    private _wallet;
-    set wallet(value: W | null);
-    get wallet(): W;
-    private _walletAddress;
-    set walletAddress(value: string | null);
-    get walletAddress(): string;
-    protected constructor(blockchain: B, logger?: ICustomLogger);
-    abstract checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
-    abstract callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<BlockchainName>[]>;
-    needPreswapAction(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string | BigNumber): Promise<boolean>;
-    handlePreswap(contractAddress: string, walletAddress: string, tokenAmount: TokenAmount): Promise<void>;
-    abstract read<T>(...args: unknown[]): Promise<T>;
-    abstract write(...args: unknown[]): Promise<string>;
-    static getRandomBytes(bytes: number): string;
-}

package/src/lib/adapter/adapters/abstract-adapter.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractAdapter = void 0;
-const viem_1 = require("viem");
-class AbstractAdapter {
-    logger;
-    blockchain;
-    _public = null;
-    set public(value) {
-        this._public = value;
-    }
-    get public() {
-        if (!this._public) {
-            const msg = 'Trying to access undefined client';
-            this.logger?.customLog(msg);
-            throw new Error(msg);
-        }
-        return this._public;
-    }
-    _wallet = null;
-    set wallet(value) {
-        this._wallet = value;
-    }
-    get wallet() {
-        if (!this._wallet) {
-            const msg = 'Trying to access undefined client';
-            this.logger?.customLog(msg);
-            throw new Error(msg);
-        }
-        return this._wallet;
-    }
-    _walletAddress = null;
-    set walletAddress(value) {
-        this._walletAddress = value;
-    }
-    get walletAddress() {
-        if (!this._walletAddress) {
-            const msg = 'Trying to access undefined walletAddress';
-            this.logger?.customLog(msg);
-            throw new Error(msg);
-        }
-        return this._walletAddress;
-    }
-    constructor(blockchain, logger) {
-        this.blockchain = blockchain;
-        if (logger) {
-            this.logger = logger;
-        }
-    }
-    needPreswapAction(token, contractAddress, walletAddress, amount) {
-        return Promise.resolve(false);
-    }
-    handlePreswap(contractAddress, walletAddress, tokenAmount) {
-        return Promise.resolve();
-    }
-    static getRandomBytes(bytes) {
-        const randomBytes = crypto.getRandomValues(new Uint8Array(bytes));
-        return (0, viem_1.bytesToHex)(randomBytes);
-    }
-}
-exports.AbstractAdapter = AbstractAdapter;

package/src/lib/adapter/adapters/bitcoin-adapter.d.ts

@@ -1,18 +0,0 @@
-import { BitcoinBlockchainName, BlockchainName, HttpClient, ICustomLogger, PriceTokenAmount, Token, TokenAmount } from '@cryptorubic/core';
-import BigNumber from 'bignumber.js';
-import { AbstractAdapter } from './abstract-adapter';
-import { BasicTransactionOptions } from './models/basic-transaction-options';
-import { BtcWallet } from './models/btc-wallet-provider';
-export declare class BitcoinAdapter extends AbstractAdapter<BtcWallet, BtcWallet, BitcoinBlockchainName> {
-    private readonly httpClient;
-    constructor(httpClient: HttpClient, logger?: ICustomLogger);
-    getBalance(userAddress: string): Promise<BigNumber>;
-    getPublicKey(userAddress: string): Promise<string | null>;
-    checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
-    callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<BlockchainName>[]>;
-    read<T>(args: unknown): Promise<T>;
-    write(args: unknown): Promise<string>;
-    getPublicKeyFromWallet(): Promise<string>;
-    transfer(recipient: string, amount: string, fromAddress: string, memo?: string, options?: BasicTransactionOptions): Promise<string>;
-    sendPsbtTransaction(psbt: string, userAddress: string, inputIndexes: number[], options?: BasicTransactionOptions): Promise<string>;
-}

package/src/lib/adapter/adapters/models/adapter-factory-params.d.ts

@@ -1,7 +0,0 @@
-import { HttpClient, ICustomLogger } from '@cryptorubic/core';
-import { TonAdapterConfig } from './ton-adapter-config';
-export interface AdaptersFactoryParams {
-    tonParams: TonAdapterConfig;
-    httpClient?: HttpClient;
-    createLogger?: (label: string) => ICustomLogger;
-}

package/src/lib/adapter/adapters/sui-adapter.d.ts

@@ -1,17 +0,0 @@
-import { Abi, MulticallResponse, MulticallParameters } from 'viem';
-import { AbstractAdapter } from './abstract-adapter';
-import { ICustomLogger, PriceTokenAmount, SuiBlockchainName, Token, TokenAmount } from '@cryptorubic/core';
-import { EvmTransactionConfig } from '../../utils/models/evm-transaction-config';
-import { SuiClient } from '@mysten/sui/client';
-import BigNumber from 'bignumber.js';
-export declare class SuiAdapter extends AbstractAdapter<SuiClient, SuiClient, SuiBlockchainName> {
-    constructor(rpcList: string[], logger?: ICustomLogger);
-    read<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
-    write<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
-    multicallByContract<T>(_contracts: MulticallParameters, _allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
-    multicallByAddress<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[][], _allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
-    simulateTransaction(_config: EvmTransactionConfig, _from: string): Promise<void>;
-    callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<SuiBlockchainName>[]>;
-    checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
-    getBalance(userAddress: string, tokenAddress: string): Promise<BigNumber>;
-}

package/src/lib/adapter/adapters/ton-adapter.d.ts

@@ -1,22 +0,0 @@
-import { BlockchainName, HttpClient, ICustomLogger, PriceTokenAmount, Token, TokenAmount, TonBlockchainName } from '@cryptorubic/core';
-import { Address, TonClient } from '@ton/ton';
-import { TonApiParseAddressResp } from './models/tonapi-models';
-import { TonAdapterConfig } from './models/ton-adapter-config';
-import BigNumber from 'bignumber.js';
-import { TonTransactionConfig } from '../../utils/models/ton-transaction-config';
-import { AbstractAdapter } from './abstract-adapter';
-export declare class TonAdapter extends AbstractAdapter<TonClient, TonClient, TonBlockchainName> {
-    private readonly tonApi;
-    readonly tonClient: TonClient;
-    constructor(httpClient: HttpClient, config: TonAdapterConfig, logger?: ICustomLogger);
-    callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<BlockchainName>[]>;
-    read<T>(args: unknown): Promise<T>;
-    write(args: unknown): Promise<string>;
-    getAllFormatsOfAddress(walletAddress: string): Promise<TonApiParseAddressResp>;
-    getWalletAddress(address: Address, contractAddress: Address): Promise<Address>;
-    checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
-    getBalance(walletAddress: string, tokenAddress?: string): Promise<BigNumber>;
-    getTransferEncodedConfig(tokenAddress: string, walletAddress: string, receiver: string, amount: string): Promise<TonTransactionConfig>;
-    private getTransferNativeConfig;
-    private getTransferJettonConfig;
-}

package/src/lib/utils/models/solana-transaction-config.d.ts

@@ -1,6 +0,0 @@
-type Base64String = `AQA${string}`;
-export interface SolanaTxConfig {
-    data: Base64String;
-    walletAddress: string;
-}
-export {};