@layerswap/widget 0.1.4 → 0.1.14

package/dist/lib/wallets/paradex/Authorize/Ethereum.js

@@ -1,23 +1,24 @@
-import * as Paradex from "../lib";
-import AppSettings from '../../../AppSettings';
-export default async function AuhorizeEthereum(ethersSigner) {
-    const environment = AppSettings.ApiVersion === 'sandbox' ? 'testnet' : 'prod';
-    const config = await Paradex.Config.fetchConfig(environment);
-    const paraclearProvider = new Paradex.ParaclearProvider.DefaultProvider(config);
-    function ethersSignerAdapter(signer) {
-        return {
-            async signTypedData(typedData) {
-                return await signer._signTypedData(typedData.domain, typedData.types, typedData.message);
-            },
-        };
-    }
-    const signer = ethersSignerAdapter(ethersSigner);
-    if (!signer)
-        throw new Error('Signer not found');
-    const paradexAccount = await Paradex.Account.fromEthSigner({
-        provider: paraclearProvider,
-        config,
-        signer: signer,
-    });
-    return paradexAccount;
-}
+// import { providers } from 'ethers'
+// import * as Paradex from "../lib";
+// import { TypedData } from '../lib/types';
+// import AppSettings from '../../../AppSettings';
+// export default async function AuhorizeEthereum(ethersSigner: providers.JsonRpcSigner) {
+//     const environment = AppSettings.ApiVersion === 'sandbox' ? 'testnet' : 'prod'
+//     const config = await Paradex.Config.fetchConfig(environment);
+//     const paraclearProvider = new Paradex.ParaclearProvider.DefaultProvider(config);
+//     function ethersSignerAdapter(signer: typeof ethersSigner) {
+//         return {
+//             async signTypedData(typedData: TypedData) {
+//                 return await signer!._signTypedData(typedData.domain, typedData.types, typedData.message);
+//             },
+//         };
+//     }
+//     const signer = ethersSignerAdapter(ethersSigner);
+//     if (!signer) throw new Error('Signer not found');
+//     const paradexAccount = await Paradex.Account.fromEthSigner({
+//         provider: paraclearProvider,
+//         config,
+//         signer: signer,
+//     });
+//     return paradexAccount
+// }

package/dist/lib/wallets/paradex/Authorize/Starknet.d.ts

@@ -1,2 +0,0 @@
-import { AccountInterface } from 'starknet';
-export declare function AuthorizeStarknet(starknetAccount: AccountInterface): Promise<import("../lib/account").Account>;

package/dist/lib/wallets/paradex/Authorize/Starknet.js

@@ -1,13 +1,14 @@
-import * as Paradex from "../lib";
-import AppSettings from '../../../AppSettings';
-export async function AuthorizeStarknet(starknetAccount) {
-    const config = await Paradex.Config.fetchConfig(AppSettings.ApiVersion === "sandbox" ? 'testnet' : 'prod'); ///TODO: check environemnt may be mainnet
-    const paraclearProvider = new Paradex.ParaclearProvider.DefaultProvider(config);
-    const snAccount = starknetAccount;
-    const paradexAccount = await Paradex.Account.fromStarknetAccount({
-        provider: paraclearProvider,
-        config,
-        account: snAccount,
-    });
-    return paradexAccount;
-}
+// import { AccountInterface } from 'starknet';
+// import * as Paradex from "../lib";
+// import AppSettings from '../../../AppSettings';
+// export async function AuthorizeStarknet(starknetAccount: AccountInterface) {
+//     const config = await Paradex.Config.fetchConfig(AppSettings.ApiVersion === "sandbox" ? 'testnet' : 'prod'); ///TODO: check environemnt may be mainnet
+//     const paraclearProvider = new Paradex.ParaclearProvider.DefaultProvider(config);
+//     const snAccount = starknetAccount
+//     const paradexAccount = await Paradex.Account.fromStarknetAccount({
+//         provider: paraclearProvider,
+//         config,
+//         account: snAccount,
+//     });
+//     return paradexAccount
+// }

package/dist/lib/wallets/paradex/lib/account.d.ts

