ccxt 4.3.69 → 4.3.71

package/js/src/static_dependencies/scure-starknet/index.js

@@ -0,0 +1,323 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+/*! scure-starknet - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+import { keccak_256 } from '../noble-hashes/sha3.js';
+import { sha256 } from '../noble-hashes/sha256.js';
+import { utf8ToBytes } from '../noble-hashes/utils.js';
+import { mod, Fp, validateField, invert } from '../noble-curves/abstract/modular.js';
+import { poseidon } from '../noble-curves/abstract/poseidon.js';
+import { weierstrass, DER } from '../noble-curves/abstract/weierstrass.js';
+import * as u from '../noble-curves/abstract/utils.js';
+import { getHash } from '../noble-curves/_shortw_utils.js';
+const CURVE_ORDER = BigInt('3618502788666131213697322783095070105526743751716087489154079457884512865583');
+// 2**251, limit for msgHash and Signature.r
+export const MAX_VALUE = BigInt('0x800000000000000000000000000000000000000000000000000000000000000');
+const nBitLength = 252;
+function bits2int(bytes) {
+    while (bytes[0] === 0)
+        bytes = bytes.subarray(1); // strip leading 0s
+    // Copy-pasted from weierstrass.ts
+    const delta = bytes.length * 8 - nBitLength;
+    const num = u.bytesToNumberBE(bytes);
+    return delta > 0 ? num >> BigInt(delta) : num;
+}
+function hex0xToBytes(hex) {
+    if (typeof hex === 'string') {
+        hex = strip0x(hex); // allow 0x prefix
+        if (hex.length & 1)
+            hex = '0' + hex; // allow unpadded hex
+    }
+    return u.hexToBytes(hex);
+}
+const curve = weierstrass({
+    a: BigInt(1),
+    b: BigInt('3141592653589793238462643383279502884197169399375105820974944592307816406665'),
+    // Field over which we'll do calculations; 2n**251n + 17n * 2n**192n + 1n
+    // There is no efficient sqrt for field (P%4==1)
+    Fp: Fp(BigInt('0x800000000000011000000000000000000000000000000000000000000000001')),
+    n: CURVE_ORDER,
+    nBitLength,
+    // Base point (x, y) aka generator point
+    Gx: BigInt('874739451078007766457464989774322083649278607533249481151382481072868806602'),
+    Gy: BigInt('152666792071518830868575557812948353041420400780739481342941381225525861407'),
+    h: BigInt(1),
+    lowS: false,
+    ...getHash(sha256),
+    // Custom truncation routines for stark curve
+    bits2int,
+    bits2int_modN: (bytes) => {
+        // 2102820b232636d200cb21f1d330f20d096cae09d1bf3edb1cc333ddee11318 =>
+        // 2102820b232636d200cb21f1d330f20d096cae09d1bf3edb1cc333ddee113180
+        const hex = u.bytesToNumberBE(bytes).toString(16); // toHex unpadded
+        if (hex.length === 63)
+            bytes = hex0xToBytes(hex + '0'); // append trailing 0
+        return mod(bits2int(bytes), CURVE_ORDER);
+    },
+});
+export const _starkCurve = curve;
+function ensureBytes(hex) {
+    return u.ensureBytes('', typeof hex === 'string' ? hex0xToBytes(hex) : hex);
+}
+function normPrivKey(privKey) {
+    return u.bytesToHex(ensureBytes(privKey)).padStart(64, '0');
+}
+export function getPublicKey(privKey, isCompressed = false) {
+    return curve.getPublicKey(normPrivKey(privKey), isCompressed);
+}
+export function getSharedSecret(privKeyA, pubKeyB) {
+    return curve.getSharedSecret(normPrivKey(privKeyA), pubKeyB);
+}
+function checkSignature(signature) {
+    // Signature.s checked inside weierstrass
+    const { r, s } = signature;
+    if (r < 0n || r >= MAX_VALUE)
+        throw new Error(`Signature.r should be [1, ${MAX_VALUE})`);
+    const w = invert(s, CURVE_ORDER);
+    if (w < 0n || w >= MAX_VALUE)
+        throw new Error(`inv(Signature.s) should be [1, ${MAX_VALUE})`);
+}
+function checkMessage(msgHash) {
+    const bytes = ensureBytes(msgHash);
+    const num = u.bytesToNumberBE(bytes);
+    // num < 0 impossible here
+    if (num >= MAX_VALUE)
+        throw new Error(`msgHash should be [0, ${MAX_VALUE})`);
+    return bytes;
+}
+export function sign(msgHash, privKey, opts) {
+    const sig = curve.sign(checkMessage(msgHash), normPrivKey(privKey), opts);
+    checkSignature(sig);
+    return sig;
+}
+export function verify(signature, msgHash, pubKey) {
+    if (!(signature instanceof Signature)) {
+        const bytes = ensureBytes(signature);
+        try {
+            signature = Signature.fromDER(bytes);
+        }
+        catch (derError) {
+            if (!(derError instanceof DER.Err))
+                throw derError;
+            signature = Signature.fromCompact(bytes);
+        }
+    }
+    checkSignature(signature);
+    return curve.verify(signature, checkMessage(msgHash), ensureBytes(pubKey));
+}
+const { CURVE, ProjectivePoint, Signature, utils } = curve;
+export { CURVE, ProjectivePoint, Signature, utils };
+function extractX(bytes) {
+    const hex = u.bytesToHex(bytes.subarray(1));
+    const stripped = hex.replace(/^0+/gm, ''); // strip leading 0s
+    return `0x${stripped}`;
+}
+function strip0x(hex) {
+    return hex.replace(/^0x/i, '');
+}
+// seed generation
+export function grindKey(seed) {
+    const _seed = ensureBytes(seed);
+    const sha256mask = 2n ** 256n;
+    const limit = sha256mask - mod(sha256mask, CURVE_ORDER);
+    for (let i = 0;; i++) {
+        const key = sha256Num(u.concatBytes(_seed, u.numberToVarBytesBE(BigInt(i))));
+        if (key < limit)
+            return mod(key, CURVE_ORDER).toString(16); // key should be in [0, limit)
+        if (i === 100000)
+            throw new Error('grindKey is broken: tried 100k vals'); // prevent dos
+    }
+}
+export function getStarkKey(privateKey) {
+    return extractX(getPublicKey(privateKey, true));
+}
+export function ethSigToPrivate(signature) {
+    signature = strip0x(signature);
+    if (signature.length !== 130)
+        throw new Error('Wrong ethereum signature');
+    return grindKey(signature.substring(0, 64));
+}
+const MASK_31 = 2n ** 31n - 1n;
+const int31 = (n) => Number(n & MASK_31);
+export function getAccountPath(layer, application, ethereumAddress, index) {
+    const layerNum = int31(sha256Num(layer));
+    const applicationNum = int31(sha256Num(application));
+    const eth = u.hexToNumber(strip0x(ethereumAddress));
+    return `m/2645'/${layerNum}'/${applicationNum}'/${int31(eth)}'/${int31(eth >> 31n)}'/${index}`;
+}
+// The Pedersen hash uses five different points on the curve.
+// This is critical to ensure that they have been generated in a way
+// that nobody knows the discrete logarithm of one point regarding another.
+//
+// Starknet utilizes nothing-up-my-sleeve technique:
+// The parameters of the Pedersen hash are generated from the constant 𝜋.
+// The x-coordinate of each point is a chunk of 76 decimal digit of 𝜋 modulo 𝑝.
+// If it is a quadratic residue then the point is valid
+// else the x-coordinate coordinate is incremented by one.
+// https://docs.starkware.co/starkex/pedersen-hash-function.html
+// https://github.com/starkware-libs/starkex-for-spot-trading/blob/607f0b4ce507e1d95cd018d206a2797f6ba4aab4/src/starkware/crypto/starkware/crypto/signature/nothing_up_my_sleeve_gen.py
+const PEDERSEN_POINTS = [
+    new ProjectivePoint(2089986280348253421170679821480865132823066470938446095505822317253594081284n, 1713931329540660377023406109199410414810705867260802078187082345529207694986n, 1n),
+    new ProjectivePoint(996781205833008774514500082376783249102396023663454813447423147977397232763n, 1668503676786377725805489344771023921079126552019160156920634619255970485781n, 1n),
+    new ProjectivePoint(2251563274489750535117886426533222435294046428347329203627021249169616184184n, 1798716007562728905295480679789526322175868328062420237419143593021674992973n, 1n),
+    new ProjectivePoint(2138414695194151160943305727036575959195309218611738193261179310511854807447n, 113410276730064486255102093846540133784865286929052426931474106396135072156n, 1n),
+    new ProjectivePoint(2379962749567351885752724891227938183011949129833673362440656643086021394946n, 776496453633298175483985398648758586525933812536653089401905292063708816422n, 1n),
+];
+function pedersenPrecompute(p1, p2) {
+    const out = [];
+    let p = p1;
+    for (let i = 0; i < 248; i++) {
+        out.push(p);
+        p = p.double();
+    }
+    // NOTE: we cannot use wNAF here, because last 4 bits will require full 248 bits multiplication
+    // We can add support for this to wNAF, but it will complicate wNAF.
+    p = p2;
+    for (let i = 0; i < 4; i++) {
+        out.push(p);
+        p = p.double();
+    }
+    return out;
+}
+const PEDERSEN_POINTS1 = pedersenPrecompute(PEDERSEN_POINTS[1], PEDERSEN_POINTS[2]);
+const PEDERSEN_POINTS2 = pedersenPrecompute(PEDERSEN_POINTS[3], PEDERSEN_POINTS[4]);
+function pedersenArg(arg) {
+    let value;
+    if (typeof arg === 'bigint') {
+        value = arg;
+    }
+    else if (typeof arg === 'number') {
+        if (!Number.isSafeInteger(arg))
+            throw new Error(`Invalid pedersenArg: ${arg}`);
+        value = BigInt(arg);
+    }
+    else {
+        value = u.bytesToNumberBE(ensureBytes(arg));
+    }
+    if (!(0n <= value && value < curve.CURVE.Fp.ORDER))
+        throw new Error(`PedersenArg should be 0 <= value < CURVE.P: ${value}`); // [0..Fp)
+    return value;
+}
+/**
+ * Warning: Not algorithmic constant-time.
+ */
+function pedersenSingle(point, value, constants) {
+    let x = pedersenArg(value);
+    for (let j = 0; j < 252; j++) {
+        const pt = constants[j];
+        if (!pt)
+            throw new Error('invalid constant index');
+        if (pt.equals(point))
+            throw new Error('Same point');
+        if ((x & 1n) !== 0n)
+            point = point.add(pt);
+        x >>= 1n;
+    }
+    return point;
+}
+// shift_point + x_low * P_0 + x_high * P1 + y_low * P2  + y_high * P3
+export function pedersen(x, y) {
+    let point = PEDERSEN_POINTS[0];
+    point = pedersenSingle(point, x, PEDERSEN_POINTS1);
+    point = pedersenSingle(point, y, PEDERSEN_POINTS2);
+    return extractX(point.toRawBytes(true));
+}
+// Same as hashChain, but computes hash even for single element and order is not revesed
+export const computeHashOnElements = (data, fn = pedersen) => [0, ...data, data.length].reduce((x, y) => fn(x, y));
+const MASK_250 = u.bitMask(250);
+export const keccak = (data) => u.bytesToNumberBE(keccak_256(data)) & MASK_250;
+const sha256Num = (data) => u.bytesToNumberBE(sha256(data));
+// Poseidon hash
+// Unused for now
+// export const Fp253 = Fp(
+//   BigInt('14474011154664525231415395255581126252639794253786371766033694892385558855681')
+// ); // 2^253 + 2^199 + 1
+export const Fp251 = Fp(BigInt('3618502788666131213697322783095070105623107215331596699973092056135872020481')); // 2^251 + 17 * 2^192 + 1
+function poseidonRoundConstant(Fp, name, idx) {
+    const val = Fp.fromBytes(sha256(utf8ToBytes(`${name}${idx}`)));
+    return Fp.create(val);
+}
+// NOTE: doesn't check eiginvalues and possible can create unsafe matrix. But any filtration here will break compatibility with starknet
+// Please use only if you really know what you doing.
+// https://eprint.iacr.org/2019/458.pdf Section 2.3 (Avoiding Insecure Matrices)
+export function _poseidonMDS(Fp, name, m, attempt = 0) {
+    const x_values = [];
+    const y_values = [];
+    for (let i = 0; i < m; i++) {
+        x_values.push(poseidonRoundConstant(Fp, `${name}x`, attempt * m + i));
+        y_values.push(poseidonRoundConstant(Fp, `${name}y`, attempt * m + i));
+    }
+    if (new Set([...x_values, ...y_values]).size !== 2 * m)
+        throw new Error('X and Y values are not distinct');
+    return x_values.map((x) => y_values.map((y) => Fp.inv(Fp.sub(x, y))));
+}
+const MDS_SMALL = [
+    [3, 1, 1],
+    [1, -1, 1],
+    [1, 1, -2],
+].map((i) => i.map(BigInt));
+export function poseidonBasic(opts, mds) {
+    validateField(opts.Fp);
+    if (!Number.isSafeInteger(opts.rate) || !Number.isSafeInteger(opts.capacity))
+        throw new Error(`Wrong poseidon opts: ${opts}`);
+    const m = opts.rate + opts.capacity;
+    const rounds = opts.roundsFull + opts.roundsPartial;
+    const roundConstants = [];
+    for (let i = 0; i < rounds; i++) {
+        const row = [];
+        for (let j = 0; j < m; j++)
+            row.push(poseidonRoundConstant(opts.Fp, 'Hades', m * i + j));
+        roundConstants.push(row);
+    }
+    const res = poseidon({
+        ...opts,
+        t: m,
+        sboxPower: 3,
+        reversePartialPowIdx: true,
+        mds,
+        roundConstants,
+    });
+    res.m = m;
+    res.rate = opts.rate;
+    res.capacity = opts.capacity;
+    return res;
+}
+export function poseidonCreate(opts, mdsAttempt = 0) {
+    const m = opts.rate + opts.capacity;
+    if (!Number.isSafeInteger(mdsAttempt))
+        throw new Error(`Wrong mdsAttempt=${mdsAttempt}`);
+    return poseidonBasic(opts, _poseidonMDS(opts.Fp, 'HadesMDS', m, mdsAttempt));
+}
+export const poseidonSmall = poseidonBasic({ Fp: Fp251, rate: 2, capacity: 1, roundsFull: 8, roundsPartial: 83 }, MDS_SMALL);
+export function poseidonHash(x, y, fn = poseidonSmall) {
+    return fn([x, y, 2n])[0];
+}
+export function poseidonHashFunc(x, y, fn = poseidonSmall) {
+    return u.numberToVarBytesBE(poseidonHash(u.bytesToNumberBE(x), u.bytesToNumberBE(y), fn));
+}
+export function poseidonHashSingle(x, fn = poseidonSmall) {
+    return fn([x, 0n, 1n])[0];
+}
+export function poseidonHashMany(values, fn = poseidonSmall) {
+    const { m, rate } = fn;
+    if (!Array.isArray(values))
+        throw new Error('bigint array expected in values');
+    const padded = Array.from(values); // copy
+    padded.push(1n);
+    while (padded.length % rate !== 0)
+        padded.push(0n);
+    let state = new Array(m).fill(0n);
+    for (let i = 0; i < padded.length; i += rate) {
+        for (let j = 0; j < rate; j++) {
+            const item = padded[i + j];
+            if (typeof item === 'undefined')
+                throw new Error('invalid index');
+            state[j] += item;
+        }
+        state = fn(state);
+    }
+    return state[0];
+}

