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

package/dist/esm/data/chainid.js

@@ -0,0 +1,85 @@
+import { bytesToBigInt, bytesToHex, hexToBigInt, hexToBytes, toBytes, toHex, } from "viem";
+import { universeFromJSON, universeToJSON, } from "../proto/definition";
+import { convertToBufferIfNecessary } from "./utils";
+export function encodeChainID36(universe, chainID) {
+    let chainIDB;
+    if (Buffer.isBuffer(chainID) || chainID instanceof Uint8Array) {
+        chainIDB = chainID;
+    }
+    else {
+        chainIDB = toBytes(chainID);
+    }
+    const buf = Buffer.alloc(36);
+    buf.writeUint32BE(universe);
+    buf.set(chainIDB, 4 + (32 - chainIDB.length));
+    return buf;
+}
+export class OmniversalChainID {
+    universe;
+    chainID;
+    binaryForm;
+    constructor(universe, chainID) {
+        this.universe = universe;
+        if (typeof chainID === "bigint") {
+            this.chainID = chainID;
+        }
+        else if (typeof chainID === "number" || typeof chainID === "string") {
+            this.chainID = BigInt(chainID);
+        }
+        else if (chainID instanceof Uint8Array) {
+            this.chainID = bytesToBigInt(chainID);
+        }
+        this.binaryForm = encodeChainID36(this.universe, this.chainID);
+    }
+    toString() {
+        return universeToJSON(this.universe) + "_" + this.chainID.toString(10);
+    }
+    toJSON() {
+        return {
+            universe: universeToJSON(this.universe),
+            chainID: toHex(this.chainID),
+        };
+    }
+    static fromJSON(input) {
+        return new OmniversalChainID(universeFromJSON(input.universe), hexToBigInt(input.chainID));
+    }
+    static fromChainID36(_input) {
+        const input = convertToBufferIfNecessary(_input);
+        const univID = input.readUint32BE(0);
+        const rest = input.subarray(4);
+        return new OmniversalChainID(univID, rest);
+    }
+    // Do not modify the returned buffer. Make a copy if necessary.
+    toBytes() {
+        return this.binaryForm;
+    }
+    equals(rhs) {
+        return this.universe === rhs.universe && this.chainID === rhs.chainID;
+    }
+    static equals(lhs, rhs) {
+        return lhs.equals(rhs);
+    }
+}
+export class ChainIDKeyedMap {
+    map;
+    constructor(entries = null) {
+        this.map = new Map(entries != null
+            ? entries.map((e) => [bytesToHex(e[0].toBytes()), e[1]])
+            : null);
+    }
+    get(key) {
+        return this.map.get(bytesToHex(key.toBytes()));
+    }
+    set(key, value) {
+        this.map.set(bytesToHex(key.toBytes()), value);
+        return this;
+    }
+    getFromChainID36(key) {
+        return this.map.get(bytesToHex(key));
+    }
+    *entries() {
+        for (const [key, value] of this.map.entries()) {
+            yield [OmniversalChainID.fromChainID36(hexToBytes(key)), value];
+        }
+    }
+}

package/dist/esm/data/currency.js

