@coinbase/cdp-sdk 1.1.1 → 1.2.0

package/types/contract.ts

@@ -0,0 +1,126 @@
+/* eslint-disable */
+// Adapted from viem (https://github.com/wevm/viem)
+
+import type {
+  Abi,
+  AbiFunction,
+  AbiParametersToPrimitiveTypes,
+  AbiStateMutability,
+  Address,
+  ExtractAbiFunction,
+  ExtractAbiFunctionNames,
+  ResolvedRegister,
+} from "abitype";
+
+import type { Hex } from "./misc.js";
+import type { IsUnion, UnionToTuple } from "./utils.js";
+
+export type ContractFunctionName<
+  abi extends Abi | readonly unknown[] = Abi,
+  mutability extends AbiStateMutability = AbiStateMutability,
+> =
+  ExtractAbiFunctionNames<
+    abi extends Abi ? abi : Abi,
+    mutability
+  > extends infer functionName extends string
+    ? [functionName] extends [never]
+      ? string
+      : functionName
+    : string;
+
+export type ContractFunctionArgs<
+  abi extends Abi | readonly unknown[] = Abi,
+  mutability extends AbiStateMutability = AbiStateMutability,
+  functionName extends ContractFunctionName<abi, mutability> = ContractFunctionName<
+    abi,
+    mutability
+  >,
+> =
+  AbiParametersToPrimitiveTypes<
+    ExtractAbiFunction<abi extends Abi ? abi : Abi, functionName, mutability>["inputs"],
+    "inputs"
+  > extends infer args
+    ? [args] extends [never]
+      ? readonly unknown[]
+      : args
+    : readonly unknown[];
+
+export type Widen<type> =
+  | ([unknown] extends [type] ? unknown : never)
+  | (type extends Function ? type : never)
+  | (type extends ResolvedRegister["BigIntType"] ? bigint : never)
+  | (type extends boolean ? boolean : never)
+  | (type extends ResolvedRegister["IntType"] ? number : never)
+  | (type extends string
+      ? type extends ResolvedRegister["AddressType"]
+        ? ResolvedRegister["AddressType"]
+        : type extends ResolvedRegister["BytesType"]["inputs"]
+          ? ResolvedRegister["BytesType"]
+          : string
+      : never)
+  | (type extends readonly [] ? readonly [] : never)
+  | (type extends Record<string, unknown> ? { [K in keyof type]: Widen<type[K]> } : never)
+  | (type extends { length: number }
+      ? {
+          [K in keyof type]: Widen<type[K]>;
+        } extends infer Val extends readonly unknown[]
+        ? readonly [...Val]
+        : never
+      : never);
+
+export type UnionWiden<type> = type extends any ? Widen<type> : never;
+
+export type ExtractAbiFunctionForArgs<
+  abi extends Abi,
+  mutability extends AbiStateMutability,
+  functionName extends ContractFunctionName<abi, mutability>,
+  args extends ContractFunctionArgs<abi, mutability, functionName>,
+> =
+  ExtractAbiFunction<abi, functionName, mutability> extends infer abiFunction extends AbiFunction
+    ? IsUnion<abiFunction> extends true // narrow overloads using `args` by converting to tuple and filtering out overloads that don't match
+      ? UnionToTuple<abiFunction> extends infer abiFunctions extends readonly AbiFunction[]
+        ? // convert back to union (removes `never` tuple entries)
+          { [k in keyof abiFunctions]: CheckArgs<abiFunctions[k], args> }[number]
+        : never
+      : abiFunction
+    : never;
+type CheckArgs<
+  abiFunction extends AbiFunction,
+  args,
+  ///
+  targetArgs extends AbiParametersToPrimitiveTypes<
+    abiFunction["inputs"],
+    "inputs"
+  > = AbiParametersToPrimitiveTypes<abiFunction["inputs"], "inputs">,
+> = (readonly [] extends args ? readonly [] : args) extends targetArgs // fallback to `readonly []` if `args` has no value (e.g. `args` property not provided)
+  ? abiFunction
+  : never;
+
+export type ContractFunctionParameters<
+  abi extends Abi | readonly unknown[] = Abi,
+  mutability extends AbiStateMutability = AbiStateMutability,
+  functionName extends ContractFunctionName<abi, mutability> = ContractFunctionName<
+    abi,
+    mutability
+  >,
+  args extends ContractFunctionArgs<abi, mutability, functionName> = ContractFunctionArgs<
+    abi,
+    mutability,
+    functionName
+  >,
+  deployless extends boolean = false,
+  ///
+  allFunctionNames = ContractFunctionName<abi, mutability>,
+  allArgs = ContractFunctionArgs<abi, mutability, functionName>,
+  /*
+   * when `args` is inferred to `readonly []` ("inputs": []) or `never` (`abi` declared as `Abi` or not inferrable), allow `args` to be optional.
+   * important that both branches return same structural type
+   */
+> = {
+  abi: abi;
+  functionName:
+    | allFunctionNames // show all options
+    | (functionName extends allFunctionNames ? functionName : never); // infer value
+  args?: (abi extends Abi ? UnionWiden<args> : never) | allArgs | undefined;
+} & (readonly [] extends allArgs ? {} : { args: Widen<args> }) &
+  (deployless extends true ? { address?: undefined; code: Hex } : { address: Address });