package/js/src/static_dependencies/starknet/constants.d.ts

@@ -0,0 +1,61 @@
+export { IS_BROWSER } from './utils/encode.js';
+/**
+ * Cairo Felt support storing max 31 character
+ */
+export declare const TEXT_TO_FELT_MAX_LEN = 31;
+/**
+ * Alternatively use directly from api specification
+ * types.RPC.ETransactionVersion
+ * For BN do BigInt(TRANSACTION_VERSION.*)
+ */
+export declare const ZERO = 0n;
+export declare const MASK_250: bigint;
+export declare const API_VERSION = 0n;
+export declare const PRIME: bigint;
+export declare const MAX_STORAGE_ITEM_SIZE = 256n;
+export declare const ADDR_BOUND: bigint;
+export declare const RANGE_FELT: {
+    readonly min: bigint;
+    readonly max: bigint;
+};
+export declare const RANGE_I128: {
+    readonly min: bigint;
+    readonly max: bigint;
+};
+export declare const RANGE_U128: {
+    readonly min: bigint;
+    readonly max: bigint;
+};
+export declare enum BaseUrl {
+    SN_MAIN = "https://alpha-mainnet.starknet.io",
+    SN_SEPOLIA = "https://alpha-sepolia.starknet.io"
+}
+export declare enum NetworkName {
+    SN_MAIN = "SN_MAIN",
+    SN_SEPOLIA = "SN_SEPOLIA"
+}
+export declare enum StarknetChainId {
+    SN_MAIN = "0x534e5f4d41494e",
+    SN_SEPOLIA = "0x534e5f5345504f4c4941"
+}
+export declare enum TransactionHashPrefix {
+    DECLARE = "0x6465636c617265",
+    DEPLOY = "0x6465706c6f79",
+    DEPLOY_ACCOUNT = "0x6465706c6f795f6163636f756e74",
+    INVOKE = "0x696e766f6b65",
+    L1_HANDLER = "0x6c315f68616e646c6572"
+}
+export declare const enum feeMarginPercentage {
+    L1_BOUND_MAX_AMOUNT = 50,
+    L1_BOUND_MAX_PRICE_PER_UNIT = 50,
+    MAX_FEE = 50
+}
+export declare const UDC: {
+    ADDRESS: string;
+    ENTRYPOINT: string;
+};
+export declare const RPC_DEFAULT_VERSION = "v0_7";
+export declare const RPC_NODES: {
+    SN_MAIN: string[];
+    SN_SEPOLIA: string[];
+};

