@privy-io/node 0.1.0-alpha.2 → 0.1.0

package/src/public-api/services/utils/request-signer.ts

@@ -0,0 +1,35 @@
+import { generateAuthorizationSignature, generateAuthorizationSignatures } from '../../../lib/authorization';
+import { PrivyClient } from '../../PrivyClient';
+
+export class PrivyRequestSigner {
+  private privyClient: PrivyClient;
+
+  constructor(privyClient: PrivyClient) {
+    this.privyClient = privyClient;
+  }
+
+  // Expose these as methods here for convenience
+  public generateAuthorizationSignature = generateAuthorizationSignature;
+  public generateAuthorizationSignatures(...input: PrivyRequestSigner.GenerateAuthorizationSignaturesInput) {
+    // Pre-populates the client instance for the function
+    return generateAuthorizationSignatures(this.privyClient, ...input);
+  }
+}
+
+// prettier-ignore
+export namespace PrivyRequestSigner {
+  export type GenerateAuthorizationSignaturesInput = ParametersExceptFirst<typeof generateAuthorizationSignatures>;
+}
+
+/**
+ * Utility type similar to `Parameters` but excluding the first argument.
+ * This is used to get the types of the remaining arguments of a function, excluding the first one.
+ *
+ * @example
+ * ```ts
+ * type MyFunction = (arg0: string, arg1: number, arg2: boolean) => any;
+ * type MyFunctionParameters = ParametersExceptFirst<MyFunction>;
+ * // type MyFunctionParameters = [number, boolean]
+ * ```
+ */
+type ParametersExceptFirst<F> = F extends (arg0: any, ...rest: infer R) => any ? R : never;

package/src/public-api/services/utils.ts

@@ -1,40 +1,30 @@
-import {
-  formatRequestForAuthorizationSignature,
-  generateAuthorizationSignature,
-  generateAuthorizationSignatures,
-} from '../../lib/authorization';
+import { PrivyAppJWKS } from '../../lib/auth';
+import { PrivyAPI } from '../../client';
 import { PrivyClient } from '../PrivyClient';
