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

package/dist/cjs/data/chainid.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainIDKeyedMap = exports.OmniversalChainID = void 0;
+exports.encodeChainID36 = encodeChainID36;
+const viem_1 = require("viem");
+const definition_1 = require("../proto/definition");
+const utils_1 = require("./utils");
+function encodeChainID36(universe, chainID) {
+    let chainIDB;
+    if (Buffer.isBuffer(chainID) || chainID instanceof Uint8Array) {
+        chainIDB = chainID;
+    }
+    else {
+        chainIDB = (0, viem_1.toBytes)(chainID);
+    }
+    const buf = Buffer.alloc(36);
+    buf.writeUint32BE(universe);
+    buf.set(chainIDB, 4 + (32 - chainIDB.length));
+    return buf;
+}
+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 = (0, viem_1.bytesToBigInt)(chainID);
+        }
+        this.binaryForm = encodeChainID36(this.universe, this.chainID);
+    }
+    toString() {
+        return (0, definition_1.universeToJSON)(this.universe) + "_" + this.chainID.toString(10);
+    }
+    toJSON() {
+        return {
+            universe: (0, definition_1.universeToJSON)(this.universe),
+            chainID: (0, viem_1.toHex)(this.chainID),
+        };
+    }
+    static fromJSON(input) {
+        return new OmniversalChainID((0, definition_1.universeFromJSON)(input.universe), (0, viem_1.hexToBigInt)(input.chainID));
+    }
+    static fromChainID36(_input) {
+        const input = (0, utils_1.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);
+    }
+}
+exports.OmniversalChainID = OmniversalChainID;
+class ChainIDKeyedMap {
+    map;
+    constructor(entries = null) {
+        this.map = new Map(entries != null
+            ? entries.map((e) => [(0, viem_1.bytesToHex)(e[0].toBytes()), e[1]])
+            : null);
+    }
+    get(key) {
+        return this.map.get((0, viem_1.bytesToHex)(key.toBytes()));
+    }
+    set(key, value) {
+        this.map.set((0, viem_1.bytesToHex)(key.toBytes()), value);
+        return this;
+    }
+    getFromChainID36(key) {
+        return this.map.get((0, viem_1.bytesToHex)(key));
+    }
+    *entries() {
+        for (const [key, value] of this.map.entries()) {
+            yield [OmniversalChainID.fromChainID36((0, viem_1.hexToBytes)(key)), value];
+        }
+    }
+}
+exports.ChainIDKeyedMap = ChainIDKeyedMap;

package/dist/cjs/data/currency.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Currency = exports.CurrencyID = void 0;
+const tslib_1 = require("tslib");
+const viem_1 = require("viem");
+const decimal_js_1 = tslib_1.__importDefault(require("decimal.js"));
+const utils_1 = require("./utils");
+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 || (exports.CurrencyID = CurrencyID = {}));
+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 = (0, utils_1.zeroExtendBufToGivenSize)((0, viem_1.toBytes)(tokenAddress), 32);
+        }
+        else if (tokenAddress instanceof Uint8Array) {
+            this.tokenAddress = (0, utils_1.zeroExtendBufToGivenSize)(tokenAddress, 32);
+        }
+        else if (Array.isArray(tokenAddress) &&
+            tokenAddress.length >= 1 &&
+            typeof tokenAddress[0] === "number") {
+            this.tokenAddress = (0, utils_1.zeroExtendBufToGivenSize)(Buffer.from(tokenAddress), 32);
+        }
+        this.oneUnitToAtomicUnitRatio = decimal_js_1.default.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 = (0, viem_1.bytesToBigInt)(input).toString(10);
+        }
+        else if (typeof input === "string") {
+            rawunits = input;
+        }
+        else {
+            throw new Error("Invalid input");
+        }
+        return decimal_js_1.default.div(rawunits, this.oneUnitToAtomicUnitRatio);
+    }
+    convertAmountToUnitsInBinary(input) {
+        return Buffer.from((0, viem_1.toBytes)(input.mul(this.oneUnitToAtomicUnitRatio).ceil().toHex()));
+    }
+}
+exports.Currency = Currency;

package/dist/cjs/data/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./chaindata"), exports);
+tslib_1.__exportStar(require("./chainid"), exports);
+tslib_1.__exportStar(require("./currency"), exports);
+tslib_1.__exportStar(require("./utils"), exports);

package/dist/cjs/data/utils.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToBufferIfNecessary = convertToBufferIfNecessary;
+exports.zeroExtendBufToGivenSize = zeroExtendBufToGivenSize;
+exports.ezPadTo32Hex = ezPadTo32Hex;
+exports.convertDecimalToBigInt = convertDecimalToBigInt;
+exports.convertBigIntToDecimal = convertBigIntToDecimal;
+exports.maxByBigInt = maxByBigInt;
+exports.minByBigInt = minByBigInt;
+const tslib_1 = require("tslib");
+const viem_1 = require("viem");
+const decimal_js_1 = tslib_1.__importDefault(require("decimal.js"));
+function convertToBufferIfNecessary(buf) {
+    return Buffer.isBuffer(buf) ? buf : Buffer.from(buf);
+}
+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;
+}
+function ezPadTo32Hex(input) {
+    return (0, viem_1.pad)(typeof input !== "string" ? (0, viem_1.toHex)(input) : input, {
+        dir: "left",
+        size: 32,
+    });
+}
+function convertDecimalToBigInt(dec) {
+    return BigInt(dec.ceil().toFixed());
+}
+function convertBigIntToDecimal(big) {
+    return new decimal_js_1.default(big.toString(10));
+}
+function maxByBigInt(items, getValue) {
+    return items.reduce((m, e) => getValue(e) > getValue(m) ? e : m);
+}
+function minByBigInt(items, getValue) {
+    return items.reduce((m, e) => getValue(e) < getValue(m) ? e : m);
+}

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

@@ -0,0 +1,349 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERC20ABI = void 0;
+exports.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/cjs/evmabi/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./erc20.abi"), exports);
+tslib_1.__exportStar(require("./vault.abi"), exports);
+tslib_1.__exportStar(require("./yakaggregator.abi"), exports);