package/js/src/static_dependencies/starknet/constants.js

@@ -0,0 +1,67 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+// import { ETransactionVersion } from './types/api';
+export { IS_BROWSER } from './utils/encode.js';
+/**
+ * Cairo Felt support storing max 31 character
+ */
+export const TEXT_TO_FELT_MAX_LEN = 31;
+/**
+ * Alternatively use directly from api specification
+ * types.RPC.ETransactionVersion
+ * For BN do BigInt(TRANSACTION_VERSION.*)
+ */
+// export { ETransactionVersion as TRANSACTION_VERSION };
+export const ZERO = 0n;
+export const MASK_250 = 2n ** 250n - 1n; // 2 ** 250 - 1
+export const API_VERSION = ZERO;
+export const PRIME = 2n ** 251n + 17n * 2n ** 192n + 1n;
+// based on: https://github.com/starkware-libs/cairo-lang/blob/v0.12.3/src/starkware/starknet/common/storage.cairo#L3
+export const MAX_STORAGE_ITEM_SIZE = 256n;
+export const ADDR_BOUND = 2n ** 251n - MAX_STORAGE_ITEM_SIZE;
+const range = (min, max) => ({ min, max });
+export const RANGE_FELT = range(ZERO, PRIME - 1n);
+export const RANGE_I128 = range(-(2n ** 127n), 2n ** 127n - 1n);
+export const RANGE_U128 = range(ZERO, 2n ** 128n - 1n);
+export var BaseUrl;
+(function (BaseUrl) {
+    BaseUrl["SN_MAIN"] = "https://alpha-mainnet.starknet.io";
+    BaseUrl["SN_SEPOLIA"] = "https://alpha-sepolia.starknet.io";
+})(BaseUrl || (BaseUrl = {}));
+export var NetworkName;
+(function (NetworkName) {
+    NetworkName["SN_MAIN"] = "SN_MAIN";
+    NetworkName["SN_SEPOLIA"] = "SN_SEPOLIA";
+})(NetworkName || (NetworkName = {}));
+export var StarknetChainId;
+(function (StarknetChainId) {
+    StarknetChainId["SN_MAIN"] = "0x534e5f4d41494e";
+    StarknetChainId["SN_SEPOLIA"] = "0x534e5f5345504f4c4941";
+})(StarknetChainId || (StarknetChainId = {}));
+export var TransactionHashPrefix;
+(function (TransactionHashPrefix) {
+    TransactionHashPrefix["DECLARE"] = "0x6465636c617265";
+    TransactionHashPrefix["DEPLOY"] = "0x6465706c6f79";
+    TransactionHashPrefix["DEPLOY_ACCOUNT"] = "0x6465706c6f795f6163636f756e74";
+    TransactionHashPrefix["INVOKE"] = "0x696e766f6b65";
+    TransactionHashPrefix["L1_HANDLER"] = "0x6c315f68616e646c6572";
+})(TransactionHashPrefix || (TransactionHashPrefix = {}));
+export const UDC = {
+    ADDRESS: '0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf',
+    ENTRYPOINT: 'deployContract',
+};
+export const RPC_DEFAULT_VERSION = 'v0_7';
+export const RPC_NODES = {
+    SN_MAIN: [
+        `https://starknet-mainnet.public.blastapi.io/rpc/${RPC_DEFAULT_VERSION}`,
+        `https://free-rpc.nethermind.io/mainnet-juno/${RPC_DEFAULT_VERSION}`,
+    ],
+    SN_SEPOLIA: [
+        `https://starknet-sepolia.public.blastapi.io/rpc/${RPC_DEFAULT_VERSION}`,
+        `https://free-rpc.nethermind.io/sepolia-juno/${RPC_DEFAULT_VERSION}`,
+    ],
+};