@@ -1,28 +0,0 @@
-import * as Starknet from 'starknet';
-import type { ParadexConfig } from './config';
-import * as ethereumSigner from './ethereum-signer';
-export interface Account extends Starknet.Account {
-}
-interface FromEthSignerParams {
-    readonly provider: Starknet.ProviderOptions | Starknet.ProviderInterface;
-    readonly config: ParadexConfig;
-    readonly signer: ethereumSigner.EthereumSigner;
-}
-/**
- * Generates a Paradex account from an Ethereum wallet.
- * @returns The generated Paradex account.
- */
-export declare function fromEthSigner({ provider, config, signer, }: FromEthSignerParams): Promise<Account>;
-interface FromStarknetAccountParams {
-    /** Paradex chain provider */
-    readonly provider: Starknet.ProviderOptions | Starknet.ProviderInterface;
-    readonly config: ParadexConfig;
-    readonly account: Starknet.AccountInterface;
-    readonly starknetProvider?: Starknet.ProviderInterface;
-}
-/**
- * Generates a Paradex account from a Starknet signer.
- * @returns The generated Paradex account.
- */
-export declare function fromStarknetAccount({ provider, config, account, starknetProvider, }: FromStarknetAccountParams): Promise<Account>;
-export {};

package/dist/lib/wallets/paradex/lib/account.js

