@privy-io/node 0.1.0-alpha.2

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

@@ -0,0 +1,134 @@
+import { WalletRpcParams, WalletRpcResponse } from '../../resources';
+import { ReplaceParams, PrivyWalletsService } from './wallets';
+import { PrivyWalletsRpcInput } from './wallets';
+
+export class PrivyEthereumService {
+  private privyWalletsService: PrivyWalletsService;
+
+  constructor(privyWalletsService: PrivyWalletsService) {
+    this.privyWalletsService = privyWalletsService;
+  }
+
+  public async signMessage(
+    walletId: string,
+    { message, ...input }: PrivyEthereumService.SignMessageInput,
+  ): Promise<WalletRpcResponse.EthereumPersonalSignRpcResponse.Data> {
+    let params: WalletRpcParams.EthereumPersonalSignRpcInput.Params;
+    if (message instanceof Uint8Array) {
+      // We fall back to `Buffer` here as Uint8Array.toHex is not widely supported yet
+      params = { message: Buffer.from(message).toString('hex'), encoding: 'hex' };
+    } else if (message.startsWith('0x')) {
+      // The 0x prefix is removed as `encoding: hex` is sufficient
+      params = { message: message.slice(2), encoding: 'hex' };
+    } else {
+      params = { message, encoding: 'utf-8' };
+    }
+
+    const response = await this.privyWalletsService.rpc(walletId, {
+      ...input,
+      params,
+      method: 'personal_sign',
+      chain_type: 'ethereum',
+    });
+
+    return response.data;
+  }
+
+  public async signSecp256k1(
+    walletId: string,
+    input: PrivyEthereumService.SignSecp256k1Input,
+  ): Promise<WalletRpcResponse.EthereumSecp256k1SignRpcResponse.Data> {
+    const response = await this.privyWalletsService.rpc(walletId, {
+      ...input,
+      method: 'secp256k1_sign',
+      chain_type: 'ethereum',
+    });
+
+    return response.data;
+  }
+
+  public async sign7702Authorization(
+    walletId: string,
+    input: PrivyEthereumService.Sign7702AuthorizationInput,
+  ): Promise<WalletRpcResponse.EthereumSign7702AuthorizationRpcResponse.Data> {
+    const response = await this.privyWalletsService.rpc(walletId, {
+      ...input,
+      method: 'eth_sign7702Authorization',
+      chain_type: 'ethereum',
+    });
+
+    if (!response.data) {
+      throw new Error(response.error?.message ?? 'Unexpected response from Privy API');
+    }
+
+    return response.data;
+  }
+
+  public async signTransaction(
+    walletId: string,
+    input: PrivyEthereumService.SignTransactionInput,
+  ): Promise<WalletRpcResponse.EthereumSignTransactionRpcResponse.Data> {
+    const response = await this.privyWalletsService.rpc(walletId, {
+      ...input,
+      method: 'eth_signTransaction',
+      chain_type: 'ethereum',
+    });
+
+    return response.data;
+  }
+
+  public async signTypedData(
+    walletId: string,
+    input: PrivyEthereumService.SignTypedDataInput,
+  ): Promise<WalletRpcResponse.EthereumSignTypedDataRpcResponse.Data> {
+    const response = await this.privyWalletsService.rpc(walletId, {
+      ...input,
+      method: 'eth_signTypedData_v4',
+      chain_type: 'ethereum',
+    });
+
+    return response.data;
+  }
+
+  public async sendTransaction(
+    walletId: string,
+    input: PrivyEthereumService.SendTransactionInput,
+  ): Promise<WalletRpcResponse.EthereumSendTransactionRpcResponse.Data> {
+    const response = await this.privyWalletsService.rpc(walletId, {
+      ...input,
+      method: 'eth_sendTransaction',
+      chain_type: 'ethereum',
+    });
+
+    if (!response.data) {
+      throw new Error(response.error?.message ?? 'Unexpected response from Privy API');
+    }
+
+    return response.data;
+  }
+}
+
+// prettier-ignore
+/**
+ * The namespace for types related to the Ethereum service class.
+ * @see {@link PrivyEthereumService} class.
+ * @see {@link PrivyWalletsRpcInput} type.
+ */
+export namespace PrivyEthereumService {
+  /**
+   * The input type for the {@link PrivyEthereumService.signMessage} method.
+   * Instead of accepting the raw `params` object, it accepts a message `string` or `Uint8Array`
+   * that is automatically converted to the right `params` object.
+   */
+  export type SignMessageInput = ReplaceParams<PrivyWalletsRpcInput<WalletRpcParams.EthereumPersonalSignRpcInput>, {message: string | Uint8Array}>;
+  /** The input type for the {@link PrivyEthereumService.signSecp256k1} method. */
+  export type SignSecp256k1Input = PrivyWalletsRpcInput<WalletRpcParams.EthereumSecp256k1SignRpcInput>;
+  /** The input type for the {@link PrivyEthereumService.sign7702Authorization} method. */
+  export type Sign7702AuthorizationInput = PrivyWalletsRpcInput<WalletRpcParams.EthereumSign7702AuthorizationRpcInput>;
+  /** The input type for the {@link PrivyEthereumService.signTransaction} method. */
+  export type SignTransactionInput = PrivyWalletsRpcInput<WalletRpcParams.EthereumSignTransactionRpcInput>;
+  /** The input type for the {@link PrivyEthereumService.signTypedData} method. */
+  export type SignTypedDataInput = PrivyWalletsRpcInput<WalletRpcParams.EthereumSignTypedDataRpcInput>;
+  /** The input type for the {@link PrivyEthereumService.sendTransaction} method. */
+  export type SendTransactionInput = PrivyWalletsRpcInput<WalletRpcParams.EthereumSendTransactionRpcInput>;
+}