package/js/src/static_dependencies/starknet/index.d.ts

@@ -0,0 +1,7 @@
+export * as hash from './utils/hash/index.js';
+export * from './utils/calldata/index.js';
+export * as typedData from './utils/typedData.js';
+/**
+ * Deprecated
+ */
+/** @deprecated prefer the 'num' naming */

package/js/src/static_dependencies/starknet/index.js

@@ -0,0 +1,50 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+export * as hash from './utils/hash/index.js';
+export * from './utils/calldata/index.js';
+export * as typedData from './utils/typedData.js';
+// /**
+//  * Main
+//  */
+// export * from './account/index.js';
+// export * from './contract/index.js';
+// export * from './types/index.js';
+// /**
+//  * Utils
+//  */
+// export * as constants from './constants.js';
+// export * as encode from './utils/encode.js';
+// export * as v3hash from './utils/hash/transactionHash/v3.js';
+// export * as v2hash from './utils/hash/transactionHash/v2.js';
+// export * as num from './utils/num.js';
+// export * as transaction from './utils/transaction.js';
+// export * as stark from './utils/stark.js';
+// export * as eth from './utils/eth.js';
+// export * as merkle from './utils/merkle.js';
+// export * as uint256 from './utils/uint256.js';
+// export * as shortString from './utils/shortString.js';
+// export * as starknetId from './utils/starknetId.js';
+// export * as events from './utils/events/index.js';
+// export * from './utils/cairoDataTypes/uint256.js';
+// export * from './utils/cairoDataTypes/uint512.js';
+// export * from './utils/address.js';
+// export * from './utils/url.js';
+// export * from './utils/calldata/enum/index.js';
+// export * from './utils/contract.js';
+// export * from './utils/transactionReceipt.js';
+/**
+ * Deprecated
+ */
+/* eslint-disable import/first */
+// import * as num from './utils/num/index.js';
+/** @deprecated prefer the 'num' naming */
+// export const number = num;
+// export * from './utils/events/index.js';
+// export * as types from './types/index.js';
+// export * as json from './utils/json.js';
+// export * as provider from './utils/provider.js';
+// export * as selector from './utils/selector/index.js';