+import { PrivyAuthUtils } from './utils/auth';
+import { PrivyRequestFormatter } from './utils/request-formatter';
+import { PrivyRequestSigner } from './utils/request-signer';
 
 export class PrivyUtils {
-  private privyClient: PrivyClient;
+  private _requestSigner: PrivyRequestSigner;
+  private _requestFormatter: PrivyRequestFormatter;
+  private _auth: PrivyAuthUtils;
 
-  constructor(privyClient: PrivyClient) {
-    this.privyClient = privyClient;
+  constructor(privyApiClient: PrivyAPI, privyClient: PrivyClient, appJwks: PrivyAppJWKS) {
+    this._requestSigner = new PrivyRequestSigner(privyClient);
+    this._requestFormatter = new PrivyRequestFormatter();
+    this._auth = new PrivyAuthUtils(privyApiClient, appJwks);
   }
 
-  // Expose these as methods here for convenience
-  public formatRequestForAuthorizationSignature = formatRequestForAuthorizationSignature;
-  public generateAuthorizationSignature = generateAuthorizationSignature;
-  public generateAuthorizationSignatures(...input: PrivyUtils.GenerateAuthorizationSignaturesInput) {
-    // Pre-populates the client instance for the function
-    return generateAuthorizationSignatures(this.privyClient, ...input);
+  public requestSigner(): PrivyRequestSigner {
+    return this._requestSigner;
   }
-}
 
-// prettier-ignore
-export namespace PrivyUtils {
-  export type GenerateAuthorizationSignaturesInput = ParametersExceptFirst<typeof generateAuthorizationSignatures>;
-}
+  public requestFormatter(): PrivyRequestFormatter {
+    return this._requestFormatter;
+  }
 
-/**
- * Utility type similar to `Parameters` but excluding the first argument.
- * This is used to get the types of the remaining arguments of a function, excluding the first one.
- *
- * @example
- * ```ts
- * type MyFunction = (arg0: string, arg1: number, arg2: boolean) => any;
- * type MyFunctionParameters = ParametersExceptFirst<MyFunction>;
- * // type MyFunctionParameters = [number, boolean]
- * ```
- */
-type ParametersExceptFirst<F> = F extends (arg0: any, ...rest: infer R) => any ? R : never;
+  public auth(): PrivyAuthUtils {
+    return this._auth;
+  }
+}

package/src/resources/index.ts

@@ -30,7 +30,6 @@ export {
   type User,
   type UserCreateParams,
   type UserListParams,
-  type UserCreateCustomMetadataParams,
   type UserGetByCustomAuthIDParams,
   type UserGetByDiscordUsernameParams,
   type UserGetByEmailAddressParams,
@@ -45,6 +44,7 @@ export {
   type UserGetByWalletAddressParams,
   type UserPregenerateWalletsParams,
   type UserSearchParams,
+  type UserSetCustomMetadataParams,
   type UserUnlinkLinkedAccountParams,
   type UsersCursor,
 } from './users';

package/src/resources/policies.ts

@@ -290,7 +290,8 @@ export interface Policy {
 
 export namespace Policy {
   /**
-   * The rules that apply to each method the policy covers.
+   * A rule that defines the conditions and action to take if the conditions are
+   * true.
    */
   export interface Rule {
     id: string;

package/src/resources/users.ts

@@ -58,34 +58,15 @@ export class Users extends APIResource {
     });
   }
 
-  /**
-   * Adds custom metadata to a user by user ID.
-   *
-   * @example
-   * ```ts
-   * const user = await client.users.createCustomMetadata(
-   *   'user_id',
-   *   { custom_metadata: { key: 'value' } },
-   * );
-   * ```
-   */
-  createCustomMetadata(
-    userID: string,
-    body: UserCreateCustomMetadataParams,
-    options?: RequestOptions,
-  ): APIPromise<User> {
-    return this._client.post(path`/v1/users/${userID}/custom_metadata`, { body, ...options });
-  }
-
   /**
    * Get a user by user ID.
    *
    * @example
    * ```ts
-   * const user = await client.users.get('user_id');
+   * const user = await client.users._get('user_id');
    * ```
    */
-  get(userID: string, options?: RequestOptions): APIPromise<User> {
+  _get(userID: string, options?: RequestOptions): APIPromise<User> {
     return this._client.get(path`/v1/users/${userID}`, options);
   }
 
@@ -293,6 +274,25 @@ export class Users extends APIResource {
     return this._client.post('/v1/users/search', { body, ...options });
   }
 
+  /**
+   * Adds custom metadata to a user by user ID.
+   *
+   * @example
+   * ```ts
+   * const user = await client.users.setCustomMetadata(
+   *   'user_id',
+   *   { custom_metadata: { key: 'value' } },
+   * );
+   * ```
+   */
+  setCustomMetadata(
+    userID: string,
+    body: UserSetCustomMetadataParams,
+    options?: RequestOptions,
+  ): APIPromise<User> {
+    return this._client.post(path`/v1/users/${userID}/custom_metadata`, { body, ...options });
+  }
+
   /**
    * Unlinks a user linked account.
    *
@@ -352,6 +352,7 @@ export interface User {
     | User.LinkedAccountSmartWallet
     | User.LinkedAccountPasskey
     | User.LinkedAccountFarcaster
+    | User.LinkedAccountTelegram
     | User.LinkedAccountEthereum
     | User.LinkedAccountEthereumEmbeddedWallet
     | User.LinkedAccountSolana
@@ -685,6 +686,26 @@ export namespace User {
     username?: string;
   }
 
+  export interface LinkedAccountTelegram {
+    first_verified_at: number | null;
+
+    latest_verified_at: number | null;
+
+    telegram_user_id: string;
+
+    type: 'telegram';
+
+    verified_at: number;
+
+    first_name?: string | null;
+
+    last_name?: string | null;
+
+    photo_url?: string | null;
+
+    username?: string | null;
+  }
+
   export interface LinkedAccountEthereum {
     address: string;
 
@@ -1152,13 +1173,6 @@ export namespace UserCreateParams {
 
 export interface UserListParams extends CursorParams {}
 
-export interface UserCreateCustomMetadataParams {
-  /**
-   * Custom metadata associated with the user.
-   */
-  custom_metadata: { [key: string]: string | number | boolean };
-}
-
 export interface UserGetByCustomAuthIDParams {
   custom_user_id: string;
 }
@@ -1258,6 +1272,13 @@ export declare namespace UserSearchParams {
   }
 }
 
+export interface UserSetCustomMetadataParams {
+  /**
+   * Custom metadata associated with the user.
+   */
+  custom_metadata: { [key: string]: string | number | boolean };
+}
+
 export interface UserUnlinkLinkedAccountParams {
   handle: string;
 
@@ -1292,7 +1313,6 @@ export declare namespace Users {
     type UsersCursor as UsersCursor,
     type UserCreateParams as UserCreateParams,
     type UserListParams as UserListParams,
-    type UserCreateCustomMetadataParams as UserCreateCustomMetadataParams,
     type UserGetByCustomAuthIDParams as UserGetByCustomAuthIDParams,
     type UserGetByDiscordUsernameParams as UserGetByDiscordUsernameParams,
     type UserGetByEmailAddressParams as UserGetByEmailAddressParams,
@@ -1307,6 +1327,7 @@ export declare namespace Users {
     type UserGetByWalletAddressParams as UserGetByWalletAddressParams,
     type UserPregenerateWalletsParams as UserPregenerateWalletsParams,
     type UserSearchParams as UserSearchParams,
+    type UserSetCustomMetadataParams as UserSetCustomMetadataParams,
     type UserUnlinkLinkedAccountParams as UserUnlinkLinkedAccountParams,
   };
 }

package/src/resources/wallets/wallets.ts

@@ -410,11 +410,9 @@ export namespace WalletRpcResponse {
   }
 
   export interface SolanaSignAndSendTransactionRpcResponse {
-    method: 'signAndSendTransaction';
-
-    data?: SolanaSignAndSendTransactionRpcResponse.Data;
+    data: SolanaSignAndSendTransactionRpcResponse.Data;
 
-    error?: SolanaSignAndSendTransactionRpcResponse.Error;
+    method: 'signAndSendTransaction';
   }
 
   export namespace SolanaSignAndSendTransactionRpcResponse {
@@ -425,12 +423,6 @@ export namespace WalletRpcResponse {
 
       transaction_id?: string;
     }
-
-    export interface Error {
-      code: string;
-
-      message: string;
-    }
   }
 
   export interface SolanaSignMessageRpcResponse {
@@ -462,11 +454,9 @@ export namespace WalletRpcResponse {
   }
 
   export interface EthereumSendTransactionRpcResponse {
-    method: 'eth_sendTransaction';
-
-    data?: EthereumSendTransactionRpcResponse.Data;
+    data: EthereumSendTransactionRpcResponse.Data;
 
-    error?: EthereumSendTransactionRpcResponse.Error;
+    method: 'eth_sendTransaction';
   }
 
   export namespace EthereumSendTransactionRpcResponse {
@@ -505,12 +495,6 @@ export namespace WalletRpcResponse {
         value?: string | number;
       }
     }
-
-    export interface Error {
-      code: string;
-
-      message: string;
-    }
   }
 
   export interface EthereumPersonalSignRpcResponse {
@@ -542,11 +526,9 @@ export namespace WalletRpcResponse {
   }
 
   export interface EthereumSign7702AuthorizationRpcResponse {
-    method: 'eth_sign7702Authorization';
-
-    data?: EthereumSign7702AuthorizationRpcResponse.Data;
+    data: EthereumSign7702AuthorizationRpcResponse.Data;
 
-    error?: EthereumSign7702AuthorizationRpcResponse.Error;
+    method: 'eth_sign7702Authorization';
   }
 
   export namespace EthereumSign7702AuthorizationRpcResponse {
@@ -569,12 +551,6 @@ export namespace WalletRpcResponse {
         y_parity: number;
       }
     }
-
-    export interface Error {
-      code: string;
-
-      message: string;
-    }
   }
 
   export interface EthereumSecp256k1SignRpcResponse {

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.1.0-alpha.2'; // x-release-please-version
+export const VERSION = '0.1.0'; // x-release-please-version

package/src/viem.ts

@@ -0,0 +1,223 @@
+import type { Hex } from 'viem';
+import {
+  type LocalAccount,
+  type SignMessageParameters,
+  type SignTransactionParameters,
+  toAccount,
+} from 'viem/accounts';
+import { toHex } from 'viem/utils';
+import { PrivyAPIError } from './core/error';
+import type { AuthorizationContext } from './lib/authorization';
+import type { PrivyClient } from './public-api/PrivyClient';
+import type { WalletRpcParams } from './resources';
+
+export interface CreateViemAccountInput {
+  /** ID for the wallet. */
+  walletId: string;
+  /** Ethereum address for the wallet. */
+  address: Hex;
+  /** Authorization context for the wallet. */
+  authorizationContext?: AuthorizationContext;
+}
+
+/**
+ * Creates a viem `Account` instance for a Privy wallet given its ID, which can be used to sign
+ * messages and send transactions with the wallet.
+ *
+ * @param client instance of the Privy client.
+ * @param input an object specifying the details of the wallet to create the viem account for.
+ * @returns viem `Account` instance for the wallet.
+ */
+export function createViemAccount(
+  client: PrivyClient,
+  { walletId, address, authorizationContext }: CreateViemAccountInput,
+): LocalAccount {
+  return toAccount({
+    address: address as Hex,
+    sign: async ({ hash }) => {
+      const response = await client
+        .wallets()
+        .ethereum()
+        .signSecp256k1(walletId, {
+          params: { hash },
+          ...(authorizationContext ? { authorization_context: authorizationContext } : {}),
+        });
+      return response.signature as `0x${string}`;
+    },
+    signMessage: async ({ message }) => {
+      const response = await client
+        .wallets()
+        .ethereum()
+        .signMessage(walletId, {
+          message: formatViemPersonalSignMessage(message),
+          ...(authorizationContext ? { authorization_context: authorizationContext } : {}),
+        });
+      return response.signature as `0x${string}`;
+    },
+    signTypedData: async (typedData) => {
+      const { message, domain, types, primaryType } = replaceBigInts(typedData, toHex);
+      // Viem accepts undefined `domain`, `message`, and `types` in this method
+      // though those are required per the EIP712 spec.
+      if (!domain) throw new PrivyAPIError('typedData.domain must be defined');
+      if (!message) throw new PrivyAPIError('typedData.message must be defined');
+      if (!types) throw new PrivyAPIError('typedData.message must be defined');
+      const { signature } = await client
+        .wallets()
+        .ethereum()
+        .signTypedData(walletId, {
+          params: {
+            typed_data: { domain, message, primary_type: primaryType as string, types: types as any },
+          },
+          ...(authorizationContext ? { authorization_context: authorizationContext } : {}),
+        });
+      return signature as Hex;
+    },
+    signTransaction: async (transaction) => {
+      const { signed_transaction: signedTransaction } = await client
+        .wallets()
+        .ethereum()
+        .signTransaction(walletId, {
+          params: { transaction: formatViemTransaction(transaction) },
+          ...(authorizationContext ? { authorization_context: authorizationContext } : {}),
+        });
+
+      return signedTransaction as Hex;
+    },
+    signAuthorization: async (parameters) => {
+      const { authorization } = await client
+        .wallets()
+        .ethereum()
+        .sign7702Authorization(walletId, {
+          params: {
+            contract: (parameters.contractAddress ?? parameters.address) as Hex,
+            chain_id: parameters.chainId,
+            nonce: parameters.nonce,
+          },
+          ...(authorizationContext ? { authorization_context: authorizationContext } : {}),
+        });
+      return {
+        address: authorization.contract as Hex,
+        nonce: Number(authorization.nonce),
+        chainId: Number(authorization.chain_id),
+        yParity: authorization.y_parity,
+        r: authorization.r as Hex,
+        s: authorization.s as Hex,
+      };
+    },
+  });
+}
+
+/**
+ * Formats a viem transaction type to the JSON-RPC transaction type:
+ * - 'legacy' -> 0
+ * - 'eip2930' -> 1
+ * - 'eip1559' or undefined -> 2. This is the default EVM transaction type.
+ * - 'eip4844' -> 3 in theory, but will throw an error as we do not support this yet.
+ * - 'eip7702' -> 4 in theory, but will throw an error as we do not support this yet
+ * @param type viem transaction type
+ * @returns 0 | 1 | 2
+ */
+const formatViemTransactionType = (type: SignTransactionParameters['transaction']['type']) => {
+  if (type === 'legacy') {
+    return 0 as const;
+  } else if (type === 'eip2930') {
+    return 1 as const;
+  } else if (type == 'eip1559' || typeof type === 'undefined') {
+    // Type 2 (EIP-1559) is the default transaction type
+    return 2 as const;
+  } else {
+    // We do not yet support EIP4844 (type 3) and EIP7702 (type 4) transaction types
+    throw new PrivyAPIError('EIP4844 and EIP7702 transaction types are not yet supported.');
+  }
+};
+
+/**
+ * Formats viem quantities, which are represented as `bigint | undefined` to our internal
+ * `Quantity` type. This is done by converting bigints into a hexstring.
+ *
+ * @param input {bigint | undefined} bigint quantity to format
+ * @returns input as hex string
+ */
+const formatViemQuantity = (input: bigint): Hex => {
+  return `0x${input.toString(16)}` as Hex;
+};
+
+/**
+ * Formats a `message` input to viem's `signMessage` function to the format needed for our wallet API.
+ *
+ * If the `message` is a string, we use it directly.
+ *
+ * If the `message` is an object containing a `raw` field, it indicates that the use case is signing raw bytes,
+ * in which case we convert `message.raw` into a `Uint8Array` before passing it to our own `signMessage`
+ * @param message input to viem's `signMessage` function
+ * @returns message as a utf-8 `string` or `Uint8Array`
+ */
+const formatViemPersonalSignMessage = (message: SignMessageParameters['message']): string | Uint8Array => {
+  if (typeof message === 'string') return message;
+
+  if (typeof message.raw === 'string') {
+    // We `.slice(2)` to remove the `0x` prefix
+    return Uint8Array.from(Buffer.from(message.raw.slice(2), 'hex'));
+  } else {
+    return message.raw;
+  }
+};
+
+/**
+ * Formats a viem transaction into our internal transaction type. For the most part, this converts
+ * bigints to hexstrings so they can be passed over the wire.
+ *
+ * @param tx input to viem's `sendTransaction` function
+ * @returns transaction {EthereumSignTransactionInputType} as our own type
+ */
+const formatViemTransaction = (
+  tx: SignTransactionParameters['transaction'],
+): WalletRpcParams.EthereumSignTransactionRpcInput.Params.Transaction => {
+  return {
+    type: formatViemTransactionType(tx.type),
+    ...(tx.to ? { to: tx.to } : {}),
+    ...(tx.nonce ? { nonce: tx.nonce } : {}),
+    ...(tx.chainId ? { chain_id: tx.chainId } : {}),
+    ...(tx.data ? { data: tx.data } : {}),
+    ...(tx.value ? { value: formatViemQuantity(tx.value) } : {}),
+    ...(tx.gas ? { gas_limit: formatViemQuantity(tx.gas) } : {}),
+    ...(tx.gasPrice ? { gas_price: formatViemQuantity(tx.gasPrice) } : {}),
+    ...(tx.maxFeePerGas ? { max_fee_per_gas: formatViemQuantity(tx.maxFeePerGas) } : {}),
+    ...(tx.maxPriorityFeePerGas ?
+      { max_priority_fee_per_gas: formatViemQuantity(tx.maxPriorityFeePerGas) }
+    : {}),
+  };
+};
+
+// replaceBigInts courtesy of ponder.sh:
+// https://github.com/ponder-sh/ponder/blob/bc65b865898b6145e87031314192c59f9e8b621f/packages/utils/src/replaceBigInts.ts
+type _ReplaceBigInts<
+  arr extends readonly unknown[],
+  type,
+  result extends readonly unknown[] = [],
+> = arr extends [infer first, ...infer rest] ?
+  _ReplaceBigInts<rest, type, readonly [...result, first extends bigint ? type : first]>
+: result;
+
+type ReplaceBigInts<obj, type> =
+  obj extends bigint ? type
+  : obj extends unknown[] ? _ReplaceBigInts<Readonly<obj>, type>
+  : obj extends readonly [] ? _ReplaceBigInts<obj, type>
+  : obj extends object ? { [key in keyof obj]: ReplaceBigInts<obj[key], type> }
+  : obj;
+
+const replaceBigInts = <const T, const type>(
+  obj: T,
+  replacer: (x: bigint) => type,
+): ReplaceBigInts<T, type> => {
+  if (typeof obj === 'bigint') return replacer(obj) as ReplaceBigInts<T, type>;
+  if (Array.isArray(obj)) {
+    return obj.map((x) => replaceBigInts(x, replacer)) as ReplaceBigInts<T, type>;
+  }
+  if (obj && typeof obj === 'object') {
+    return Object.fromEntries(
+      Object.entries(obj).map(([k, v]) => [k, replaceBigInts(v, replacer)]),
+    ) as ReplaceBigInts<T, type>;
+  }
+  return obj as ReplaceBigInts<T, type>;
+};

package/version.d.mts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.1.0-alpha.2";
+export declare const VERSION = "0.1.0";
 //# sourceMappingURL=version.d.mts.map

package/version.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"version.d.mts","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,kBAAkB,CAAC"}
+{"version":3,"file":"version.d.mts","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,UAAU,CAAC"}

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.1.0-alpha.2";
+export declare const VERSION = "0.1.0";
 //# sourceMappingURL=version.d.ts.map

package/version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,kBAAkB,CAAC"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,UAAU,CAAC"}

package/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
-exports.VERSION = '0.1.0-alpha.2'; // x-release-please-version
+exports.VERSION = '0.1.0'; // x-release-please-version
 //# sourceMappingURL=version.js.map

package/version.js.map

@@ -1 +1 @@
-{"version":3,"file":"version.js","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":";;;AAAa,QAAA,OAAO,GAAG,eAAe,CAAC,CAAC,2BAA2B"}
+{"version":3,"file":"version.js","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":";;;AAAa,QAAA,OAAO,GAAG,OAAO,CAAC,CAAC,2BAA2B"}

package/version.mjs

@@ -1,2 +1,2 @@
-export const VERSION = '0.1.0-alpha.2'; // x-release-please-version
+export const VERSION = '0.1.0'; // x-release-please-version
 //# sourceMappingURL=version.mjs.map

package/version.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"version.mjs","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,OAAO,GAAG,eAAe,CAAC,CAAC,2BAA2B"}
+{"version":3,"file":"version.mjs","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,2BAA2B"}

package/viem.d.mts

@@ -0,0 +1,22 @@
+import type { Hex } from 'viem';
+import { type LocalAccount } from 'viem/accounts';
+import type { AuthorizationContext } from "./lib/authorization.mjs";
+import type { PrivyClient } from "./public-api/PrivyClient.mjs";
+export interface CreateViemAccountInput {
+    /** ID for the wallet. */
+    walletId: string;
+    /** Ethereum address for the wallet. */
+    address: Hex;
+    /** Authorization context for the wallet. */
+    authorizationContext?: AuthorizationContext;
+}
+/**
+ * Creates a viem `Account` instance for a Privy wallet given its ID, which can be used to sign
+ * messages and send transactions with the wallet.
+ *
+ * @param client instance of the Privy client.
+ * @param input an object specifying the details of the wallet to create the viem account for.
+ * @returns viem `Account` instance for the wallet.
+ */
+export declare function createViemAccount(client: PrivyClient, { walletId, address, authorizationContext }: CreateViemAccountInput): LocalAccount;
+//# sourceMappingURL=viem.d.mts.map

package/viem.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viem.d.mts","sourceRoot":"","sources":["src/viem.ts"],"names":[],"mappings":"OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM;OACxB,EACL,KAAK,YAAY,EAIlB,MAAM,eAAe;OAGf,KAAK,EAAE,oBAAoB,EAAE;OAC7B,KAAK,EAAE,WAAW,EAAE;AAG3B,MAAM,WAAW,sBAAsB;IACrC,yBAAyB;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,uCAAuC;IACvC,OAAO,EAAE,GAAG,CAAC;IACb,4CAA4C;IAC5C,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CAC7C;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,WAAW,EACnB,EAAE,QAAQ,EAAE,OAAO,EAAE,oBAAoB,EAAE,EAAE,sBAAsB,GAClE,YAAY,CA0Ed"}

package/viem.d.ts

@@ -0,0 +1,22 @@
+import type { Hex } from 'viem';
+import { type LocalAccount } from 'viem/accounts';
+import type { AuthorizationContext } from "./lib/authorization.js";
+import type { PrivyClient } from "./public-api/PrivyClient.js";
+export interface CreateViemAccountInput {
+    /** ID for the wallet. */
+    walletId: string;
+    /** Ethereum address for the wallet. */
+    address: Hex;
+    /** Authorization context for the wallet. */
+    authorizationContext?: AuthorizationContext;
+}
+/**
+ * Creates a viem `Account` instance for a Privy wallet given its ID, which can be used to sign
+ * messages and send transactions with the wallet.
+ *
+ * @param client instance of the Privy client.
+ * @param input an object specifying the details of the wallet to create the viem account for.
+ * @returns viem `Account` instance for the wallet.
+ */
+export declare function createViemAccount(client: PrivyClient, { walletId, address, authorizationContext }: CreateViemAccountInput): LocalAccount;
+//# sourceMappingURL=viem.d.ts.map

package/viem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viem.d.ts","sourceRoot":"","sources":["src/viem.ts"],"names":[],"mappings":"OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM;OACxB,EACL,KAAK,YAAY,EAIlB,MAAM,eAAe;OAGf,KAAK,EAAE,oBAAoB,EAAE;OAC7B,KAAK,EAAE,WAAW,EAAE;AAG3B,MAAM,WAAW,sBAAsB;IACrC,yBAAyB;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,uCAAuC;IACvC,OAAO,EAAE,GAAG,CAAC;IACb,4CAA4C;IAC5C,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CAC7C;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,WAAW,EACnB,EAAE,QAAQ,EAAE,OAAO,EAAE,oBAAoB,EAAE,EAAE,sBAAsB,GAClE,YAAY,CA0Ed"}