@@ -1,53 +1,102 @@
-import { keyDerivation } from '@starkware-industries/starkware-crypto-utils';
-import * as Starknet from 'starknet';
-import * as ethereumSigner from './ethereum-signer';
-import * as starknetSigner from './starknet-signer';
-/**
- * Generates a Paradex account from an Ethereum wallet.
- * @returns The generated Paradex account.
- */
-export async function fromEthSigner({ provider, config, signer, }) {
-    const starkKeyTypedData = ethereumSigner.buildEthereumStarkKeyTypedData(config.ethereumChainId);
-    const seed = await signer.signTypedData(starkKeyTypedData);
-    const privateKey = keyDerivation.getPrivateKeyFromEthSignature(seed);
-    const publicKey = keyDerivation.privateToStarkKey(privateKey);
-    const address = generateAccountAddress({
-        publicKey: `0x${publicKey}`,
-        accountClassHash: config.paraclearAccountHash,
-        accountProxyClassHash: config.paraclearAccountProxyHash,
-    });
-    return new Starknet.Account(provider, address, `0x${privateKey}`);
-}
-/**
- * Generates a Paradex account from a Starknet signer.
- * @returns The generated Paradex account.
- */
-export async function fromStarknetAccount({ provider, config, account, starknetProvider, }) {
-    const starkKeyTypedData = starknetSigner.buildStarknetStarkKeyTypedData(config.starknetChainId);
-    const accountSupport = await starknetSigner.getAccountSupport(account, starknetProvider ??
-        starknetSigner.getPublicProvider(config.starknetChainId));
-    const signature = await account.signMessage(starkKeyTypedData);
-    const seed = accountSupport.getSeedFromSignature(signature);
-    const [privateKey, publicKey] = await starknetSigner.getStarkKeypairFromStarknetSignature(seed);
-    const address = generateAccountAddress({
-        publicKey: `0x${publicKey}`,
-        accountClassHash: config.paraclearAccountHash,
-        accountProxyClassHash: config.paraclearAccountProxyHash,
-    });
-    return new Starknet.Account(provider, address, `0x${privateKey}`);
-}
-/**
- * Generates an account address based on the account contract and public key.
- */
-function generateAccountAddress({ accountClassHash, accountProxyClassHash, publicKey, }) {
-    const callData = Starknet.CallData.compile({
-        implementation: accountClassHash,
-        selector: Starknet.hash.getSelectorFromName('initialize'),
-        calldata: Starknet.CallData.compile({
-            signer: publicKey,
-            guardian: '0',
-        }),
-    });
-    const address = Starknet.hash.calculateContractAddressFromHash(publicKey, accountProxyClassHash, callData, 0);
-    return address;
-}
+// import { keyDerivation } from '@starkware-industries/starkware-crypto-utils';
+// import * as Starknet from 'starknet';
+// import type { ParadexConfig } from './config';
+// import * as ethereumSigner from './ethereum-signer';
+// import * as starknetSigner from './starknet-signer';
+// import type { Hex } from './types';
+// export interface Account extends Starknet.Account {}
+// interface FromEthSignerParams {
+//   readonly provider: Starknet.ProviderOptions | Starknet.ProviderInterface;
+//   readonly config: ParadexConfig;
+//   readonly signer: ethereumSigner.EthereumSigner;
+// }
+// /**
+//  * Generates a Paradex account from an Ethereum wallet.
+//  * @returns The generated Paradex account.
+//  */
+// export async function fromEthSigner({
+//   provider,
+//   config,
+//   signer,
+// }: FromEthSignerParams): Promise<Account> {
+//   const starkKeyTypedData = ethereumSigner.buildEthereumStarkKeyTypedData(
+//     config.ethereumChainId,
+//   );
+//   const seed = await signer.signTypedData(starkKeyTypedData);
+//   const privateKey = keyDerivation.getPrivateKeyFromEthSignature(seed);
+//   const publicKey = keyDerivation.privateToStarkKey(privateKey);
+//   const address = generateAccountAddress({
+//     publicKey: `0x${publicKey}`,
+//     accountClassHash: config.paraclearAccountHash,
+//     accountProxyClassHash: config.paraclearAccountProxyHash,
+//   });
+//   return new Starknet.Account(provider, address, `0x${privateKey}`);
+// }
+// interface FromStarknetAccountParams {
+//   /** Paradex chain provider */
+//   readonly provider: Starknet.ProviderOptions | Starknet.ProviderInterface;
+//   readonly config: ParadexConfig;
+//   readonly account: Starknet.AccountInterface;
+//   readonly starknetProvider?: Starknet.ProviderInterface;
+// }
+// /**
+//  * Generates a Paradex account from a Starknet signer.
+//  * @returns The generated Paradex account.
+//  */
+// export async function fromStarknetAccount({
+//   provider,
+//   config,
+//   account,
+//   starknetProvider,
+// }: FromStarknetAccountParams): Promise<Account> {
+//   const starkKeyTypedData = starknetSigner.buildStarknetStarkKeyTypedData(
+//     config.starknetChainId,
+//   );
+//   const accountSupport = await starknetSigner.getAccountSupport(
+//     account,
+//     starknetProvider ??
+//       starknetSigner.getPublicProvider(config.starknetChainId),
+//   );
+//   const signature = await account.signMessage(starkKeyTypedData);
+//   const seed = accountSupport.getSeedFromSignature(signature);
+//   const [privateKey, publicKey] =
+//     await starknetSigner.getStarkKeypairFromStarknetSignature(seed);
+//   const address = generateAccountAddress({
+//     publicKey: `0x${publicKey}`,
+//     accountClassHash: config.paraclearAccountHash,
+//     accountProxyClassHash: config.paraclearAccountProxyHash,
+//   });
+//   return new Starknet.Account(provider, address, `0x${privateKey}`);
+// }
+// interface GenerateAccountAddressParams {
+//   /** The hash of the account contract in hex format */
+//   readonly accountClassHash: Hex;
+//   /** The hash of the account proxy contract in hex format */
+//   readonly accountProxyClassHash: Hex;
+//   /** The public key of the account in hex format */
+//   readonly publicKey: Hex;
+// }
+// /**
+//  * Generates an account address based on the account contract and public key.
+//  */
+// function generateAccountAddress({
+//   accountClassHash,
+//   accountProxyClassHash,
+//   publicKey,
+// }: GenerateAccountAddressParams): Hex {
+//   const callData = Starknet.CallData.compile({
+//     implementation: accountClassHash,
+//     selector: Starknet.hash.getSelectorFromName('initialize'),
+//     calldata: Starknet.CallData.compile({
+//       signer: publicKey,
+//       guardian: '0',
+//     }),
+//   });
+//   const address = Starknet.hash.calculateContractAddressFromHash(
+//     publicKey,
+//     accountProxyClassHash,
+//     callData,
+//     0,
+//   );
+//   return address as Hex;
+// }

package/dist/lib/wallets/paradex/lib/index.d.ts

@@ -1,24 +0,0 @@
-import * as _Account from './account';
-import * as _Config from './config';
-import * as _Signer from './ethereum-signer';
-import * as _ParaclearProvider from './paraclear-provider';
-import * as _Paraclear from './paraclear';
-export declare const Config: {
-    fetchConfig: typeof _Config.fetchConfig;
-};
-export declare const Account: {
-    fromEthSigner: typeof _Account.fromEthSigner;
-    fromStarknetAccount: typeof _Account.fromStarknetAccount;
-};
-export declare const Signer: {
-    ethersSignerAdapter: typeof _Signer.ethersSignerAdapter;
-};
-export declare const ParaclearProvider: {
-    DefaultProvider: typeof _ParaclearProvider.DefaultProvider;
-};
-export declare const Paraclear: {
-    getTokenBalance: typeof _Paraclear.getTokenBalance;
-    getSocializedLossFactor: typeof _Paraclear.getSocializedLossFactor;
-    getReceivableAmount: typeof _Paraclear.getReceivableAmount;
-    withdraw: typeof _Paraclear.withdraw;
-};

