@layerswap/widget 0.1.4 → 0.1.14

package/dist/lib/balances/providers/tonBalanceProvider.js

@@ -1,100 +1,104 @@
-import { datadogRum } from "@datadog/browser-rum";
-import formatAmount from "../../formatAmount";
-import KnownInternalNames from "../../knownIds";
-import retryWithExponentialBackoff from "../../retry";
-import tonClient from "../../wallets/ton/client";
-import { insertIfNotExists } from "./helpers";
-export class TonBalanceProvider {
-    constructor() {
-        this.fetchBalance = async (address, network) => {
-            let balances = [];
-            const tokens = insertIfNotExists(network.tokens || [], network.token);
-            for (const token of tokens) {
-                try {
-                    const balance = await resolveBalance({ network, address, token });
-                    if (!balance)
-                        return;
-                    balances = [
-                        ...balances,
-                        balance,
-                    ];
-                }
-                catch (e) {
-                    console.log(e);
-                }
-            }
-            return balances;
-        };
-    }
-    supportsNetwork(network) {
-        return KnownInternalNames.Networks.TONMainnet.includes(network.name);
-    }
-}
-export const resolveBalance = async ({ address, network, token }) => {
-    if (token.contract) {
-        const res = await getJettonBalance({ network, token, address });
-        return res;
-    }
-    else {
-        const res = await getNativeAssetBalance({ network, token, address });
-        return res;
-    }
-};
-const getNativeAssetBalance = async ({ network, token, address }) => {
-    try {
-        const { Address } = await import("@ton/ton");
-        const getBalance = async () => {
-            return await tonClient.getBalance(Address.parse(address));
-        };
-        const tonBalance = await retryWithExponentialBackoff(getBalance);
-        return ({
-            network: network.name,
-            token: token.symbol,
-            amount: formatAmount(tonBalance.toString(), Number(token?.decimals)),
-            request_time: new Date().toJSON(),
-            decimals: Number(token?.decimals),
-            isNativeCurrency: false,
-        });
-    }
-    catch (e) {
-        const error = new Error(e);
-        error.name = "TonNativeAssetBalanceError";
-        error.cause = e;
-        datadogRum.addError(error);
-        return null;
-    }
-};
-const getJettonBalance = async ({ network, token, address }) => {
-    try {
-        const { JettonMaster, JettonWallet, Address } = await import("@ton/ton");
-        const jettonMasterAddress = Address.parse(token.contract);
-        const userAddress = Address.parse(address);
-        const jettonMaster = tonClient.open(JettonMaster.create(jettonMasterAddress));
-        const getJettonAddress = async () => {
-            return await jettonMaster.getWalletAddress(userAddress);
-        };
-        const jettonAddress = await retryWithExponentialBackoff(getJettonAddress);
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-        const jettonWallet = JettonWallet.create(jettonAddress);
-        const getBalance = async () => {
-            return await jettonWallet.getBalance(tonClient.provider(jettonAddress));
-        };
-        const jettonBalance = await retryWithExponentialBackoff(getBalance);
-        const balance = {
-            network: network.name,
-            token: token.symbol,
-            amount: formatAmount(Number(BigInt(jettonBalance)), token.decimals),
-            request_time: new Date().toJSON(),
-            decimals: token.decimals,
-            isNativeCurrency: false,
-        };
-        return balance;
-    }
-    catch (e) {
-        const error = new Error(e);
-        error.name = "TonJettonBalanceError";
-        error.cause = e;
-        datadogRum.addError(error);
-        return null;
-    }
-};
+// import { datadogRum } from "@datadog/browser-rum";
+// import { Balance } from "../../../Models/Balance";
+// import { Network, NetworkWithTokens, Token } from "../../../Models/Network";
+// import formatAmount from "../../formatAmount";
+// import KnownInternalNames from "../../knownIds";
+// import retryWithExponentialBackoff from "../../retry";
+// import tonClient from "../../wallets/ton/client";
+// import { insertIfNotExists } from "./helpers";
+// export class TonBalanceProvider {
+//     supportsNetwork(network: NetworkWithTokens): boolean {
+//         return KnownInternalNames.Networks.TONMainnet.includes(network.name)
+//     }
+//     fetchBalance = async (address: string, network: NetworkWithTokens) => {
+//         let balances: Balance[] = []
+//         const tokens = insertIfNotExists(network.tokens || [], network.token)
+//         for (const token of tokens) {
+//             try {
+//                 const balance = await resolveBalance({ network, address, token })
+//                 if (!balance) return
+//                 balances = [
+//                     ...balances,
+//                     balance,
+//                 ]
+//             }
+//             catch (e) {
+//                 console.log(e)
+//             }
+//         }
+//         return balances
+//     }
+// }
+// export const resolveBalance = async ({ address, network, token }: {
+//     network: Network,
+//     token: Token,
+//     address: string
+// }
+// ) => {
+//     if (token.contract) {
+//         const res = await getJettonBalance({ network, token, address })
+//         return res
+//     }
+//     else {
+//         const res = await getNativeAssetBalance({ network, token, address })
+//         return res
+//     }
+// }
+// const getNativeAssetBalance = async ({ network, token, address }: { network: Network, token: Token, address: string }) => {
+//     try {
+//         const { Address } = await import("@ton/ton");
+//         const getBalance = async () => {
+//             return await tonClient.getBalance(Address.parse(address))
+//         }
+//         const tonBalance = await retryWithExponentialBackoff(getBalance)
+//         return ({
+//             network: network.name,
+//             token: token.symbol,
+//             amount: formatAmount(tonBalance.toString(), Number(token?.decimals)),
+//             request_time: new Date().toJSON(),
+//             decimals: Number(token?.decimals),
+//             isNativeCurrency: false,
+//         })
+//     }
+//     catch (e) {
+//         const error = new Error(e)
+//         error.name = "TonNativeAssetBalanceError"
+//         error.cause = e
+//         datadogRum.addError(error);
+//         return null;
+//     }
+// }
+// const getJettonBalance = async ({ network, token, address }: { network: Network, token: Token, address: string }) => {
+//     try {
+//         const { JettonMaster, JettonWallet, Address } = await import("@ton/ton");
+//         const jettonMasterAddress = Address.parse(token.contract!)
+//         const userAddress = Address.parse(address)
+//         const jettonMaster = tonClient.open(JettonMaster.create(jettonMasterAddress))
+//         const getJettonAddress = async () => {
+//             return await jettonMaster.getWalletAddress(userAddress)
+//         }
+//         const jettonAddress = await retryWithExponentialBackoff(getJettonAddress)
+//         await new Promise((resolve) => setTimeout(resolve, 1000))
+//         const jettonWallet = JettonWallet.create(jettonAddress)
+//         const getBalance = async () => {
+//             return await jettonWallet.getBalance(tonClient.provider(jettonAddress))
+//         }
+//         const jettonBalance = await retryWithExponentialBackoff(getBalance)
+//         const balance = {
+//             network: network.name,
+//             token: token.symbol,
+//             amount: formatAmount(Number(BigInt(jettonBalance)), token.decimals),
+//             request_time: new Date().toJSON(),
+//             decimals: token.decimals,
+//             isNativeCurrency: false,
+//         }
+//         return balance
+//     }
+//     catch (e) {
+//         const error = new Error(e)
+//         error.name = "TonJettonBalanceError"
+//         error.cause = e
+//         datadogRum.addError(error);
+//         return null;
+//     }
+// }