@@ -0,0 +1,72 @@
+import { bytesToBigInt, toBytes } from "viem";
+import Decimal from "decimal.js";
+import { zeroExtendBufToGivenSize } from "./utils";
+export var CurrencyID;
+(function (CurrencyID) {
+    CurrencyID[CurrencyID["USDC"] = 1] = "USDC";
+    CurrencyID[CurrencyID["USDT"] = 2] = "USDT";
+    CurrencyID[CurrencyID["ETH"] = 3] = "ETH";
+    CurrencyID[CurrencyID["POL"] = 4] = "POL";
+    CurrencyID[CurrencyID["AVAX"] = 5] = "AVAX";
+    CurrencyID[CurrencyID["BNB"] = 6] = "BNB";
+    CurrencyID[CurrencyID["HYPE"] = 16] = "HYPE";
+    CurrencyID[CurrencyID["KAIA"] = 17] = "KAIA";
+    CurrencyID[CurrencyID["SOPH"] = 18] = "SOPH";
+    CurrencyID[CurrencyID["TRX"] = 19] = "TRX";
+    CurrencyID[CurrencyID["MON"] = 20] = "MON";
+})(CurrencyID || (CurrencyID = {}));
+export class Currency {
+    currencyID;
+    decimals;
+    permitVariant;
+    permitContractVersion;
+    isGasToken;
+    // this is always 32 byte long
+    tokenAddress;
+    /* This is the ratio between one unit to the smallest unit used.
+  
+       For example, USDC, which has a ‘decimals’ value of 6, is designed so that 1 USDC = 10⁶ μUSDC, which is the smallest indivisible amount representable.
+     */
+    oneUnitToAtomicUnitRatio;
+    constructor(currencyID, tokenAddress, decimals, permitVariant, permitContractVersion = 0, isGasToken) {
+        this.currencyID = currencyID;
+        this.decimals = decimals;
+        this.permitVariant = permitVariant;
+        this.permitContractVersion = permitContractVersion;
+        this.isGasToken = isGasToken;
+        if (typeof tokenAddress === "string") {
+            this.tokenAddress = zeroExtendBufToGivenSize(toBytes(tokenAddress), 32);
+        }
+        else if (tokenAddress instanceof Uint8Array) {
+            this.tokenAddress = zeroExtendBufToGivenSize(tokenAddress, 32);
+        }
+        else if (Array.isArray(tokenAddress) &&
+            tokenAddress.length >= 1 &&
+            typeof tokenAddress[0] === "number") {
+            this.tokenAddress = zeroExtendBufToGivenSize(Buffer.from(tokenAddress), 32);
+        }
+        this.oneUnitToAtomicUnitRatio = Decimal.pow(10, decimals);
+    }
+    convertUnitsToAmountDecimal(input) {
+        let rawunits;
+        if (typeof input === "bigint") {
+            rawunits = input.toString(10);
+        }
+        else if (typeof input === "number") {
+            rawunits = input.toString();
+        }
+        else if (input instanceof Uint8Array) {
+            rawunits = bytesToBigInt(input).toString(10);
+        }
+        else if (typeof input === "string") {
+            rawunits = input;
+        }
+        else {
+            throw new Error("Invalid input");
+        }
+        return Decimal.div(rawunits, this.oneUnitToAtomicUnitRatio);
+    }
+    convertAmountToUnitsInBinary(input) {
+        return Buffer.from(toBytes(input.mul(this.oneUnitToAtomicUnitRatio).ceil().toHex()));
+    }
+}

package/dist/esm/data/index.js

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

package/dist/esm/data/utils.js

@@ -0,0 +1,34 @@
+import { pad, toHex } from "viem";
+import Decimal from "decimal.js";
+export function convertToBufferIfNecessary(buf) {
+    return Buffer.isBuffer(buf) ? buf : Buffer.from(buf);
+}
+export function zeroExtendBufToGivenSize(buf, size = 32) {
+    if (buf.length === size) {
+        return convertToBufferIfNecessary(buf);
+    }
+    if (buf.length > size) {
+        return convertToBufferIfNecessary(buf.subarray(0, size));
+    }
+    const out = Buffer.alloc(size);
+    out.set(buf, size - buf.length);
+    return out;
+}
+export function ezPadTo32Hex(input) {
+    return pad(typeof input !== "string" ? toHex(input) : input, {
+        dir: "left",
+        size: 32,
+    });
+}
+export function convertDecimalToBigInt(dec) {
+    return BigInt(dec.ceil().toFixed());
+}
+export function convertBigIntToDecimal(big) {
+    return new Decimal(big.toString(10));
+}
+export function maxByBigInt(items, getValue) {
+    return items.reduce((m, e) => getValue(e) > getValue(m) ? e : m);
+}
+export function minByBigInt(items, getValue) {
+    return items.reduce((m, e) => getValue(e) < getValue(m) ? e : m);
+}

package/dist/esm/evmabi/erc20.abi.js

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

package/dist/esm/evmabi/index.js

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