package/dist/lib/wallets/paradex/lib/index.js

@@ -1,20 +1,20 @@
-import * as _Account from './account';
-import * as _Config from './config';
-import * as _Signer from './ethereum-signer';
-import * as _ParaclearProvider from './paraclear-provider';
-import * as _Paraclear from './paraclear';
-export const Config = { fetchConfig: _Config.fetchConfig };
-export const Account = {
-    fromEthSigner: _Account.fromEthSigner,
-    fromStarknetAccount: _Account.fromStarknetAccount,
-};
-export const Signer = { ethersSignerAdapter: _Signer.ethersSignerAdapter };
-export const ParaclearProvider = {
-    DefaultProvider: _ParaclearProvider.DefaultProvider,
-};
-export const Paraclear = {
-    getTokenBalance: _Paraclear.getTokenBalance,
-    getSocializedLossFactor: _Paraclear.getSocializedLossFactor,
-    getReceivableAmount: _Paraclear.getReceivableAmount,
-    withdraw: _Paraclear.withdraw,
-};
+// import * as _Account from './account';
+// import * as _Config from './config';
+// import * as _Signer from './ethereum-signer';
+// import * as _ParaclearProvider from './paraclear-provider';
+// import * as _Paraclear from './paraclear';
+// export const Config = { fetchConfig: _Config.fetchConfig };
+// export const Account = {
+//   fromEthSigner: _Account.fromEthSigner,
+//   fromStarknetAccount: _Account.fromStarknetAccount,
+// };
+// export const Signer = { ethersSignerAdapter: _Signer.ethersSignerAdapter };
+// export const ParaclearProvider = {
+//   DefaultProvider: _ParaclearProvider.DefaultProvider,
+// };
+// export const Paraclear = {
+//   getTokenBalance: _Paraclear.getTokenBalance,
+//   getSocializedLossFactor: _Paraclear.getSocializedLossFactor,
+//   getReceivableAmount: _Paraclear.getReceivableAmount,
+//   withdraw: _Paraclear.withdraw,
+// };

package/dist/lib/wallets/paradex/lib/paraclear-provider.d.ts

@@ -1,6 +0,0 @@
-import * as Starknet from 'starknet';
-import type { ParadexConfig } from './config';
-export declare class DefaultProvider extends Starknet.RpcProvider {
-    constructor(config: ParadexConfig);
-}
-export type ParaclearProvider = DefaultProvider;

package/dist/lib/wallets/paradex/lib/paraclear-provider.js

@@ -1,9 +1,13 @@
-import * as Starknet from 'starknet';
-export class DefaultProvider extends Starknet.RpcProvider {
-    constructor(config) {
-        super({
-            nodeUrl: config.paradexFullNodeRpcUrl,
-            chainId: Starknet.shortString.encodeShortString(config.paradexChainId),
-        });
-    }
-}
+// import * as Starknet from 'starknet';
+// import type { ParadexConfig } from './config';
+// export class DefaultProvider extends Starknet.RpcProvider {
+//   constructor(config: ParadexConfig) {
+//     super({
+//       nodeUrl: config.paradexFullNodeRpcUrl,
+//       chainId: Starknet.shortString.encodeShortString(
+//         config.paradexChainId,
+//       ) as Starknet.RpcProviderOptions['chainId'],
+//     });
+//   }
+// }
+// export type ParaclearProvider = DefaultProvider;

package/dist/lib/wallets/paradex/lib/paraclear.d.ts