package/src/public-api/services/key-quorums.ts

@@ -0,0 +1,77 @@
+import { Prettify } from 'viem';
+import { PrivyAPI } from '../../client';
+import { generateAuthorizationSignatures } from '../../lib/authorization';
+import {
+  KeyQuorum,
+  KeyQuorumDeleteParams,
+  KeyQuorumDeleteResponse,
+  KeyQuorums,
+  KeyQuorumUpdateParams,
+} from '../../resources';
+import { PrivyClient } from '../PrivyClient';
+import { WithAuthorization } from './types';
+
+export class PrivyKeyQuorumsService extends KeyQuorums {
+  private privyClient: PrivyClient;
+
+  constructor(privyApiClient: PrivyAPI, privyClient: PrivyClient) {
+    super(privyApiClient);
+    this.privyClient = privyClient;
+  }
+
+  public async update(
+    keyQuorumId: string,
+    { authorization_context: authorizationContext = {}, ...params }: PrivyKeyQuorumsService.UpdateInput,
+  ): Promise<KeyQuorum> {
+    const authorizationSignaturesHeader = await generateAuthorizationSignatures(this.privyClient, {
+      authorizationContext,
+      input: {
+        version: 1,
+        method: 'PATCH',
+        url: `${this._client.baseURL}/v1/key_quorums/${keyQuorumId}`,
+        body: params,
+        headers: {
+          'privy-app-id': this._client.appID,
+        },
+      },
+    });
+
+    const response = await this._update(keyQuorumId, {
+      ...params,
+      'privy-authorization-signature': authorizationSignaturesHeader.join(','),
+    });
+
+    return response;
+  }
+
+  public async delete(
+    keyQuorumId: string,
+    { authorization_context: authorizationContext = {}, ...params }: PrivyKeyQuorumsService.DeleteInput,
+  ): Promise<KeyQuorumDeleteResponse> {
+    const authorizationSignaturesHeader = await generateAuthorizationSignatures(this.privyClient, {
+      authorizationContext,
+      input: {
+        version: 1,
+        method: 'DELETE',
+        url: `${this._client.baseURL}/v1/key_quorums/${keyQuorumId}`,
+        body: params,
+        headers: {
+          'privy-app-id': this._client.appID,
+        },
+      },
+    });
+
+    const response = await this._delete(keyQuorumId, {
+      ...params,
+      'privy-authorization-signature': authorizationSignaturesHeader.join(','),
+    });
+
+    return response;
+  }
+}
+export namespace PrivyKeyQuorumsService {
+  /** The input type for the {@link PrivyKeyQuorumsService.update} method. */
+  export type UpdateInput = Prettify<WithAuthorization<KeyQuorumUpdateParams>>;
+  /** The input type for the {@link PrivyKeyQuorumsService.delete} method. */
+  export type DeleteInput = Prettify<WithAuthorization<KeyQuorumDeleteParams>>;
+}

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

