@layerswap/widget 0.1.18 → 1.0.0-alpha0.1

package/dist/lib/loopring/utils.d.ts

@@ -0,0 +1,76 @@
+import * as ethUtil from 'ethereumjs-util';
+import { OriginTransferRequestV3, ChainId, UpdateAccountRequestV3 } from './defs';
+export type EddsaKey = {
+    keyPair: {
+        publicKeyX: string;
+        publicKeyY: string;
+        secretKey: string;
+    };
+    formatedPx: string;
+    formatedPy: string;
+    sk: string;
+};
+export declare function generateKey(sig: string): EddsaKey;
+export declare const getEdDSASigWithPoseidon: (inputs: any, PrivateKey: string | undefined) => {
+    hash: any;
+    result: string;
+};
+export declare const genSigWithPadding: (PrivateKey: string | undefined, hash: any) => string;
+export declare function convertPublicKey2(pk: {
+    x: string;
+    y: string;
+}): ethUtil.BN;
+export declare function getUpdateAccountEcdsaTypedData(data: UpdateAccountRequestV3, chainId: ChainId): {
+    types: {
+        EIP712Domain: {
+            name: string;
+            type: string;
+        }[];
+        AccountUpdate: {
+            name: string;
+            type: string;
+        }[];
+    };
+    primaryType: string;
+    domain: {
+        name: string;
+        version: string;
+        chainId: ChainId;
+        verifyingContract: string;
+    };
+    message: any;
+};
+export declare function getTransferTypedData(data: OriginTransferRequestV3, chainId: ChainId): {
+    types: {
+        EIP712Domain: {
+            name: string;
+            type: string;
+        }[];
+        Transfer: {
+            name: string;
+            type: string;
+        }[];
+    };
+    primaryType: string;
+    domain: {
+        name: string;
+        version: string;
+        chainId: ChainId;
+        verifyingContract: string;
+    };
+    message: {
+        from: string;
+        to: string;
+        tokenID: string | number;
+        amount: string;
+        feeTokenID: string | number;
+        maxFee: string;
+        validUntil: number;
+        storageID: number;
+    };
+};
+export declare function get_EddsaSig_Transfer(request: OriginTransferRequestV3, eddsaKey: string): {
+    hash: any;
+    result: string;
+};
+export declare function getEdDSASig(method: string, basePath: string, api_url: string, requestInfo: any, PrivateKey: string | undefined): string;

package/dist/lib/loopring/utils.js