package/js/src/static_dependencies/starknet/types/cairoEnum.d.ts

@@ -0,0 +1,2 @@
+import { CairoCustomEnum, CairoOption, CairoResult } from '../utils/calldata/enum/index.js';
+export declare type CairoEnum = CairoCustomEnum | CairoOption<any> | CairoResult<any, any>;

package/js/src/static_dependencies/starknet/types/cairoEnum.js

@@ -0,0 +1,7 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+export {};

package/js/src/static_dependencies/starknet/types/calldata.d.ts

@@ -0,0 +1,19 @@
+export declare enum ValidateType {
+    DEPLOY = "DEPLOY",
+    CALL = "CALL",
+    INVOKE = "INVOKE"
+}
+export declare enum Uint {
+    u8 = "core::integer::u8",
+    u16 = "core::integer::u16",
+    u32 = "core::integer::u32",
+    u64 = "core::integer::u64",
+    u128 = "core::integer::u128",
+    u256 = "core::integer::u256",
+    u512 = "core::integer::u512"
+}
+export declare enum Literal {
+    ClassHash = "core::starknet::class_hash::ClassHash",
+    ContractAddress = "core::starknet::contract_address::ContractAddress",
+    Secp256k1Point = "core::starknet::secp256k1::Secp256k1Point"
+}

