@avail-project/ca-common 1.0.0-beta.1

package/dist/esm/xcs/yieldyak-agg.js

@@ -0,0 +1,109 @@
+import { bytesToHex } from "viem";
+import { clone as _clone, groupBy, last as _last, maxBy } from "es-toolkit";
+import { QuoteType } from "./iface";
+import { encodeChainID36 } from "../data";
+import { Universe } from "../proto/definition";
+import { YakAggregatorABI } from "../evmabi/yakaggregator.abi";
+const YakAggregatorAddresses = new Map([
+    [encodeChainID36(Universe.ETHEREUM, 42161), '0xb32C79a25291265eF240Eb32E9faBbc6DcEE3cE3'],
+    [encodeChainID36(Universe.ETHEREUM, 10), '0xCd887F78c77b36B0b541E77AfD6F91C0253182A2'],
+    [encodeChainID36(Universe.ETHEREUM, 43114), '0xC4729E56b831d74bBc18797e0e17A295fA77488c'],
+].map(([chainID, addr]) => {
+    return [bytesToHex(chainID), addr];
+}));
+export class YieldYakAggregator {
+    clients = new Map();
+    constructor(clients) {
+        for (const client of clients) {
+            const chainIDHex = bytesToHex(client.chainID.toBytes());
+            const aggAddr = YakAggregatorAddresses.get(chainIDHex);
+            if (aggAddr == null) {
+                continue;
+            }
+            this.clients.set(chainIDHex, {
+                chainID: client.chainID,
+                client: client.client,
+                aggregatorAddress: aggAddr
+            });
+        }
+    }
+    async getQuotes(_requests) {
+        const requestsWithOriginalIndexes = _requests.map((r, rid) => {
+            return {
+                req: r,
+                idx: rid,
+            };
+        });
+        const responses = new Array(_requests.length).fill(null);
+        // it's so sad that JS doesn't have a proper binary data type
+        const groupedByChainID = groupBy(requestsWithOriginalIndexes, r => bytesToHex(r.req.chain.toBytes()));
+        await Promise.all(Array.from(Object.entries(groupedByChainID)).map(async ([chainIDHex, requests]) => {
+            const config = this.clients.get(chainIDHex);
+            if (config == null) {
+                return;
+            }
+            const reverseIndexes = [];
+            const mc3calls = [];
+            for (const req of requests) {
+                const inputTokenHex = bytesToHex(req.req.inputToken.subarray(12));
+                const outputTokenHex = bytesToHex(req.req.outputToken.subarray(12));
+                let args;
+                switch (req.req.type) {
+                    case QuoteType.EXACT_IN: {
+                        args = [req.req.inputAmount, inputTokenHex, outputTokenHex, 0, 1];
+                        break;
+                    }
+                    case QuoteType.EXACT_OUT: {
+                        args = [req.req.outputAmount, outputTokenHex, inputTokenHex, 0, 1];
+                        break;
+                    }
+                }
+                const indexes = [];
+                for (let steps = 1; steps !== 5; steps++) {
+                    const clonedArgs = _clone(args);
+                    clonedArgs[3] = steps;
+                    const idx = mc3calls.push({
+                        address: config.aggregatorAddress,
+                        abi: YakAggregatorABI,
+                        functionName: 'findBestPathWithGas',
+                        args: clonedArgs
+                    });
+                    indexes.push(idx - 1);
+                }
+                reverseIndexes.push([req, indexes]);
+            }
+            const _final = await config.client.multicall({
+                allowFailure: false,
+                contracts: mc3calls,
+                multicallAddress: '0xcA11bde05977b3631167028862bE2a173976CA11'
+            });
+            for (const [req, indexes] of reverseIndexes) {
+                const collected = [];
+                for (const index of indexes) {
+                    collected.push(_final[index]);
+                }
+                // @ts-expect-error the typing in maxBy is wrong, it can work with anything that is comparable
+                const optimalChoice = maxBy(collected, route => _last(route.amounts));
+                if (optimalChoice.path.length === 0) {
+                    responses[req.idx] = null;
+                    return;
+                }
+                // we have to reverse everything
+                if (req.req.type === QuoteType.EXACT_OUT) {
+                    optimalChoice.adapters.reverse();
+                    optimalChoice.amounts.reverse();
+                    optimalChoice.path.reverse();
+                }
+                const output = _last(optimalChoice.amounts);
+                responses[req.idx] = {
+                    type: req.req.type,
+                    inputAmount: optimalChoice.amounts[0],
+                    outputAmountLikely: output,
+                    outputAmountMinimum: output,
+                    offer: optimalChoice
+                };
+            }
+        }));
+        return responses;
+    }
+}

