@avail-project/ca-common 1.0.0-beta.6 → 1.0.0-beta.8

package/dist/esm/_polyfill.js

@@ -0,0 +1,143 @@
+import * as bufferModule from "buffer";
+import { Buffer as DefaultBuffer } from "buffer";
+const globalScope = globalThis;
+let patched = false;
+function collectBufferCtors() {
+    const candidates = new Set();
+    if (typeof DefaultBuffer === "function") {
+        candidates.add(DefaultBuffer);
+    }
+    const mod = bufferModule;
+    if (typeof mod?.Buffer === "function") {
+        candidates.add(mod.Buffer);
+    }
+    const defaultExport = mod?.default;
+    if (typeof defaultExport === "function") {
+        candidates.add(defaultExport);
+    }
+    else if (defaultExport &&
+        typeof defaultExport === "object" &&
+        typeof defaultExport.Buffer === "function") {
+        candidates.add(defaultExport.Buffer);
+    }
+    if (typeof globalScope.Buffer === "function") {
+        candidates.add(globalScope.Buffer);
+    }
+    return Array.from(candidates);
+}
+function assertOffset(buffer, offset) {
+    const numericOffset = Number(offset);
+    if (!Number.isFinite(numericOffset)) {
+        throw new TypeError("Offset must be a finite number");
+    }
+    const normalized = numericOffset >>> 0;
+    if (normalized !== numericOffset) {
+        throw new RangeError("Offset must be a non-negative integer");
+    }
+    if (normalized + 4 > buffer.length) {
+        throw new RangeError("Offset out of bounds");
+    }
+    return normalized;
+}
+function fallbackWriteUint32BE(value, offset = 0) {
+    const o = assertOffset(this, offset);
+    const normalized = Number(value) >>> 0;
+    this[o] = (normalized >>> 24) & 0xff;
+    this[o + 1] =
+        (normalized >>> 16) & 0xff;
+    this[o + 2] =
+        (normalized >>> 8) & 0xff;
+    this[o + 3] = normalized & 0xff;
+    return o + 4;
+}
+function fallbackWriteUint32LE(value, offset = 0) {
+    const o = assertOffset(this, offset);
+    const normalized = Number(value) >>> 0;
+    this[o] = normalized & 0xff;
+    this[o + 1] =
+        (normalized >>> 8) & 0xff;
+    this[o + 2] =
+        (normalized >>> 16) & 0xff;
+    this[o + 3] =
+        (normalized >>> 24) & 0xff;
+    return o + 4;
+}
+function fallbackReadUint32BE(offset = 0) {
+    const o = assertOffset(this, offset);
+    const store = this;
+    return ((store[o] * 0x1000000 +
+        ((store[o + 1] << 16) | (store[o + 2] << 8) | store[o + 3])) >>>
+        0);
+}
+function fallbackReadUint32LE(offset = 0) {
+    const o = assertOffset(this, offset);
+    const store = this;
+    return ((store[o] |
+        (store[o + 1] << 8) |
+        (store[o + 2] << 16) |
+        (store[o + 3] * 0x1000000)) >>>
+        0);
+}
+function aliasOrDefine(proto, alias, canonical, fallback) {
+    const aliasKey = alias;
+    const canonicalKey = canonical;
+    const existingAlias = proto[aliasKey];
+    if (typeof existingAlias === "function") {
+        return;
+    }
+    const canonicalFn = proto[canonicalKey];
+    if (typeof canonicalFn === "function") {
+        Object.defineProperty(proto, aliasKey, {
+            value: canonicalFn,
+            writable: true,
+            configurable: true,
+        });
+        return;
+    }
+    Object.defineProperty(proto, aliasKey, {
+        value: fallback,
+        writable: true,
+        configurable: true,
+    });
+}
+function patchPrototype(bufferCtor) {
+    const proto = bufferCtor.prototype;
+    if (!proto) {
+        return;
+    }
+    aliasOrDefine(proto, "writeUint32BE", "writeUInt32BE", fallbackWriteUint32BE);
+    aliasOrDefine(proto, "writeUint32LE", "writeUInt32LE", fallbackWriteUint32LE);
+    aliasOrDefine(proto, "readUint32BE", "readUInt32BE", fallbackReadUint32BE);
+    aliasOrDefine(proto, "readUint32LE", "readUInt32LE", fallbackReadUint32LE);
+}
+function ensureProcessEnv() {
+    if (!globalScope.process) {
+        globalScope.process = { env: { NODE_ENV: "production" } };
+        return;
+    }
+    const processValue = globalScope.process;
+    if (!processValue.env) {
+        processValue.env = { NODE_ENV: "production" };
+        return;
+    }
+    if (typeof processValue.env.NODE_ENV === "undefined") {
+        processValue.env.NODE_ENV = "production";
+    }
+}
+export function ensureBufferPolyfill() {
+    if (patched) {
+        return;
+    }
+    const candidates = collectBufferCtors();
+    candidates.forEach(patchPrototype);
+    const preferred = candidates[0];
+    if (preferred &&
+        (typeof globalScope.Buffer !== "function" ||
+            typeof globalScope.Buffer.prototype?.writeUint32BE !==
+                "function")) {
+        globalScope.Buffer = preferred;
+    }
+    ensureProcessEnv();
+    patched = true;
+}
+ensureBufferPolyfill();