@@ -0,0 +1,175 @@
+import { Prettify } from 'viem';
+import { PrivyAPI } from '../../client';
+import { generateAuthorizationSignatures } from '../../lib/authorization';
+import {
+  Policies,
+  Policy,
+  PolicyCreateRuleParams,
+  PolicyCreateRuleResponse,
+  PolicyDeleteParams,
+  PolicyDeleteResponse,
+  PolicyDeleteRuleParams,
+  PolicyDeleteRuleResponse,
+  PolicyUpdateParams,
+  PolicyUpdateRuleParams,
+  PolicyUpdateRuleResponse,
+} from '../../resources';
+import { PrivyClient } from '../PrivyClient';
+import { WithAuthorization } from './types';
+
+export class PrivyPoliciesService extends Policies {
+  private privyClient: PrivyClient;
+
+  constructor(privyApiClient: PrivyAPI, privyClient: PrivyClient) {
+    super(privyApiClient);
+    this.privyClient = privyClient;
+  }
+
+  public async update(
+    policyId: string,
+    { authorization_context: authorizationContext = {}, ...params }: PrivyPoliciesService.UpdateInput,
+  ): Promise<Policy> {
+    const authorizationSignaturesHeader = await generateAuthorizationSignatures(this.privyClient, {
+      authorizationContext,
+      input: {
+        version: 1,
+        method: 'PATCH',
+        url: `${this._client.baseURL}/v1/policies/${policyId}`,
+        body: params,
+        headers: {
+          'privy-app-id': this._client.appID,
+        },
+      },
+    });
+
+    const response = await this._update(policyId, {
+      ...params,
+      'privy-authorization-signature': authorizationSignaturesHeader.join(','),
+    });
+
+    return response;
+  }
+
+  public async delete(
+    policyId: string,
+    { authorization_context: authorizationContext = {}, ...params }: PrivyPoliciesService.DeleteInput,
+  ): Promise<PolicyDeleteResponse> {
+    const authorizationSignaturesHeader = await generateAuthorizationSignatures(this.privyClient, {
+      authorizationContext,
+      input: {
+        version: 1,
+        method: 'DELETE',
+        url: `${this._client.baseURL}/v1/policies/${policyId}`,
+        body: params,
+        headers: {
+          'privy-app-id': this._client.appID,
+        },
+      },
+    });
+
+    const response = await this._delete(policyId, {
+      ...params,
+      'privy-authorization-signature': authorizationSignaturesHeader.join(','),
+    });
+
+    return response;
+  }
+
+  public async createRule(
+    policyId: string,
+    { authorization_context: authorizationContext = {}, ...params }: PrivyPoliciesService.CreateRuleInput,
+  ): Promise<PolicyCreateRuleResponse> {
+    const authorizationSignaturesHeader = await generateAuthorizationSignatures(this.privyClient, {
+      authorizationContext,
+      input: {
+        version: 1,
+        method: 'POST',
+        url: `${this._client.baseURL}/v1/policies/${policyId}/rules`,
+        body: params,
+        headers: {
+          'privy-app-id': this._client.appID,
+        },
+      },
+    });
+
+    const response = await this._createRule(policyId, {
+      ...params,
+      'privy-authorization-signature': authorizationSignaturesHeader.join(','),
+    });
+
+    return response;
+  }
+
+  public async updateRule(
+    ruleId: string,
+    {
+      authorization_context: authorizationContext = {},
+      policy_id: policyId,
+      ...params
+    }: PrivyPoliciesService.UpdateRuleInput,
+  ): Promise<PolicyUpdateRuleResponse> {
+    const authorizationSignaturesHeader = await generateAuthorizationSignatures(this.privyClient, {
+      authorizationContext,
+      input: {
+        version: 1,
+        method: 'PATCH',
+        url: `${this._client.baseURL}/v1/policies/${policyId}/rules/${ruleId}`,
+        body: params,
+        headers: {
+          'privy-app-id': this._client.appID,
+        },
+      },
+    });
+
+    const response = await this._updateRule(ruleId, {
+      ...params,
+      policy_id: policyId,
+      'privy-authorization-signature': authorizationSignaturesHeader.join(','),
+    });
+
+    return response;
+  }
+
+  public async deleteRule(
+    ruleId: string,
+    {
+      authorization_context: authorizationContext = {},
+      policy_id: policyId,
+      ...params
+    }: PrivyPoliciesService.DeleteRuleInput,
+  ): Promise<PolicyDeleteRuleResponse> {
+    const authorizationSignaturesHeader = await generateAuthorizationSignatures(this.privyClient, {
+      authorizationContext,
+      input: {
+        version: 1,
+        method: 'DELETE',
+        url: `${this._client.baseURL}/v1/policies/${policyId}/rules/${ruleId}`,
+        body: params,
+        headers: {
+          'privy-app-id': this._client.appID,
+        },
+      },
+    });
+
+    const response = await this._deleteRule(ruleId, {
+      ...params,
+      policy_id: policyId,
+      'privy-authorization-signature': authorizationSignaturesHeader.join(','),
+    });
+
+    return response;
+  }
+}
+
+export namespace PrivyPoliciesService {
+  /** The input type for the {@link PrivyPoliciesService.update} method. */
+  export type UpdateInput = Prettify<WithAuthorization<PolicyUpdateParams>>;
+  /** The input type for the {@link PrivyPoliciesService.delete} method. */
+  export type DeleteInput = Prettify<WithAuthorization<PolicyDeleteParams>>;
+  /** The input type for the {@link PrivyPoliciesService.createRule} method. */
+  export type CreateRuleInput = Prettify<WithAuthorization<PolicyCreateRuleParams>>;
+  /** The input type for the {@link PrivyPoliciesService.updateRule} method. */
+  export type UpdateRuleInput = Prettify<WithAuthorization<PolicyUpdateRuleParams>>;
+  /** The input type for the {@link PrivyPoliciesService.deleteRule} method. */
+  export type DeleteRuleInput = Prettify<WithAuthorization<PolicyDeleteRuleParams>>;
+}

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