package/dist/types/balances/ub-api.d.ts

@@ -0,0 +1,14 @@
+import Decimal from "decimal.js";
+import { Universe } from "../proto/definition";
+import { Bytes } from "../types";
+import { OmniversalChainID } from "../data";
+export type BalanceOnChain = {
+    chainID: OmniversalChainID;
+    totalValue: Decimal;
+    currencywise: {
+        tokenAddress: Buffer;
+        amount: Decimal;
+        value: Decimal;
+    }[];
+};
+export declare function getBalances(vscURL: string, universe: Universe, address: Bytes): Promise<BalanceOnChain[]>;

package/dist/types/cosmos/index.d.ts

@@ -0,0 +1,6 @@
+import { Registry as CosmosRegistry, OfflineDirectSigner, DirectSecp256k1Wallet } from "@cosmjs/proto-signing";
+import { HttpEndpoint, SigningStargateClient, SigningStargateClientOptions } from "@cosmjs/stargate";
+import { Bytes } from "../types";
+export declare const Registry: CosmosRegistry;
+export declare function createCosmosWallet(privateKey: string | Bytes): Promise<DirectSecp256k1Wallet>;
+export declare function createCosmosClient(signer: OfflineDirectSigner, endpoint: string | HttpEndpoint, options?: SigningStargateClientOptions): Promise<SigningStargateClient>;

package/dist/types/data/chaindata.d.ts

@@ -0,0 +1,20 @@
+import { Universe } from "../proto/definition";
+import { ChainIDKeyedMap, OmniversalChainID } from "./chainid";
+import { Currency } from "./currency";
+import { ezPadTo32Hex } from "./utils";
+declare class CurrencyMap {
+    private readonly map;
+    constructor(currencies: Currency[]);
+    get(input: Parameters<typeof ezPadTo32Hex>[0]): Currency | undefined;
+}
+export type ChainDatum = {
+    ChainID: OmniversalChainID;
+    Universe: Universe;
+    ChainID32: Buffer;
+    Currencies: Currency[];
+    CurrencyMap: CurrencyMap;
+};
+export declare const Chaindata: ChainDatum[];
+export declare const ChaindataMap: ChainIDKeyedMap<ChainDatum>;
+export declare const RPCURLMap: ChainIDKeyedMap<string>;
+export {};

package/dist/types/data/chainid.d.ts

@@ -0,0 +1,31 @@
+import { type Hex } from "viem";
+import { Universe } from "../proto/definition";
+import { Bytes } from "../types";
+export declare function encodeChainID36(universe: Universe, chainID: Bytes | bigint | number): Buffer;
+export declare class OmniversalChainID {
+    readonly universe: Universe;
+    readonly chainID: bigint;
+    private readonly binaryForm;
+    constructor(universe: Universe, chainID: bigint | number | string | Bytes);
+    toString(): string;
+    toJSON(): {
+        universe: string;
+        chainID: `0x${string}`;
+    };
+    static fromJSON(input: {
+        universe: string;
+        chainID: Hex;
+    }): OmniversalChainID;
+    static fromChainID36(_input: Bytes): OmniversalChainID;
+    toBytes(): Buffer;
+    equals(rhs: OmniversalChainID): boolean;
+    static equals(lhs: OmniversalChainID, rhs: OmniversalChainID): boolean;
+}
+export declare class ChainIDKeyedMap<V> {
+    private readonly map;
+    constructor(entries?: readonly [OmniversalChainID, V][] | null);
+    get(key: OmniversalChainID): V | undefined;
+    set(key: OmniversalChainID, value: V): this;
+    getFromChainID36(key: Bytes): V | undefined;
+    entries(): Generator<[OmniversalChainID, V]>;
+}

package/dist/types/data/currency.d.ts

@@ -0,0 +1,29 @@
+import { Hex } from "viem";
+import Decimal from "decimal.js";
+import { Bytes } from "../types";
+import { PermitVariant } from "../permitutils";
+export declare enum CurrencyID {
+    USDC = 1,
+    USDT = 2,
+    ETH = 3,
+    POL = 4,
+    AVAX = 5,
+    BNB = 6,
+    HYPE = 16,
+    KAIA = 17,
+    SOPH = 18,
+    TRX = 19,
+    MON = 20
+}
+export declare class Currency {
+    readonly currencyID: CurrencyID;
+    readonly decimals: number;
+    readonly permitVariant: PermitVariant;
+    readonly permitContractVersion: number;
+    readonly isGasToken: boolean;
+    readonly tokenAddress: Buffer;
+    private readonly oneUnitToAtomicUnitRatio;
+    constructor(currencyID: CurrencyID, tokenAddress: string | Bytes | number[], decimals: number, permitVariant: PermitVariant, permitContractVersion: number | undefined, isGasToken: boolean);
+    convertUnitsToAmountDecimal(input: bigint | number | Hex | Bytes): Decimal;
+    convertAmountToUnitsInBinary(input: Decimal): Buffer;
+}