package/js/src/static_dependencies/starknet/types/calldata.js

@@ -0,0 +1,28 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+export var ValidateType;
+(function (ValidateType) {
+    ValidateType["DEPLOY"] = "DEPLOY";
+    ValidateType["CALL"] = "CALL";
+    ValidateType["INVOKE"] = "INVOKE";
+})(ValidateType || (ValidateType = {}));
+export var Uint;
+(function (Uint) {
+    Uint["u8"] = "core::integer::u8";
+    Uint["u16"] = "core::integer::u16";
+    Uint["u32"] = "core::integer::u32";
+    Uint["u64"] = "core::integer::u64";
+    Uint["u128"] = "core::integer::u128";
+    Uint["u256"] = "core::integer::u256";
+    Uint["u512"] = "core::integer::u512";
+})(Uint || (Uint = {}));
+export var Literal;
+(function (Literal) {
+    Literal["ClassHash"] = "core::starknet::class_hash::ClassHash";
+    Literal["ContractAddress"] = "core::starknet::contract_address::ContractAddress";
+    Literal["Secp256k1Point"] = "core::starknet::secp256k1::Secp256k1Point";
+})(Literal || (Literal = {}));

package/js/src/static_dependencies/starknet/types/index.d.ts

@@ -0,0 +1,13 @@
+export * from './calldata.js';
+export * from './lib/index.js';
+export * from './cairoEnum.js';
+export declare type ArgsOrCalldata = any;
+export declare type Result = any;
+export declare type ParsedEvent = any;
+export declare type ParsedEvents = any;
+export declare type RPC = any;
+export declare type InvokeTransactionReceiptResponse = any;
+export declare type ContractClassResponse = any;
+export declare type FeeEstimate = any;
+export declare type UniversalDetails = any;
+export * from './typedData.js';