@@ -0,0 +1,111 @@
+import { WalletRpcParams, WalletRpcResponse } from '../../resources';
+import { PrivyWalletsService, ReplaceParams } from './wallets';
+import { PrivyWalletsRpcInput } from './wallets';
+
+export class PrivySolanaService {
+  private privyWalletsService: PrivyWalletsService;
+
+  constructor(privyWalletsService: PrivyWalletsService) {
+    this.privyWalletsService = privyWalletsService;
+  }
+
+  public async signMessage(
+    walletId: string,
+    { message, ...input }: PrivySolanaService.SignMessageInput,
+  ): Promise<WalletRpcResponse.SolanaSignMessageRpcResponse.Data> {
+    let params: WalletRpcParams.SolanaSignMessageRpcInput.Params;
+    if (message instanceof Uint8Array) {
+      // We fall back to `Buffer` here as Uint8Array.toBase64 is not widely supported yet
+      params = { message: Buffer.from(message).toString('base64'), encoding: 'base64' };
+    } else {
+      // Strings are assumed to be base64 encoded
+      params = { message, encoding: 'base64' };
+    }
+
+    const response = await this.privyWalletsService.rpc(walletId, {
+      ...input,
+      method: 'signMessage',
+      chain_type: 'solana',
+      params,
+    });
+
+    return response.data;
+  }
+
+  public async signTransaction(
+    walletId: string,
+    { transaction, ...input }: PrivySolanaService.SignTransactionInput,
+  ): Promise<WalletRpcResponse.SolanaSignTransactionRpcResponse.Data> {
+    let params: WalletRpcParams.SolanaSignTransactionRpcInput.Params;
+    if (transaction instanceof Uint8Array) {
+      // We fall back to `Buffer` here as Uint8Array.toBase64 is not widely supported yet
+      params = { transaction: Buffer.from(transaction).toString('base64'), encoding: 'base64' };
+    } else {
+      // Strings are assumed to be base64 encoded
+      params = { transaction, encoding: 'base64' };
+    }
+
+    const response = await this.privyWalletsService.rpc(walletId, {
+      ...input,
+      method: 'signTransaction',
+      chain_type: 'solana',
+      params,
+    });
+
+    return response.data;
+  }
+
+  public async signAndSendTransaction(
+    walletId: string,
+    { transaction, ...input }: PrivySolanaService.SignAndSendTransactionInput,
+  ): Promise<WalletRpcResponse.SolanaSignAndSendTransactionRpcResponse.Data> {
+    let params: WalletRpcParams.SolanaSignAndSendTransactionRpcInput.Params;
+    if (transaction instanceof Uint8Array) {
+      // We fall back to `Buffer` here as Uint8Array.toBase64 is not widely supported yet
+      params = { transaction: Buffer.from(transaction).toString('base64'), encoding: 'base64' };
+    } else {
+      // Strings are assumed to be base64 encoded
+      params = { transaction, encoding: 'base64' };
+    }
+
+    const response = await this.privyWalletsService.rpc(walletId, {
+      ...input,
+      method: 'signAndSendTransaction',
+      chain_type: 'solana',
+      params,
+    });
+
+    if (!response.data) {
+      throw new Error(response.error?.message ?? 'Unexpected response from Privy API');
+    }
+
+    return response.data;
+  }
+}
+
+// prettier-ignore
+/**
+ * The namespace for types related to the Solana service class.
+ * @see {@link PrivySolanaService} class.
+ * @see {@link PrivyWalletsRpcInput} type.
+ */
+export namespace PrivySolanaService {
+  /**
+   * The input type for the {@link PrivySolanaService.signMessage} method.
+   * Instead of accepting the raw `params` object, it accepts a message `string` or `Uint8Array`
+   * that is automatically converted to the right `params` object.
+   */
+  export type SignMessageInput = ReplaceParams<PrivyWalletsRpcInput<WalletRpcParams.SolanaSignMessageRpcInput>, {message: string | Uint8Array}>;
+  /**
+   * The input type for the {@link PrivySolanaService.signTransaction} method.
+   * Instead of accepting the raw `params` object, it accepts a transaction `string` or `Uint8Array`
+   * that is automatically converted to the right `params` object.
+   */
+  export type SignTransactionInput = ReplaceParams<PrivyWalletsRpcInput<WalletRpcParams.SolanaSignTransactionRpcInput>, {transaction: string | Uint8Array}>;
+  /**
+   * The input type for the {@link PrivySolanaService.signAndSendTransaction} method.
+   * Instead of accepting the raw `params` object, it accepts a transaction `string` or `Uint8Array`
+   * that is automatically converted to the right `params` object.
+   */
+  export type SignAndSendTransactionInput = ReplaceParams<PrivyWalletsRpcInput<WalletRpcParams.SolanaSignAndSendTransactionRpcInput>, {transaction: string | Uint8Array}>;
+}

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