package/types/misc.ts

@@ -0,0 +1,5 @@
+// Adapted from viem (https://github.com/wevm/viem)
+
+export type Hex = `0x${string}`;
+export type Hash = `0x${string}`;
+export type Address = `0x${string}`;

package/types/multicall.ts

@@ -0,0 +1,29 @@
+// Adapted from viem (https://github.com/wevm/viem)
+import type {
+  ContractFunctionArgs,
+  ContractFunctionName,
+  ContractFunctionParameters,
+} from "./contract.js";
+import type { Abi, AbiStateMutability } from "abitype";
+
+// infer contract parameters from `unknown`
+export type GetMulticallContractParameters<
+  contract,
+  mutability extends AbiStateMutability,
+> = contract extends { abi: infer abi extends Abi } // 1. Check if `abi` is const-asserted or defined inline
+  ? // 1a. Check if `functionName` is valid for `abi`
+    contract extends {
+      functionName: infer functionName extends ContractFunctionName<abi, mutability>;
+    }
+    ? // 1aa. Check if `args` is valid for `abi` and `functionName`
+      contract extends {
+        args: infer args extends ContractFunctionArgs<abi, mutability, functionName>;
+      }
+      ? ContractFunctionParameters<abi, mutability, functionName, args> // `args` valid, pass through
+      : ContractFunctionParameters<abi, mutability, functionName> // invalid `args`
+    : // 1b. `functionName` is invalid, check if `abi` is declared as `Abi`
+      Abi extends abi
+      ? ContractFunctionParameters // `abi` declared as `Abi`, unable to infer types further
+      : // `abi` is const-asserted or defined inline, infer types for `functionName` and `args`
+        ContractFunctionParameters<abi, mutability>
+  : ContractFunctionParameters<readonly unknown[]>; // invalid `contract['abi']`, set to `readonly unknown[]`

package/types/utils.ts