@@ -1,137 +0,0 @@
-import * as Starknet from 'starknet';
-import type { Account } from './account';
-import type { ParadexConfig } from './config';
-import type { ParaclearProvider } from './paraclear-provider';
-import type { Hex } from './types';
-interface GetBalanceParams {
-    readonly config: ParadexConfig;
-    readonly provider: Pick<ParaclearProvider, 'callContract'>;
-    /**
-     * Account to get the balance for.
-     */
-    readonly account: Pick<Account, 'address'>;
-    /**
-     * Token symbol.
-     * @example 'USDC'
-     */
-    readonly token: string;
-}
-interface GetBalanceResult {
-    /**
-     * Token balance as a decimal string.
-     * @example '100.45'
-     * @example '45.2'
-     */
-    readonly size: string;
-}
-/**
- * Get the Paraclear balance of the given token for the given account.
- */
-export declare function getTokenBalance(params: GetBalanceParams): Promise<GetBalanceResult>;
-interface GetSocializedLossFactorParams {
-    readonly config: ParadexConfig;
-    readonly provider: Pick<ParaclearProvider, 'callContract'>;
-}
-interface GetSocializedLossFactorResult {
-    readonly socializedLossFactor: string;
-}
-/**
- * Socialized losses happen when Paradex Insurance Fund is bankrupt
- * due to large amounts of unprofitable liquidations. When socialized
- * losses are active, (socialized loss factor > 0), the amount that
- * the user will receive when withdrawing will be smaller than the
- * requested amount.
- */
-export declare function getSocializedLossFactor(params: GetSocializedLossFactorParams): Promise<GetSocializedLossFactorResult>;
-interface GetReceivableAmountParams {
-    readonly config: ParadexConfig;
-    readonly provider: Pick<ParaclearProvider, 'callContract'>;
-    /**
-     * Token symbol.
-     * @example 'USDC'
-     */
-    readonly token: string;
-    /**
-     * Amount of to withdraw from Paradex, as a decimal string.
-     * The receivable amount will be calculated based on this amount and
-     * can be less than the requested amount if socialized loss is active.
-     */
-    readonly amount: string;
-}
-interface GetReceivableAmountResult {
-    /**
-     * Amount that will be received from Paradex, after socialized loss,
-     * if applicable, after a withdrawal of the given amount parameter.
-     * Decimal string.
-     * @example '99.45'
-     */
-    readonly receivableAmount: string;
-    /**
-     * The receivable amount, converted to be used in chain calls,
-     * using the Paraclear decimals.
-     * @example '9945000000'
-     */
-    readonly receivableAmountChain: string;
-    /**
-     * Socialized loss factor used to calculate the receivable amount.
-     * Decimal string.
-     * @example '0.05'
-     */
-    readonly socializedLossFactor: string;
-}
-/**
- * The receivable amount is calculated based on the current
- * socialized loss factor: amount * (1 - socializedLossFactor)
- *
- * If the socialized loss factor is 0, the receivable amount
- * will be equal to the requested amount.
- */
-export declare function getReceivableAmount(params: GetReceivableAmountParams): Promise<GetReceivableAmountResult>;
-interface WithdrawParams {
-    readonly config: ParadexConfig;
-    /**
-     * Account to withdraw from.
-     */
-    readonly account: Account;
-    /**
-     * Token symbol.
-     * @example 'USDC'
-     */
-    readonly token: string;
-    /**
-     * Amount to withdraw from Paradex.
-     * Note that this amount can be less than the amount that will be
-     * received if socialized loss is active. Use {@link getReceivableAmount}
-     * to calculate the amount that will be received.
-     * Decimal string.
-     * @example '100.45'
-     * @example '45.2'
-     */
-    readonly amount: string;
-    /**
-     * Call to transfer funds to the bridge. This transaction will be called
-     * as the second transaction of the withdrawal transactions batch.
-     *
-     * The bridge call must be made with the receivable amount calculated
-     * using {@link getReceivableAmount}.
-     */
-    readonly bridgeCall: Starknet.Call | readonly Starknet.Call[];
-}
-interface TransactionResult {
-    readonly hash: Hex;
-}
-/**
- * Withdraw funds from Paraclear for the given account.
- *
- * Automatically make a batch transaction with `initiate_withdrawal`
- * call to the Paraclear contract along with the transaction passed
- * as `params.bridgeCall` The batch call is atomic. If either of
- * the transactions fail, the entire batch gets reverted.
- *
- * If socialized loss is active, the bridge call must be constructed
- * with an amount that accounts for the loss. To calculate that amount,
- * use {@link getReceivableAmount}. Failing to do so can result in a
- * failed withdrawal.
- */
-export declare function withdraw(params: WithdrawParams): Promise<TransactionResult>;
-export {};