package/dist/types/data/index.d.ts

@@ -0,0 +1,4 @@
+export * from './chaindata';
+export * from './chainid';
+export * from './currency';
+export * from './utils';

package/dist/types/data/utils.d.ts

@@ -0,0 +1,10 @@
+import { Hex, toHex } from "viem";
+import Decimal from "decimal.js";
+import { Bytes } from "../types";
+export declare function convertToBufferIfNecessary(buf: Bytes): Buffer<ArrayBufferLike>;
+export declare function zeroExtendBufToGivenSize(buf: Bytes, size?: number): Buffer;
+export declare function ezPadTo32Hex(input: Hex | Parameters<typeof toHex>[0]): Hex;
+export declare function convertDecimalToBigInt(dec: Decimal): bigint;
+export declare function convertBigIntToDecimal(big: bigint): Decimal;
+export declare function maxByBigInt<T>(items: readonly T[], getValue: (element: T) => bigint): T;
+export declare function minByBigInt<T>(items: readonly T[], getValue: (element: T) => bigint): T;

package/dist/types/evmabi/erc20.abi.d.ts

@@ -0,0 +1,264 @@
+export declare const ERC20ABI: readonly [{
+    readonly constant: true;
+    readonly inputs: readonly [];
+    readonly name: "name";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly constant: false;
+    readonly inputs: readonly [{
+        readonly name: "_spender";
+        readonly type: "address";
+    }, {
+        readonly name: "_value";
+        readonly type: "uint256";
+    }];
+    readonly name: "approve";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly constant: true;
+    readonly inputs: readonly [];
+    readonly name: "totalSupply";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly constant: false;
+    readonly inputs: readonly [{
+        readonly name: "_from";
+        readonly type: "address";
+    }, {
+        readonly name: "_to";
+        readonly type: "address";
+    }, {
+        readonly name: "_value";
+        readonly type: "uint256";
+    }];
+    readonly name: "transferFrom";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly constant: true;
+    readonly inputs: readonly [];
+    readonly name: "decimals";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint8";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly constant: true;
+    readonly inputs: readonly [{
+        readonly name: "_owner";
+        readonly type: "address";
+    }];
+    readonly name: "balanceOf";
+    readonly outputs: readonly [{
+        readonly name: "balance";
+        readonly type: "uint256";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly constant: true;
+    readonly inputs: readonly [];
+    readonly name: "symbol";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly constant: false;
+    readonly inputs: readonly [{
+        readonly name: "_to";
+        readonly type: "address";
+    }, {
+        readonly name: "_value";
+        readonly type: "uint256";
+    }];
+    readonly name: "transfer";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly constant: true;
+    readonly inputs: readonly [{
+        readonly name: "_owner";
+        readonly type: "address";
+    }, {
+        readonly name: "_spender";
+        readonly type: "address";
+    }];
+    readonly name: "allowance";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly payable: true;
+    readonly stateMutability: "payable";
+    readonly type: "fallback";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "value";
+        readonly type: "uint256";
+    }];
+    readonly name: "Approval";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "value";
+        readonly type: "uint256";
+    }];
+    readonly name: "Transfer";
+    readonly type: "event";
+}, {
+    readonly comment: "From the EIP-2612 spec.";
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }];
+    readonly name: "nonces";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly comment: "From the EIP-2612 spec.";
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "value";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint8";
+        readonly name: "v";
+        readonly type: "uint8";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "r";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "s";
+        readonly type: "bytes32";
+    }];
+    readonly name: "permit";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly comment: "Available on bridged tokens on Polygon.";
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "userAddress";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "functionSignature";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "sigR";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "sigS";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "uint8";
+        readonly name: "sigV";
+        readonly type: "uint8";
+    }];
+    readonly name: "executeMetaTransaction";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes";
+        readonly name: "";
+        readonly type: "bytes";
+    }];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly comment: "Available on bridged tokens on Polygon.";
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }];
+    readonly name: "getNonce";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];

package/dist/types/evmabi/index.d.ts

@@ -0,0 +1,3 @@
+export * from './erc20.abi';
+export * from './vault.abi';
+export * from './yakaggregator.abi';