package/dist/esm/data/chaindata.js

@@ -533,6 +533,27 @@ const RawData = [
             },
         ],
     },
+    {
+        Universe: 0,
+        ChainID32: "0x000000000000000000000000000000000000000000000000000000000000008f",
+        Currencies: [
+            {
+                CurrencyID: 1,
+                TokenContractAddress: "0x000000000000000000000000754704Bc059F8C67012fEd69BC8A327a5aafb603",
+                PermitVariant: PermitVariant.EIP2612Canonical,
+                PermitContractVersion: 2,
+                TokenDecimals: 6,
+                IsGasToken: false,
+            },
+            {
+                CurrencyID: 20,
+                TokenContractAddress: "0x0000000000000000000000000000000000000000000000000000000000000000",
+                PermitVariant: PermitVariant.Unsupported,
+                TokenDecimals: 18,
+                IsGasToken: true,
+            },
+        ],
+    },
     {
         Universe: 3,
         ChainID32: "0x0000000000000000000000000000000000000000000000000000000094a9059e",
@@ -603,75 +624,68 @@ export const ChaindataMap = new ChainIDKeyedMap(Chaindata.map((ch) => [ch.ChainI
 export const RPCURLMap = new ChainIDKeyedMap([
     [
         new OmniversalChainID(Universe.ETHEREUM, 421614),
-        "https://arb-sepolia.g.alchemy.com/v2/PfaswrKq0rjOrfYWHfE9uLQKhiD4JCdq",
+        "https://rpcs.avail.so/arbitrumsepolia",
     ],
     [
         new OmniversalChainID(Universe.ETHEREUM, 11155420),
-        "https://opt-sepolia.g.alchemy.com/v2/PfaswrKq0rjOrfYWHfE9uLQKhiD4JCdq",
+        "https://rpcs.avail.so/optimismsepolia",
     ],
     [
         new OmniversalChainID(Universe.ETHEREUM, 80002),
-        "https://polygon-amoy.g.alchemy.com/v2/PfaswrKq0rjOrfYWHfE9uLQKhiD4JCdq",
+        "https://rpcs.avail.so/polygonamoy",
     ],
     [
         new OmniversalChainID(Universe.ETHEREUM, 84532),
-        "https://base-sepolia.g.alchemy.com/v2/PfaswrKq0rjOrfYWHfE9uLQKhiD4JCdq",
+        "https://rpcs.avail.so/basesepolia",
     ],
     [
         new OmniversalChainID(Universe.ETHEREUM, 11155111),
-        "https://eth-sepolia.g.alchemy.com/v2/PfaswrKq0rjOrfYWHfE9uLQKhiD4JCdq",
+        "https://rpcs.avail.so/sepolia",
     ],
     [
         new OmniversalChainID(Universe.ETHEREUM, 137),
-        "https://polygon-mainnet.g.alchemy.com/v2/PfaswrKq0rjOrfYWHfE9uLQKhiD4JCdq",
+        "https://rpcs.avail.so/polygon",
     ],
     [
         new OmniversalChainID(Universe.ETHEREUM, 42161),
-        "https://arb-mainnet.g.alchemy.com/v2/PfaswrKq0rjOrfYWHfE9uLQKhiD4JCdq",
+        "https://rpcs.avail.so/arbitrum",
     ],
     [
         new OmniversalChainID(Universe.ETHEREUM, 10),
-        "https://opt-mainnet.g.alchemy.com/v2/PfaswrKq0rjOrfYWHfE9uLQKhiD4JCdq",
+        "https://rpcs.avail.so/optimism",
     ],
     [
         new OmniversalChainID(Universe.ETHEREUM, 8453),
-        "https://base-mainnet.g.alchemy.com/v2/PfaswrKq0rjOrfYWHfE9uLQKhiD4JCdq",
-    ],
-    [
-        new OmniversalChainID(Universe.ETHEREUM, 1),
-        "https://eth-mainnet.g.alchemy.com/v2/PfaswrKq0rjOrfYWHfE9uLQKhiD4JCdq",
+        "https://rpcs.avail.so/base",
     ],
+    [new OmniversalChainID(Universe.ETHEREUM, 1), "https://rpcs.avail.so/eth"],
     [
         new OmniversalChainID(Universe.ETHEREUM, 534352),
-        "https://scroll-mainnet.g.alchemy.com/v2/PfaswrKq0rjOrfYWHfE9uLQKhiD4JCdq",
-    ],
-    [
-        new OmniversalChainID(Universe.ETHEREUM, 59144),
-        "https://linea-mainnet.g.alchemy.com/v2/PfaswrKq0rjOrfYWHfE9uLQKhiD4JCdq",
+        "https://rpcs.avail.so/scroll",
     ],
     [
         new OmniversalChainID(Universe.ETHEREUM, 43114),
-        "https://avax-mainnet.g.alchemy.com/v2/PfaswrKq0rjOrfYWHfE9uLQKhiD4JCdq",
+        "https://rpcs.avail.so/avalanche",
     ],
     [
         new OmniversalChainID(Universe.ETHEREUM, 999),
-        "https://rpc.hyperliquid.xyz/evm",
-    ], // Alchemy doesn't support this.
+        "https://rpcs.avail.so/hyperevm",
+    ],
     [
         new OmniversalChainID(Universe.ETHEREUM, 8217),
-        "https://go.getblock.io/d7094dbd80ab474ba7042603fe912332",
-    ], // Alchemy doesn't support this.
-    [new OmniversalChainID(Universe.ETHEREUM, 50104), "https://rpc.sophon.xyz"], // Alchemy doesn't support this.
+        "https://rpcs.avail.so/kaia",
+    ],
     [
-        new OmniversalChainID(Universe.ETHEREUM, 56),
-        "https://bnb-mainnet.g.alchemy.com/v2/PfaswrKq0rjOrfYWHfE9uLQKhiD4JCdq",
+        new OmniversalChainID(Universe.ETHEREUM, 50104),
+        "https://sophon.gateway.tenderly.co/1d4STFT7zmG0vM5QowibCw",
     ],
+    [new OmniversalChainID(Universe.ETHEREUM, 56), "https://rpcs.avail.so/bsc"],
     [
         new OmniversalChainID(Universe.ETHEREUM, 10143),
-        "https://lb.drpc.org/monad-testnet/Am5nENoJmEuovqui8_LMxzp4ChJzW7kR8JfPrqRhf0fE",
+        "https://rpcs.avail.so/monadtestnet",
     ],
     [
-        new OmniversalChainID(Universe.FUEL, 9889),
-        "https://omniscient-fittest-pallet.fuel-mainnet.quiknode.pro/3193ae52f2522af1a4357a482e475e019857f02b/v1/graphql",
+        new OmniversalChainID(Universe.ETHEREUM, 143),
+        "https://rpcs.avail.so/monad",
     ],
 ]);

package/dist/esm/data/chainid.js

@@ -1,6 +1,8 @@
+import { ensureBufferPolyfill } from "../_polyfill";
 import { bytesToBigInt, bytesToHex, hexToBigInt, hexToBytes, toBytes, toHex, } from "viem";
 import { universeFromJSON, universeToJSON, } from "../proto/definition";
 import { convertToBufferIfNecessary } from "./utils";
+ensureBufferPolyfill();
 export function encodeChainID36(universe, chainID) {
     let chainIDB;
     if (Buffer.isBuffer(chainID) || chainID instanceof Uint8Array) {
@@ -10,7 +12,7 @@ export function encodeChainID36(universe, chainID) {
         chainIDB = toBytes(chainID);
     }
     const buf = Buffer.alloc(36);
-    buf.writeUint32BE(universe);
+    buf.writeUInt32BE(universe);
     buf.set(chainIDB, 4 + (32 - chainIDB.length));
     return buf;
 }
@@ -45,7 +47,7 @@ export class OmniversalChainID {
     }
     static fromChainID36(_input) {
         const input = convertToBufferIfNecessary(_input);
-        const univID = input.readUint32BE(0);
+        const univID = input.readUInt32BE(0);
         const rest = input.subarray(4);
         return new OmniversalChainID(univID, rest);
     }

package/dist/esm/index.js

@@ -1,12 +1,13 @@
-export { ArcanaVault, ArcanaVaultFactory } from './fuelcontracts';
-export * from './proto/definition';
-export { QueryClientImpl, GrpcWebError, GrpcWebImpl } from './proto/grpc';
-export * from './data';
-export * from './vaultcontracts';
-export * from './permitutils';
-export * from './xcs';
-export * from './cosmos';
-export * from './rff/rff';
-export * from './types';
-export * from './balances/ub-api';
-export * from './evmabi';
+import "./_polyfill";
+export * from "./proto/definition";
+export { QueryClientImpl, GrpcWebError, GrpcWebImpl, } from "./proto/grpc";
+export { createGrpcWebImpl } from "./proto/client";
+export * from "./data";
+export * from "./vaultcontracts";
+export * from "./permitutils";
+export * from "./xcs";
+export * from "./cosmos";
+export * from "./rff/rff";
+export * from "./types";
+export * from "./balances/ub-api";
+export * from "./evmabi";

package/dist/esm/proto/client.js

@@ -0,0 +1,11 @@
+import { GrpcWebImpl } from "./grpc";
+export const createGrpcWebImpl = async (url) => {
+    const options = {};
+    // eslint-disable-next-line no-constant-binary-expression, valid-typeof
+    if (typeof window == undefined) {
+        const lib = await import("@improbable-eng/grpc-web-node-http-transport");
+        options.transport = lib.NodeHttpTransport();
+    }
+    const impl = new GrpcWebImpl(url, options);
+    return impl;
+};