@@ -0,0 +1,230 @@
+import { BigNumber } from 'ethers';
+import { jubjub } from './jubjub';
+import { SignatureScheme } from './eddsa';
+import * as ethUtil from 'ethereumjs-util';
+import * as fm from './formatter';
+import { bnToBufWithFixedLength } from './poseidon/eddsa';
+import { field } from './field';
+import { PoseidonParams, permunation } from './permutation';
+import { EDDSAUtil } from './poseidon/EDDSAUtil';
+import BN from 'bn.js';
+import BigInteger from 'bignumber.js';
+import * as crypto from 'crypto-js';
+import { toBig, toHex } from './formatter';
+const SNARK_SCALAR_FIELD = new BigInteger('21888242871839275222246405745257275088548364400416034343698204186575808495617', 10);
+const generateKeyPair = (seed) => {
+    let bigInt = BigNumber.from(0);
+    for (let i = 0; i < seed.length; i++) {
+        const item = seed[i];
+        const itemBigInt = BigNumber.from(item);
+        const tmp = BigNumber.from("256").pow(BigNumber.from(i));
+        bigInt = bigInt.add(itemBigInt.mul(tmp));
+    }
+    const secretKey = bigInt.mod(jubjub.JUBJUB_L);
+    const copySecretKey = BigNumber.from(secretKey.toString());
+    const B = SignatureScheme.B();
+    const publicKey = B.mul(copySecretKey);
+    const keyPair = {
+        "publicKeyX": publicKey.x.n.toString(),
+        "publicKeyY": publicKey.y.n.toString(),
+        "secretKey": secretKey.toString()
+    };
+    return keyPair;
+};
+export function generateKey(sig) {
+    if (sig) {
+        const seedBuff = ethUtil.sha256(fm.toBuffer(sig));
+        const seed = BigNumber.from('0x' + seedBuff.toString('hex'));
+        const bitIntDataItems = bnToBufWithFixedLength(seed.toString(), 32);
+        const keyPair = generateKeyPair(bitIntDataItems);
+        const formatedPx = fm.formatEddsaKey(fm.toHex(fm.toBig(keyPair.publicKeyX)));
+        const formatedPy = fm.formatEddsaKey(fm.toHex(fm.toBig(keyPair.publicKeyY)));
+        const sk = toHex(toBig(keyPair.secretKey));
+        return {
+            keyPair,
+            formatedPx,
+            formatedPy,
+            sk,
+        };
+    }
+    else {
+        throw Error("No signature");
+    }
+}
+export const getEdDSASigWithPoseidon = (inputs, PrivateKey) => {
+    const p = field.SNARK_SCALAR_FIELD;
+    const poseidonParams = new PoseidonParams(p, inputs.length + 1, 6, 53, 'poseidon', BigNumber.from(5), null, null, 128);
+    let bigIntInputs;
+    bigIntInputs = [];
+    for (let i = 0; i < inputs.length; i++) {
+        const input = inputs[i];
+        bigIntInputs.push(BigNumber.from(input));
+    }
+    const hash = permunation.poseidon(bigIntInputs, poseidonParams);
+    return {
+        hash,
+        result: genSigWithPadding(PrivateKey, hash),
+    };
+};
+export const genSigWithPadding = (PrivateKey, hash) => {
+    const signature = EDDSAUtil.sign(PrivateKey, hash);
+    let signatureRx_Hex = fm.clearHexPrefix(fm.toHex(fm.toBN(signature.Rx)));
+    if (signatureRx_Hex.length < 64) {
+        const padding = new Array(64 - signatureRx_Hex.length).fill(0);
+        signatureRx_Hex = padding.join('').toString() + signatureRx_Hex;
+    }
+    let signatureRy_Hex = fm.clearHexPrefix(fm.toHex(fm.toBN(signature.Ry)));
+    if (signatureRy_Hex.length < 64) {
+        const padding = new Array(64 - signatureRy_Hex.length).fill(0);
+        signatureRy_Hex = padding.join('').toString() + signatureRy_Hex;
+    }
+    let signatureS_Hex = fm.clearHexPrefix(fm.toHex(fm.toBN(signature.s)));
+    if (signatureS_Hex.length < 64) {
+        const padding = new Array(64 - signatureS_Hex.length).fill(0);
+        signatureS_Hex = padding.join('').toString() + signatureS_Hex;
+    }
+    const result = '0x' + signatureRx_Hex + signatureRy_Hex + signatureS_Hex;
+    return result;
+};
+export function convertPublicKey2(pk) {
+    // return new BN(EdDSA.pack(pk.x, pk.y), 16);
+    return new BN(EDDSAUtil.pack(pk.x, pk.y), 16);
+}
+export function getUpdateAccountEcdsaTypedData(data, chainId) {
+    const message = {
+        owner: data.owner,
+        accountID: data.accountId,
+        feeTokenID: data.maxFee.tokenId,
+        maxFee: data.maxFee.volume,
+        publicKey: fm.addHexPrefix(convertPublicKey2(data.publicKey).toString(16)),
+        validUntil: data.validUntil,
+        nonce: data.nonce,
+    };
+    const typedData = {
+        types: {
+            EIP712Domain: [
+                { name: 'name', type: 'string' },
+                { name: 'version', type: 'string' },
+                { name: 'chainId', type: 'uint256' },
+                { name: 'verifyingContract', type: 'address' },
+            ],
+            AccountUpdate: [
+                { name: 'owner', type: 'address' },
+                { name: 'accountID', type: 'uint32' },
+                { name: 'feeTokenID', type: 'uint16' },
+                { name: 'maxFee', type: 'uint96' },
+                { name: 'publicKey', type: 'uint256' },
+                { name: 'validUntil', type: 'uint32' },
+                { name: 'nonce', type: 'uint32' },
+            ],
+        },
+        primaryType: 'AccountUpdate',
+        domain: {
+            name: 'Loopring Protocol',
+            version: '3.6.0',
+            chainId,
+            verifyingContract: data.exchange,
+        },
+        message: message,
+    };
+    return typedData;
+}
+export function getTransferTypedData(data, chainId) {
+    const message = {
+        from: data.payerAddr,
+        to: data.payeeAddr,
+        tokenID: data.token.tokenId,
+        amount: data.token.volume,
+        feeTokenID: data.maxFee.tokenId,
+        maxFee: data.maxFee.volume,
+        validUntil: data.validUntil,
+        storageID: data.storageId,
+    };
+    const typedData = {
+        types: {
+            EIP712Domain: [
+                { name: 'name', type: 'string' },
+                { name: 'version', type: 'string' },
+                { name: 'chainId', type: 'uint256' },
+                { name: 'verifyingContract', type: 'address' },
+            ],
+            Transfer: [
+                { name: 'from', type: 'address' },
+                { name: 'to', type: 'address' },
+                { name: 'tokenID', type: 'uint16' },
+                { name: 'amount', type: 'uint96' },
+                { name: 'feeTokenID', type: 'uint16' },
+                { name: 'maxFee', type: 'uint96' },
+                { name: 'validUntil', type: 'uint32' },
+                { name: 'storageID', type: 'uint32' },
+            ],
+        },
+        primaryType: 'Transfer',
+        domain: {
+            name: 'Loopring Protocol',
+            version: '3.6.0',
+            chainId: chainId,
+            verifyingContract: data.exchange,
+        },
+        message: message,
+    };
+    return typedData;
+}
+export function get_EddsaSig_Transfer(request, eddsaKey) {
+    const inputs = [
+        new BN(ethUtil.toBuffer(request.exchange)).toString(),
+        request.payerId,
+        request.payeeId,
+        request.token.tokenId,
+        request.token.volume,
+        request.maxFee.tokenId,
+        request.maxFee.volume,
+        new BN(ethUtil.toBuffer(request.payeeAddr)).toString(),
+        0,
+        0,
+        request.validUntil,
+        request.storageId,
+    ];
+    return getEdDSASigWithPoseidon(inputs, eddsaKey);
+}
+export function getEdDSASig(method, basePath, api_url, requestInfo, PrivateKey) {
+    let params;
+    method = method.toUpperCase().trim();
+    if (method === 'GET' || method === 'DELETE') {
+        params = makeRequestParamStr(requestInfo);
+    }
+    else if (method === 'POST' || method === 'PUT') {
+        params = makeObjectStr(requestInfo);
+    }
+    else {
+        throw new Error(`${method} is not supported yet!`);
+    }
+    const uri = encodeURIComponent(`${basePath}${api_url}`);
+    const message = `${method}&${uri}&${params}`;
+    let _hash = new BigInteger(crypto.SHA256(message).toString(), 16);
+    let hash = _hash.mod(SNARK_SCALAR_FIELD).toFormat(0, 0, {});
+    const sig = genSigWithPadding(PrivateKey, hash);
+    return sig;
+}
+const makeRequestParamStr = (request) => {
+    const arrObj = Array.from(request);
+    arrObj.sort(function (a, b) {
+        return a[0].localeCompare(b[0]);
+    });
+    const orderedMap = new Map(arrObj.map((i) => [i[0], i[1]]));
+    const paramlist = [];
+    const keys = Object.keys(Object.fromEntries(orderedMap));
+    if (keys) {
+        keys.forEach((key) => {
+            const value = request.get(key);
+            if (value !== undefined && value !== '')
+                paramlist.push(`${key}=${value}`);
+        });
+    }
+    // force to change encode ',' due to different encode rules between server and client
+    return encodeURIComponent(paramlist.join('&')).replace(/%2C/g, '%252C');
+};
+const makeObjectStr = (request) => {
+    const jsonTxt = JSON.stringify(Object.fromEntries(request));
+    return encodeURIComponent(jsonTxt).replace(/[!'()]/g, escape); //replace(/'/ig, "%27")
+};

package/dist/lib/nft/nftBalanceResolver.js

@@ -1,7 +1,8 @@
+import { StarknetNftProvider } from "./providers/starknetNftProvider";
 export class NftBalanceResolver {
     constructor() {
         this.providers = [
-        // new StarknetNftProvider()
+            new StarknetNftProvider()
         ];
     }
     async getBalance({ address, network, contractAddress }) {

package/dist/lib/nft/providers/starknetNftProvider.d.ts

@@ -0,0 +1,6 @@
+import { Network } from "../../../Models/Network";
+import { Provider, NftBalanceProps } from "./types";
+export declare class StarknetNftProvider implements Provider {
+    supportsNetwork(network: Network): boolean;
+    getBalance: ({ address, network, contractAddress }: NftBalanceProps) => Promise<number>;
+}

package/dist/lib/nft/providers/starknetNftProvider.js

@@ -1,49 +1,50 @@
-// import { Contract, RpcProvider } from "starknet";
-// import { Network } from "../../../Models/Network";
-// import KnownInternalNames from "../../knownIds";
-// import { Provider, NftBalanceProps } from "./types";
-// const NFT_ABI = [
-//     {
-//         "name": "balanceOf",
-//         "type": "function",
-//         "inputs": [
-//             {
-//                 "name": "owner",
-//                 "type": "felt"
-//             }
-//         ],
-//         "outputs": [
-//             {
-//                 "name": "balance",
-//                 "type": "felt"
-//             }
-//         ],
-//         "stateMutability": "view"
-//     }
-// ];
-// export class StarknetNftProvider implements Provider {
-//     supportsNetwork(network: Network): boolean {
-//         return (KnownInternalNames.Networks.StarkNetMainnet.includes(network.name) 
-//             || KnownInternalNames.Networks.StarkNetGoerli.includes(network.name) 
-//             || KnownInternalNames.Networks.StarkNetSepolia.includes(network.name))
-//     }
-//     getBalance = async ({ address, network, contractAddress }: NftBalanceProps): Promise<number> => {
-//         if (!contractAddress || !network.node_url) {
-//             throw new Error("Missing NFT contract address or node URL");
-//         }
-//         const provider = new RpcProvider({
-//             nodeUrl: network.node_url
-//         });
-//         try {
-//             const contract = new Contract(NFT_ABI, contractAddress, provider);
-//             const response = await contract.balanceOf(address);
-//             if (!response || typeof response.balance === 'undefined') {
-//                 throw new Error("Invalid response from NFT contract");
-//             }
-//             return Number(response.balance);
-//         } catch (error) {
-//             console.error("Error fetching NFT balance:", error);
-//             throw error;
-//         }
-//     }
-// } 
+import { Contract, RpcProvider } from "starknet";
+import KnownInternalNames from "../../knownIds";
+const NFT_ABI = [
+    {
+        "name": "balanceOf",
+        "type": "function",
+        "inputs": [
+            {
+                "name": "owner",
+                "type": "felt"
+            }
+        ],
+        "outputs": [
+            {
+                "name": "balance",
+                "type": "felt"
+            }
+        ],
+        "stateMutability": "view"
+    }
+];
+export class StarknetNftProvider {
+    constructor() {
+        this.getBalance = async ({ address, network, contractAddress }) => {
+            if (!contractAddress || !network.node_url) {
+                throw new Error("Missing NFT contract address or node URL");
+            }
+            const provider = new RpcProvider({
+                nodeUrl: network.node_url
+            });
+            try {
+                const contract = new Contract(NFT_ABI, contractAddress, provider);
+                const response = await contract.balanceOf(address);
+                if (!response || typeof response.balance === 'undefined') {
+                    throw new Error("Invalid response from NFT contract");
+                }
+                return Number(response.balance);
+            }
+            catch (error) {
+                console.error("Error fetching NFT balance:", error);
+                throw error;
+            }
+        };
+    }
+    supportsNetwork(network) {
+        return (KnownInternalNames.Networks.StarkNetMainnet.includes(network.name)
+            || KnownInternalNames.Networks.StarkNetGoerli.includes(network.name)
+            || KnownInternalNames.Networks.StarkNetSepolia.includes(network.name));
+    }
+}

package/dist/lib/resolveChain.d.ts

@@ -6,6 +6,7 @@ export default function resolveChain(network: Network): {
             readonly url: string;
         };
     } | undefined;
+    blockTime?: number | undefined | undefined;
     contracts: {
         readonly multicall3?: {
             address: `0x${string}`;
@@ -19,6 +20,7 @@ export default function resolveChain(network: Network): {
         readonly symbol: string;
         readonly decimals: number;
     };
+    experimental_preconfirmationTime?: number | undefined | undefined;
     rpcUrls: {
         readonly default: {
             readonly http: readonly [string];

package/dist/lib/resolveChain.js

@@ -1,7 +1,6 @@
 import { defineChain, parseGwei } from "viem";
 import NetworkSettings from "./NetworkSettings";
-import { SendErrorMessage } from "./telegram";
-import AppSettings from "./AppSettings";
+import logError from "./logError";
 export default function resolveChain(network) {
     const nativeCurrency = network.token;
     const blockExplorersBaseURL = network.transaction_explorer_template ?
@@ -10,7 +9,7 @@ export default function resolveChain(network) {
     const metadata = network.metadata;
     const { evm_multicall_contract } = metadata || {};
     if (!nativeCurrency) {
-        SendErrorMessage("UI Settings error", `env: ${AppSettings.ApiVersion} %0A url: ${AppSettings.Integrator} %0A message: could not find native currency for ${network.name} ${JSON.stringify(network)} %0A`);
+        logError(`UI Settings error: could not find native currency for ${network.name} ${JSON.stringify(network)} %0A`);
         return;
     }
     const res = defineChain({

package/dist/lib/sorting.d.ts

@@ -1,6 +1,7 @@
-import { Exchange, ExchangeToken } from "../Models/Exchange";
-import { RouteNetwork, RouteToken } from "../Models/Network";
-import { SwapDirection } from "../components/Pages/SwapPages/Form/SwapFormValues";
+import { SwapDirection } from "../components/Pages/Swap/Form/SwapFormValues";
+import { Exchange } from "../Models/Exchange";
+import { NetworkRoute, NetworkRouteToken } from "../Models/Network";
+export declare const ONE_WEEK: number;
 export declare const SortAscending: (x: {
     order: number;
 }, y: {
@@ -13,7 +14,8 @@ export declare const SortNetworks: (a: {
     order: number;
     name: string;
 }) => number;
-export declare function ResolveNetworkOrder(network: RouteNetwork, is_new: boolean): 100 | -1 | 50;
+export declare const SortNetworkRoutes: (a: NetworkRoute, b: NetworkRoute) => number;
+export declare const SortNetworkRoutesWithBalances: (balances: Record<string, number>) => (a: NetworkRoute, b: NetworkRoute) => number;
+export declare function ResolveNetworkOrder(network: NetworkRoute, is_new: boolean): 100 | -1 | 50;
 export declare function ResolveExchangeOrder(exchange: Exchange, direction: SwapDirection): number;
-export declare function ResolveCEXCurrencyOrder(token: ExchangeToken): number;
-export declare function ResolveCurrencyOrder(currency: RouteToken, is_new: boolean): number;
+export declare function ResolveCurrencyOrder(currency: NetworkRouteToken): number;

package/dist/lib/sorting.js

@@ -1,5 +1,6 @@
 import CurrencySettings from "./CurrencySettings";
 import ExchangeSettings from "./ExchangeSettings";
+export const ONE_WEEK = 7 * 24 * 60 * 60 * 1000;
 export const SortAscending = (x, y) => x.order - y.order;
 export const SortNetworks = (a, b) => {
     if (a.order !== b.order) {
@@ -7,6 +8,31 @@ export const SortNetworks = (a, b) => {
     }
     return a.name.localeCompare(b.name);
 };
+export const SortNetworkRoutes = (a, b) => {
+    const aIsNew = a?.tokens?.every(t => new Date(t?.listing_date)?.getTime() >= new Date().getTime() - ONE_WEEK);
+    const bIsNew = b?.tokens?.every(t => new Date(t?.listing_date)?.getTime() >= new Date().getTime() - ONE_WEEK);
+    const a_order = ResolveNetworkOrder(a, aIsNew);
+    const b_order = ResolveNetworkOrder(b, bIsNew);
+    if (a_order !== b_order) {
+        return b_order - a_order;
+    }
+    return a.name.localeCompare(b.name);
+};
+export const SortNetworkRoutesWithBalances = (balances) => (a, b) => {
+    const aIsNew = a?.tokens?.every(t => new Date(t?.listing_date)?.getTime() >= new Date().getTime() - ONE_WEEK);
+    const bIsNew = b?.tokens?.every(t => new Date(t?.listing_date)?.getTime() >= new Date().getTime() - ONE_WEEK);
+    const a_order = ResolveNetworkOrder(a, aIsNew);
+    const b_order = ResolveNetworkOrder(b, bIsNew);
+    if (a_order !== b_order) {
+        return b_order - a_order;
+    }
+    const balance_a = balances[a.name]; //useNetworksBalanceStore.getState().getNetworkBalance(a.name)?.totalInUSD || 0
+    const balance_b = balances[b.name]; //useNetworksBalanceStore.getState().getNetworkBalance(b.name)?.totalInUSD || 0
+    if (balance_b !== balance_a) {
+        return balance_b - balance_a;
+    }
+    return a.name.localeCompare(b.name);
+};
 export function ResolveNetworkOrder(network, is_new) {
     const is_inactive = network.tokens?.every(r => r.status === 'inactive');
     if (is_inactive) {
@@ -22,11 +48,7 @@ export function ResolveExchangeOrder(exchange, direction) {
     const initial_order = resolveInitialWeightedOrder(ExchangeSettings.KnownSettings[exchange.name]?.[orderProp], 1);
     return initial_order;
 }
-export function ResolveCEXCurrencyOrder(token) {
-    const initial_order = resolveInitialWeightedOrder(CurrencySettings.KnownSettings[token.symbol]?.Order, 1);
-    return initial_order;
-}
-export function ResolveCurrencyOrder(currency, is_new) {
+export function ResolveCurrencyOrder(currency) {
     const initial_order = resolveInitialWeightedOrder(CurrencySettings.KnownSettings[currency.symbol]?.Order, 1);
     const is_active = currency.status === 'active';
     const is_inactive = currency.status === 'inactive';

package/dist/lib/telegram.js

@@ -1,4 +1,4 @@
-const configs = {}; //rocess.env.NEXT_PUBLIC_TELEGRAM_CONFIGS ? JSON.parse(process.env.NEXT_PUBLIC_TELEGRAM_CONFIGS) : undefined
+const configs = process.env.NEXT_PUBLIC_TELEGRAM_CONFIGS ? JSON.parse(process.env.NEXT_PUBLIC_TELEGRAM_CONFIGS) : undefined;
 export const SendFeedbackMessage = async (title, text) => {
     if (!configs.feedback_token || !configs.feedback_chat_id)
         return;