package/js/src/static_dependencies/starknet/types/index.js

@@ -0,0 +1,16 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+export * from './calldata.js';
+export * from './lib/index.js';
+export * from './cairoEnum.js';
+export * from './typedData.js';
+// export * from './transactionReceipt.js';
+// export * as RPC from './api.js';
+// export * from './contract.js';
+// export * from './account.js';
+// export * from './provider.js';
+// export * from './signer.js';

package/js/src/static_dependencies/starknet/types/lib/contract/abi.d.ts

@@ -0,0 +1,71 @@
+/** ABI */
+export declare type Abi = ReadonlyArray<FunctionAbi | EventAbi | StructAbi | InterfaceAbi | any>;
+export declare type AbiEntry = {
+    name: string;
+    type: 'felt' | 'felt*' | string;
+};
+export declare type EventEntry = {
+    name: string;
+    type: 'felt' | 'felt*' | string;
+    kind: 'key' | 'data';
+};
+declare enum FunctionAbiType {
+    'function' = 0,
+    'l1_handler' = 1,
+    'constructor' = 2
+}
+export declare type FunctionAbi = {
+    inputs: AbiEntry[];
+    name: string;
+    outputs: AbiEntry[];
+    stateMutability?: 'view';
+    state_mutability?: string;
+    type: FunctionAbiType;
+};
+export declare type AbiStructs = {
+    [name: string]: StructAbi;
+};
+export declare type StructAbi = {
+    members: (AbiEntry & {
+        offset: number;
+    })[];
+    name: string;
+    size: number;
+    type: 'struct';
+};
+export declare type AbiInterfaces = {
+    [name: string]: InterfaceAbi;
+};
+export declare type InterfaceAbi = {
+    items: FunctionAbi[];
+    name: string;
+    type: 'interface';
+};
+export declare type AbiEnums = {
+    [name: string]: EnumAbi;
+};
+export declare type EnumAbi = {
+    variants: (AbiEntry & {
+        offset: number;
+    })[];
+    name: string;
+    size: number;
+    type: 'enum/index.js';
+};
+export declare type AbiEvents = {
+    [hash: string]: EventAbi;
+};
+export declare type EventAbi = Cairo1Event | LegacyEvent;
+export declare type Cairo1Event = {
+    name: string;
+    members: EventEntry[];
+    kind: 'struct';
+    type: 'event';
+};
+export declare type LegacyEvent = {
+    name: string;
+    type: 'event';
+    data: EventEntry[];
+    keys: EventEntry[];
+};
+export {};