@@ -0,0 +1,3 @@
+import { Transactions } from '../../resources';
+
+export class PrivyTransactionsService extends Transactions {}

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

@@ -0,0 +1,50 @@
+import { AuthorizationContext } from '../../lib/authorization';
+
+/**
+ * Configuration object that can be set by the caller and is used to generate the right value for
+ * the `privy-authorization-signature` HTTP header.
+ */
+export type AuthorizationConfig = { authorization_context?: AuthorizationContext };
+type AuthParams = { 'privy-authorization-signature'?: any };
+// prettier-ignore
+/**
+ * Helper type that takes a parameters object (body & headers of an API request) and replaces the
+ * `privy-authorization-signature` HTTP header with the authorization config object.
+ *
+ * This is used to turn Params objects that accept the raw header value into ones that accept the
+ * more ergonomic config object instead.
+ */
+export type WithAuthorization<Params extends AuthParams> =
+  TheOmit<Params, keyof AuthParams> & AuthorizationConfig;
+
+/**
+ * Configuration object that can be set by the caller and is used to generate the right value for
+ * the `privy-idempotency-key` HTTP header.
+ */
+export type IdempotencyConfig = { idempotency_key?: string };
+type IdempotencyParams = { 'privy-idempotency-key'?: any };
+// prettier-ignore
+/**
+ * Helper type that takes a parameters object (body & headers of an API request) and replaces
+ * the `privy-idempotency-key` HTTP header with the idempotency config object.
+ *
+ * This is used to turn Params objects that accept the raw header value into ones that accept the
+ * more ergonomic config object instead.
+ */
+export type WithIdempotency<Params extends IdempotencyParams> =
+  TheOmit<Params, keyof IdempotencyParams> & IdempotencyConfig;
+
+/**
+ * `Omit` loses type info in unions like the `WalletRpcParams` type.
+ * @see https://github.com/microsoft/TypeScript/issues/54525
+ */
+type TheOmit<T, K extends keyof T> = { [P in keyof T as P extends K ? never : P]: T[P] };
+
+/**
+ * Utility type that takes an object type and makes the hover overlay more readable.
+ *
+ * [Learn more](https://www.totaltypescript.com/concepts/the-prettify-helper)
+ */
+export type Prettify<T> = {
+  [K in keyof T]: T[K];
+} & {};

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

@@ -0,0 +1,3 @@
+import { Users } from '../../resources';
+
+export class PrivyUsersService extends Users {}

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

@@ -0,0 +1,40 @@
+import {
+  formatRequestForAuthorizationSignature,
+  generateAuthorizationSignature,
+  generateAuthorizationSignatures,
+} from '../../lib/authorization';
+import { PrivyClient } from '../PrivyClient';
+
+export class PrivyUtils {
+  private privyClient: PrivyClient;
+
+  constructor(privyClient: PrivyClient) {
+    this.privyClient = privyClient;
+  }
+
+  // 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);
+  }
+}
+
+// prettier-ignore
+export namespace PrivyUtils {
+  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;