@argent/x-shared 1.59.0 → 1.61.0

package/dist/src/transactions/getTransactionVersion.d.ts

@@ -4,3 +4,9 @@ import { TransactionInvokeVersion, TransactionSimulationVersion } from './transa
 export declare function getTxVersionFromFeeToken(feeTokenAddress: Address): TransactionInvokeVersion;
 export declare function getSimulationTxVersionFromFeeToken(feeTokenAddress: Address): TransactionSimulationVersion;
 export declare function getTxVersionFromFeeTokenForDeclareContract(feeTokenAddress: Address, payload: DeclareContractPayload): TransactionInvokeVersion;
+type AccountClassHash = {
+    classHash?: string;
+};
+export declare const getAccountTxVersion: ({ classHash }: AccountClassHash) => "0x1" | "0x3";
+export declare const getTxVersionForDeclareContract: ({ classHash }: AccountClassHash, payload: DeclareContractPayload) => TransactionInvokeVersion;
+export {};

package/dist/src/transactions/getTransactionVersion.js

@@ -1,18 +1,21 @@
-import { constants as e, isSierra as N } from "starknet";
-import { feeTokenNeedsTxV3Support as o } from "./txv3.js";
-function S(r) {
-  return o({
-    address: r
-  }) ? e.TRANSACTION_VERSION.V3 : e.TRANSACTION_VERSION.V1;
+import { constants as r, isSierra as T } from "starknet";
+import { classHashSupportsTxV3 as n, feeTokenNeedsTxV3Support as t } from "./txv3.js";
+function S(e) {
+  return t({
+    address: e
+  }) ? r.TRANSACTION_VERSION.V3 : r.TRANSACTION_VERSION.V1;
 }
-function V(r) {
-  return o({ address: r }) ? e.TRANSACTION_VERSION.F3 : e.TRANSACTION_VERSION.F1;
+function A(e) {
+  return t({ address: e }) ? r.TRANSACTION_VERSION.F3 : r.TRANSACTION_VERSION.F1;
 }
-function A(r, n) {
-  return N(n.contract) ? o({ address: r }) ? e.TRANSACTION_VERSION.V3 : e.TRANSACTION_VERSION.V2 : e.TRANSACTION_VERSION.V1;
+function I(e, N) {
+  return T(N.contract) ? t({ address: e }) ? r.TRANSACTION_VERSION.V3 : r.TRANSACTION_VERSION.V2 : r.TRANSACTION_VERSION.V1;
 }
+const O = ({ classHash: e }) => e && !n(e) ? r.TRANSACTION_VERSION.V1 : r.TRANSACTION_VERSION.V3, R = ({ classHash: e }, N) => T(N.contract) ? e && !n(e) ? r.TRANSACTION_VERSION.V2 : r.TRANSACTION_VERSION.V3 : r.TRANSACTION_VERSION.V1;
 export {
-  V as getSimulationTxVersionFromFeeToken,
+  O as getAccountTxVersion,
+  A as getSimulationTxVersionFromFeeToken,
+  R as getTxVersionForDeclareContract,
   S as getTxVersionFromFeeToken,
-  A as getTxVersionFromFeeTokenForDeclareContract
+  I as getTxVersionFromFeeTokenForDeclareContract
 };

package/dist/src/transactions/txv3.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("../chains/starknet/constants.cjs"),o=require("../chains/starknet/services/deploymentData/getAccountClassHash.cjs"),t=require("../chains/starknet/address.cjs"),u=[r.STRK_TOKEN_ADDRESS];function n({address:e}){return u.some(s=>t.isEqualAddress(e,s))}function a(e){return e?o.getArgentAccountClassHashesWithTxV3Support().some(s=>t.isEqualAddress(s,e)):!1}exports.classHashSupportsTxV3=a;exports.feeTokenNeedsTxV3Support=n;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("../chains/starknet/services/deploymentData/getAccountClassHash.cjs"),o=require("../chains/starknet/constants.cjs"),t=require("../chains/starknet/address.cjs"),u=[o.STRK_TOKEN_ADDRESS];function n({address:e}){return u.some(s=>t.isEqualAddress(e,s))}function a(e){return e?r.getArgentAccountClassHashesWithTxV3Support().some(s=>t.isEqualAddress(s,e)):!1}exports.classHashSupportsTxV3=a;exports.feeTokenNeedsTxV3Support=n;

package/dist/src/transactions/txv3.js

@@ -1,12 +1,12 @@
-import { STRK_TOKEN_ADDRESS as t } from "../chains/starknet/constants.js";
-import { getArgentAccountClassHashesWithTxV3Support as s } from "../chains/starknet/services/deploymentData/getAccountClassHash.js";
+import { getArgentAccountClassHashesWithTxV3Support as t } from "../chains/starknet/services/deploymentData/getAccountClassHash.js";
+import { STRK_TOKEN_ADDRESS as s } from "../chains/starknet/constants.js";
 import { isEqualAddress as o } from "../chains/starknet/address.js";
-const n = [t];
+const n = [s];
 function f({ address: r }) {
   return n.some((e) => o(r, e));
 }
 function m(r) {
-  return r ? s().some((e) => o(e, r)) : !1;
+  return r ? t().some((e) => o(e, r)) : !1;
 }
 export {
   m as classHashSupportsTxV3,

package/dist/src/utils/index.d.ts

@@ -22,3 +22,4 @@ export * from './url';
 export * from './voidify';
 export * from './bips';
 export * from './retryUntilInitialised';
+export type * from './type.utils';

package/dist/src/utils/type.utils.d.ts

@@ -0,0 +1,215 @@
+declare const symbol: unique symbol;
+/**
+ * Creates a branded type of {@link T} with the brand {@link U}.
+ *
+ * @param T - Type to brand
+ * @param U - Label
+ * @returns Branded type
+ *
+ * @example
+ * type Result = Branded<string, 'foo'>
+ * //   ^? type Result = string & { [symbol]: 'foo' }
+ */
+export type Branded<T, U> = T & {
+    [symbol]: U;
+};
+/**
+ * @description Combines members of an intersection into a readable type.
+ *
+ * @see {@link https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=NdpAcmEFXY01xkqU3KO0Mg}
+ * @example
+ * Prettify<{ a: string } & { b: string } & { c: number, d: bigint }>
+ * => { a: string, b: string, c: number, d: bigint }
+ */
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * Filters out all members of {@link T} that are not {@link P}
+ *
+ * @param T - Items to filter
+ * @param P - Type to filter out
+ * @returns Filtered items
+ *
+ * @example
+ * type Result = Filter<['a', 'b', 'c'], 'b'>
+ * //   ^? type Result = ['a', 'c']
+ */
+export type Filter<T extends readonly unknown[], P, Acc extends readonly unknown[] = []> = T extends readonly [infer F, ...infer Rest extends readonly unknown[]] ? [F] extends [P] ? Filter<Rest, P, [...Acc, F]> : Filter<Rest, P, Acc> : readonly [...Acc];
+/**
+ * @description Checks if {@link T} can be narrowed further than {@link U}
+ * @param T - Type to check
+ * @param U - Type to against
+ * @example
+ * type Result = IsNarrowable<'foo', string>
+ * //   ^? true
+ */
+export type IsNarrowable<T, U> = IsNever<(T extends U ? true : false) & (U extends T ? false : true)> extends true ? false : true;
+/**
+ * @description Checks if {@link T} is `never`
+ * @param T - Type to check
+ * @example
+ * type Result = IsNever<never>
+ * //   ^? type Result = true
+ */
+export type IsNever<T> = [T] extends [never] ? true : false;
+/** Removes `readonly` from all properties of an object. */
+export type Mutable<type extends object> = {
+    -readonly [key in keyof type]: type[key];
+};
+/**
+ * @description Evaluates boolean "or" condition for {@link T} properties.
+ * @param T - Type to check
+ *
+ * * @example
+ * type Result = Or<[false, true, false]>
+ * //   ^? type Result = true
+ *
+ * @example
+ * type Result = Or<[false, false, false]>
+ * //   ^? type Result = false
+ */
+export type Or<T extends readonly unknown[]> = T extends readonly [
+    infer Head,
+    ...infer Tail
+] ? Head extends true ? true : Or<Tail> : false;
+/**
+ * @description Checks if {@link T} is `undefined`
+ * @param T - Type to check
+ * @example
+ * type Result = IsUndefined<undefined>
+ * //   ^? type Result = true
+ */
+export type IsUndefined<T> = [undefined] extends [T] ? true : false;
+export type MaybePromise<T> = T | Promise<T>;
+/**
+ * @description Makes attributes on the type T required if required is true.
+ *
+ * @example
+ * MaybeRequired<{ a: string, b?: number }, true>
+ * => { a: string, b: number }
+ *
+ * MaybeRequired<{ a: string, b?: number }, false>
+ * => { a: string, b?: number }
+ */
+export type MaybeRequired<T, required extends boolean> = required extends true ? ExactRequired<T> : T;
+export type ExactRequired<type> = {
+    [P in keyof type]-?: Exclude<type[P], undefined>;
+};
+/**
+ * @description Assigns the properties of U onto T.
+ *
+ * @example
+ * Assign<{ a: string, b: number }, { a: undefined, c: boolean }>
+ * => { a: undefined, b: number, c: boolean }
+ */
+export type Assign<T, U> = Assign_<T, U> & U;
+type Assign_<T, U> = {
+    [K in keyof T as K extends keyof U ? U[K] extends void ? never : K : K]: K extends keyof U ? U[K] : T[K];
+};
+/**
+ * @description Constructs a type by excluding `undefined` from `T`.
+ *
+ * @example
+ * NoUndefined<string | undefined>
+ * => string
+ *
+ * @internal
+ */
+export type NoUndefined<T> = T extends undefined ? never : T;
+/** Strict version of built-in Omit type */
+export type StrictOmit<type, keys extends keyof type> = Pick<type, Exclude<keyof type, keys>>;
+/**
+ * @description Creates a type that is a partial of T, but with the required keys K.
+ *
+ * @example
+ * PartialBy<{ a: string, b: number }, 'a'>
+ * => { a?: string, b: number }
+ */
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & ExactPartial<Pick<T, K>>;
+export type ExactPartial<type> = {
+    [key in keyof type]?: type[key] | undefined;
+};
+/**
+ * @description Creates a type that is T with the required keys K.
+ *
+ * @example
+ * RequiredBy<{ a?: string, b: number }, 'a'>
+ * => { a: string, b: number }
+ */
+export type RequiredBy<T, K extends keyof T> = Omit<T, K> & ExactRequired<Pick<T, K>>;
+/**
+ * @description Returns truthy if `array` contains `value`.
+ *
+ * @example
+ * Some<[1, 2, 3], 2>
+ * => true
+ */
+export type Some<array extends readonly unknown[], value> = array extends readonly [value, ...unknown[]] ? true : array extends readonly [unknown, ...infer rest] ? Some<rest, value> : false;
+/**
+ * @description Creates a type that extracts the values of T.
+ *
+ * @example
+ * ValueOf<{ a: string, b: number }>
+ * => string | number
+ *
+ * @internal
+ */
+export type ValueOf<T> = T[keyof T];
+/**
+ * @description Converts a union to a tuple.
+ *
+ * @example
+ * UnionToTuple<string | number | boolean>
+ * => [string, number, boolean]
+ *
+ */
+export type UnionToTuple<union, last = LastInUnion<union>> = [union] extends [never] ? [] : [...UnionToTuple<Exclude<union, last>>, last];
+type LastInUnion<U> = UnionToIntersection<U extends unknown ? (x: U) => 0 : never> extends (x: infer l) => 0 ? l : never;
+type UnionToIntersection<union> = (union extends unknown ? (arg: union) => 0 : never) extends (arg: infer i) => 0 ? i : never;
+export type IsUnion<union, union2 = union> = union extends union2 ? ([union2] extends [union] ? false : true) : never;
+export type MaybePartial<type, enabled extends boolean | undefined> = enabled extends true ? Prettify<ExactPartial<type>> : type;
+/**
+ * @description Creates a type that is a one of the keys of {@link union}.
+ *
+ * @example
+ * OneOf<{ a: string, b: number }, { a: string }>
+ * => { a: string, b?: number }
+ */
+export type OneOf<union extends object, fallback extends object | undefined = undefined, keys extends KeyofUnion<union> = KeyofUnion<union>> = union extends infer item ? Prettify<item & {
+    [key in Exclude<keys, keyof item>]?: fallback extends object ? key extends keyof fallback ? fallback[key] : undefined : undefined;
+}> : never;
+type KeyofUnion<type> = type extends type ? keyof type : never;
+export type UnionEvaluate<type> = type extends object ? Prettify<type> : type;
+export type UnionLooseOmit<type, keys extends string> = type extends any ? Omit<type, keys> : never;
+/**
+ * @description Construct a type with the properties of union type T except for those in type K.
+ * @example
+ * type Result = UnionStrictOmit<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * => { b: number } | { b: undefined, c: number }
+ */
+export type UnionStrictOmit<type, keys extends keyof type> = type extends any ? StrictOmit<type, keys> : never;
+/**
+ * @description Construct a type with the properties of union type T except for those in type K.
+ * @example
+ * type Result = UnionOmit<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * => { b: number } | { b: undefined, c: number }
+ */
+export type UnionPick<type, keys extends keyof type> = type extends any ? Pick<type, keys> : never;
+/**
+ * @description Creates a type that is a partial of T, but with the required keys K.
+ *
+ * @example
+ * UnionPartialBy<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * => { a?: string, b: number } | { a?: string, b: undefined, c: number }
+ */
+export type UnionPartialBy<T, K extends keyof T> = T extends any ? PartialBy<T, K> : never;
+/**
+ * @description Creates a type that is T with the required keys K.
+ *
+ * @example
+ * UnionRequiredBy<{ a?: string, b: number } | { a?: string, c?: number }, 'a'>
+ * => { a: string, b: number } | { a: string, c?: number }
+ */
+export type UnionRequiredBy<T, K extends keyof T> = T extends any ? RequiredBy<T, K> : never;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@argent/x-shared",
-  "version": "1.59.0",
+  "version": "1.61.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/argentlabs/x-shared.git"
@@ -55,7 +55,7 @@
     "@typescript-eslint/eslint-plugin": "8.18.0",
     "@typescript-eslint/parser": "8.18.0",
     "eslint": "8.57.1",
-    "eslint-config-prettier": "9.1.0",
+    "eslint-config-prettier": "10.0.1",
     "eslint-plugin-import": "2.31.0",
     "husky": "9.1.7",
     "lint-staged": "15.2.11",
@@ -66,7 +66,7 @@
     "typescript": "5.7.2",
     "vite": "6.0.3",
     "vite-plugin-dts": "4.3.0",
-    "vitest": "2.1.8"
+    "vitest": "3.0.5"
   },
   "dependencies": {
     "@argent/x-multicall": "^7.1.0",