package/dist/lib/balances/providers/tronBalanceResolver.js

@@ -1,4 +1,3 @@
-import { datadogRum } from "@datadog/browser-rum";
 import formatAmount from "../../formatAmount";
 import KnownInternalNames from "../../knownIds";
 import { TronWeb } from 'tronweb';
@@ -56,7 +55,7 @@ const getNativeAssetBalance = async ({ network, token, address, provider }) => {
         const error = new Error(e);
         error.name = "TronNativeAssetBalanceError";
         error.cause = e;
-        datadogRum.addError(error);
+        // datadogRum.addError(error);
         return null;
     }
 };
@@ -82,7 +81,7 @@ const getTRC20Balance = async ({ network, token, address, provider }) => {
         const error = new Error(e);
         error.name = "TronTRC20BalanceError";
         error.cause = e;
-        datadogRum.addError(error);
+        // datadogRum.addError(error);
         return null;
     }
 };

package/dist/lib/fuels/common/FakeAccount.d.ts

@@ -1,24 +0,0 @@
-import type { Hash, Option } from './types';
-export interface FakeAccount {
-    generate: () => void;
-    getAddress: () => Option<string, Hash>;
-    getRawAddress: () => Uint8Array;
-    signMessage: (message: Option<string, Uint8Array, Hash>) => Promise<Option<string, Uint8Array, Hash>>;
-}
-export declare class EthereumFakeAccount implements FakeAccount {
-    private account;
-    constructor();
-    generate: () => void;
-    getAddress: () => Option<string, Hash>;
-    getRawAddress: () => Uint8Array;
-    signMessage: (message: Option<string, Uint8Array, Hash>) => Promise<Option<string, Uint8Array, Hash>>;
-}
-export declare class SolanaFakeAccount implements FakeAccount {
-    private keypair;
-    constructor();
-    generate: () => void;
-    getAddress: () => Option<string, Hash>;
-    getRawAddress: () => Uint8Array;
-    private getSmallTxId;
-    signMessage: (message: Option<string, Uint8Array, Hash>) => Promise<Option<string, Uint8Array, Hash>>;
-}