@@ -0,0 +1,288 @@
+/* eslint-disable */
+// Adapted from viem (https://github.com/wevm/viem)
+
+/**
+ * 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;
+
+/**
+ * @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];
+};
+
+// TODO: Remove when peer dep `typescript@>=4.5` (NoInfer is native)
+export type NoInfer<type> = [type][type extends any ? 0 : never];
+
+/**
+ * @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 Omit<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>>;
+
+/**
+ * @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];
+} & {};
+
+/** @internal */
+export type Evaluate<type> = {
+  [key in keyof type]: type[key];
+} & {};
+
+/**
+ * @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];
+
+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;
+
+export type ExactPartial<type> = {
+  [key in keyof type]?: type[key] | undefined;
+};
+
+export type ExactRequired<type> = {
+  [P in keyof type]-?: Exclude<type[P], undefined>;
+};
+
+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;
+
+///////////////////////////////////////////////////////////////////////////
+// Loose types
+
+/**
+ * Loose version of {@link Omit}
+ *
+ * @internal
+ */
+export type LooseOmit<type, keys extends string> = Pick<type, Exclude<keyof type, keys>>;
+
+///////////////////////////////////////////////////////////////////////////
+// Union types
+
+export type UnionEvaluate<type> = type extends object ? Prettify<type> : type;
+
+export type UnionLooseOmit<type, keys extends string> = type extends any
+  ? LooseOmit<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 UnionOmit<type, keys extends keyof type> = 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 = 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
+ * PartialBy<{ 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
+ * RequiredBy<{ 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;

package/utils/wait.ts

@@ -0,0 +1,52 @@
+import { TimeoutError } from "../errors.js";
+
+/**
+ * Options for the wait function
+ */
+export type WaitOptions = {
+  /** Interval between retries in seconds. Defaults to 0.2 */
+  intervalSeconds?: number;
+  /** Maximum time to wait before timing out in seconds. Defaults to 10 */
+  timeoutSeconds?: number;
+};
+
+/**
+ * Polls a resource until a terminal condition is met or timeout occurs.
+ *
+ * @param reload - Function that fetches the latest state of the resource
+ * @param isTerminal - Function that determines if the current state is terminal
+ * @param transform - Function that transforms the resource into a new type
+ * @param options - Configuration options for polling behavior
+ * @returns The resource in its terminal state
+ * @throws {TimeoutError} If the operation exceeds the timeout duration
+ *
+ * @example
+ * const result = await wait(
+ *   () => fetchOrderStatus(orderId),
+ *   (status) => status === 'completed',
+ *   (status) => status === 'completed' ? { status } : undefined,
+ *   { timeoutSeconds: 30 }
+ * );
+ */
+export async function wait<T, K = T>(
+  reload: () => Promise<T>,
+  isTerminal: (obj: T) => boolean,
+  transform: (obj: T) => K = (obj: T) => obj as unknown as K,
+  options: WaitOptions = {},
+): Promise<K> {
+  const { intervalSeconds = 0.2, timeoutSeconds = 10 } = options;
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < timeoutSeconds * 1000) {
+    const updatedObject = await reload();
+
+    if (isTerminal(updatedObject)) {
+      return transform(updatedObject);
+    }
+
+    await new Promise(resolve => setTimeout(resolve, intervalSeconds * 1000));
+  }
+  throw new TimeoutError(
+    `Operation has not reached a terminal state after ${timeoutSeconds} seconds and may still succeed. Retry with a longer timeout using the timeoutSeconds option.`,
+  );
+}

package/version.ts

@@ -0,0 +1 @@
+export const version = "1.2.0";

package/dist/auth/hooks/axios/index.d.ts

@@ -1 +0,0 @@
-export * from "./withAuth";

package/dist/auth/index.d.ts

@@ -1,4 +0,0 @@
-import * as axiosHooks from "./hooks/axios";
-export * from "./utils/http";
-export * from "./utils/jwt";
-export { axiosHooks };

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

@@ -1,2 +0,0 @@
-export * from "./http";
-export * from "./jwt";

package/dist/client/evm/index.d.ts

@@ -1 +0,0 @@
-export { EvmClient } from "./evm";

package/dist/client/evm/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EvmClient = void 0;
-var evm_1 = require("./evm");
-Object.defineProperty(exports, "EvmClient", { enumerable: true, get: function () { return evm_1.EvmClient; } });

package/dist/client/solana/index.d.ts

@@ -1 +0,0 @@
-export { SolanaClient } from "./solana";

package/dist/index.d.ts

@@ -1,3 +0,0 @@
-import "./analytics";
-export { CdpClient } from "./client/cdp";
-export { EvmServerAccount, EvmSmartAccount } from "./accounts/types";

package/dist/openapi-client/generated/evm-smart-accounts/evm-smart-accounts.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendUserOperation = exports.getUserOperation = exports.prepareUserOperation = exports.getEvmSmartAccount = exports.createEvmSmartAccount = exports.listEvmSmartAccounts = void 0;
-const cdpApiClient_1 = require("../../cdpApiClient");
-/**
-* Lists the Smart Accounts belonging to the developer's CDP Project.
-The response is paginated, and by default, returns 20 accounts per page.
-* @summary List Smart Accounts
-*/
-const listEvmSmartAccounts = (params, options) => {
-    return (0, cdpApiClient_1.cdpApiClient)({ url: `/v2/evm/smart-accounts`, method: 'GET',
-        params
-    }, options);
-};
-exports.listEvmSmartAccounts = listEvmSmartAccounts;
-/**
-* Creates a new Smart Account.
-* @summary Create a Smart Account
-*/
-const createEvmSmartAccount = (createEvmSmartAccountBody, options) => {
-    return (0, cdpApiClient_1.cdpApiClient)({ url: `/v2/evm/smart-accounts`, method: 'POST',
-        headers: { 'Content-Type': 'application/json', },
-        data: createEvmSmartAccountBody
-    }, options);
-};
-exports.createEvmSmartAccount = createEvmSmartAccount;
-/**
-* Gets a Smart Account by its address.
-* @summary Get a Smart Account by address
-*/
-const getEvmSmartAccount = (address, options) => {
-    return (0, cdpApiClient_1.cdpApiClient)({ url: `/v2/evm/smart-accounts/${address}`, method: 'GET'
-    }, options);
-};
-exports.getEvmSmartAccount = getEvmSmartAccount;
-/**
-* Prepares a new user operation on a Smart Account for a specific network.
-* @summary Prepare a user operation
-*/
-const prepareUserOperation = (address, prepareUserOperationBody, options) => {
-    return (0, cdpApiClient_1.cdpApiClient)({ url: `/v2/evm/smart-accounts/${address}/user-operations`, method: 'POST',
-        headers: { 'Content-Type': 'application/json', },
-        data: prepareUserOperationBody
-    }, options);
-};
-exports.prepareUserOperation = prepareUserOperation;
-/**
-* Gets a user operation by its hash.
-* @summary Get a user operation
-*/
-const getUserOperation = (address, userOpHash, options) => {
-    return (0, cdpApiClient_1.cdpApiClient)({ url: `/v2/evm/smart-accounts/${address}/user-operations/${userOpHash}`, method: 'GET'
-    }, options);
-};
-exports.getUserOperation = getUserOperation;
-/**
-* Sends a user operation with a signature.
-* @summary Send a user operation
-*/
-const sendUserOperation = (address, userOpHash, sendUserOperationBody, options) => {
-    return (0, cdpApiClient_1.cdpApiClient)({ url: `/v2/evm/smart-accounts/${address}/user-operations/${userOpHash}/send`, method: 'POST',
-        headers: { 'Content-Type': 'application/json', },
-        data: sendUserOperationBody
-    }, options);
-};
-exports.sendUserOperation = sendUserOperation;