package/dist/lib/fuels/common/FakeAccount.js

@@ -1,36 +1,58 @@
-import { Keypair } from '@solana/web3.js';
-import nacl from 'tweetnacl';
-import { privateKeyToAccount } from 'viem/accounts';
-export class EthereumFakeAccount {
-    constructor() {
-        this.generate = () => {
-            this.account = privateKeyToAccount('0x0000000000000000000000000000000000000000000000000000000000000001');
-        };
-        this.getAddress = () => this.account.address;
-        this.getRawAddress = () => Buffer.from(this.account.address.slice(2), 'hex');
-        this.signMessage = (message) => {
-            return this.account.signMessage({
-                message: message,
-            });
-        };
-        this.generate();
-    }
-}
-export class SolanaFakeAccount {
-    constructor() {
-        this.generate = () => {
-            this.keypair = Keypair.generate();
-        };
-        this.getAddress = () => this.keypair.publicKey.toString();
-        this.getRawAddress = () => this.keypair.publicKey.toBytes();
-        this.getSmallTxId = (message) => {
-            const txIdNo0x = message.slice(2);
-            const idBytes = `${txIdNo0x.slice(0, 16)}${txIdNo0x.slice(-16)}`;
-            return new TextEncoder().encode(idBytes);
-        };
-        this.signMessage = (message) => {
-            return Promise.resolve(nacl.sign.detached(this.getSmallTxId(message), this.keypair.secretKey));
-        };
-        this.generate();
-    }
-}
+// import { Keypair } from '@solana/web3.js';
+// import nacl from 'tweetnacl';
+// import { type PrivateKeyAccount, privateKeyToAccount } from 'viem/accounts';
+// import type { Hash, Option } from './types';
+// export interface FakeAccount {
+//   generate: () => void;
+//   getAddress: () => Option<string, Hash>;
+//   getRawAddress: () => Uint8Array;
+//   signMessage: (
+//     message: Option<string, Uint8Array, Hash>,
+//   ) => Promise<Option<string, Uint8Array, Hash>>;
+// }
+// export class EthereumFakeAccount implements FakeAccount {
+//   private account!: PrivateKeyAccount;
+//   constructor() {
+//     this.generate();
+//   }
+//   generate = (): void => {
+//     this.account = privateKeyToAccount(
+//       '0x0000000000000000000000000000000000000000000000000000000000000001',
+//     );
+//   };
+//   getAddress = (): Option<string, Hash> => this.account.address;
+//   getRawAddress = (): Uint8Array =>
+//     Buffer.from(this.account.address.slice(2), 'hex');
+//   signMessage = (
+//     message: Option<string, Uint8Array, Hash>,
+//   ): Promise<Option<string, Uint8Array, Hash>> => {
+//     return this.account.signMessage({
+//       message: message as string,
+//     });
+//   };
+// }
+// export class SolanaFakeAccount implements FakeAccount {
+//   private keypair!: Keypair;
+//   constructor() {
+//     this.generate();
+//   }
+//   generate = (): void => {
+//     this.keypair = Keypair.generate();
+//   };
+//   getAddress = (): Option<string, Hash> => this.keypair.publicKey.toString();
+//   getRawAddress = (): Uint8Array => this.keypair.publicKey.toBytes();
+//   private getSmallTxId = (
+//     message: Option<string, Uint8Array, Hash>,
+//   ): Uint8Array => {
+//     const txIdNo0x = message.slice(2);
+//     const idBytes = `${txIdNo0x.slice(0, 16)}${txIdNo0x.slice(-16)}`;
+//     return new TextEncoder().encode(idBytes);
+//   };
+//   signMessage = (
+//     message: Option<string, Uint8Array, Hash>,
+//   ): Promise<Option<string, Uint8Array, Hash>> => {
+//     return Promise.resolve(
+//       nacl.sign.detached(this.getSmallTxId(message), this.keypair.secretKey),
+//     );
+//   };
+// }

package/dist/lib/fuels/common/PredicateConnector.d.ts

@@ -1,54 +0,0 @@
-import { type AbiMap, type Asset, type BytesLike, type ConnectorMetadata, FuelConnector, FuelConnectorEventTypes, type JsonAbi, type Network, type SelectNetworkArguments, type TransactionRequestLike, type Version } from 'fuels';
-import { PredicateFactory } from './PredicateFactory';
-import type { PredicateWalletAdapter } from './PredicateWalletAdapter';
-import type { ConnectorConfig, Maybe, MaybeAsync, PredicateConfig, PredicateVersion, PreparedTransaction, ProviderDictionary, SignedMessageCustomCurve } from './types';
-export declare abstract class PredicateConnector extends FuelConnector {
-    connected: boolean;
-    installed: boolean;
-    external: boolean;
-    events: typeof FuelConnectorEventTypes;
-    protected predicateAddress: string;
-    protected customPredicate: Maybe<PredicateConfig>;
-    protected predicateAccount: Maybe<PredicateFactory>;
-    protected subscriptions: Array<() => void>;
-    protected hasProviderSucceeded: boolean;
-    private _predicateVersions;
-    abstract name: string;
-    abstract metadata: ConnectorMetadata;
-    abstract sendTransaction(address: string, transaction: TransactionRequestLike): Promise<string>;
-    abstract connect(): Promise<boolean>;
-    abstract disconnect(): Promise<boolean>;
-    protected abstract configProviders(config: ConnectorConfig): MaybeAsync<void>;
-    protected abstract getWalletAdapter(): PredicateWalletAdapter;
-    protected abstract getPredicateVersions(): Record<string, PredicateVersion>;
-    protected abstract getAccountAddress(): MaybeAsync<Maybe<string>>;
-    protected abstract getProviders(): Promise<ProviderDictionary>;
-    protected abstract requireConnection(): MaybeAsync<void>;
-    protected abstract walletAccounts(): Promise<Array<string>>;
-    abstract signMessageCustomCurve(_message: string): Promise<SignedMessageCustomCurve>;
-    protected emitAccountChange(address: string, connected?: boolean): Promise<void>;
-    protected get predicateVersions(): Array<PredicateFactory>;
-    protected isAddressPredicate(b: BytesLike, walletAccount: string): boolean;
-    protected getCurrentUserPredicate(): Promise<Maybe<PredicateFactory>>;
-    protected getNewestPredicate(): Maybe<PredicateFactory>;
-    protected setupPredicate(): Promise<PredicateFactory>;
-    protected subscribe(listener: () => void): void;
-    protected prepareTransaction(address: string, transaction: TransactionRequestLike): Promise<PreparedTransaction>;
-    clearSubscriptions(): void;
-    ping(): Promise<boolean>;
-    version(): Promise<Version>;
-    isConnected(): Promise<boolean>;
-    accounts(): Promise<Array<string>>;
-    currentAccount(): Promise<string | null>;
-    networks(): Promise<Network[]>;
-    currentNetwork(): Promise<Network>;
-    signMessage(_address: string, _message: string): Promise<string>;
-    addAssets(_assets: Asset[]): Promise<boolean>;
-    addAsset(_asset: Asset): Promise<boolean>;
-    assets(): Promise<Array<Asset>>;
-    addNetwork(_networkUrl: string): Promise<boolean>;
-    selectNetwork(_network: SelectNetworkArguments): Promise<boolean>;
-    addAbi(_abiMap: AbiMap): Promise<boolean>;
-    getAbi(_contractId: string): Promise<JsonAbi>;
-    hasAbi(_contractId: string): Promise<boolean>;
-}