@privy-io/node 0.1.0-alpha.2

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

@@ -0,0 +1,270 @@
+import { PrivyAPI } from '../../client';
+import { PrivyAPIError } from '../../core/error';
+import { generateAuthorizationSignatures } from '../../lib/authorization';
+import { setupHPKERecipient, setupHPKESender } from '../../lib/cryptography';
+import { entropyToBytes } from '../../lib/wallet-entropy';
+import {
+  Wallet,
+  WalletExportParams,
+  WalletRawSignParams,
+  WalletRawSignResponse,
+  WalletRpcParams,
+  WalletRpcResponse,
+  Wallets,
+  WalletSubmitImportParams,
+  WalletUpdateParams,
+} from '../../resources';
+import { PrivyClient } from '../PrivyClient';
+import { PrivyEthereumService } from './ethereum';
+import { PrivySolanaService } from './solana';
+import { Prettify, WithAuthorization, WithIdempotency } from './types';
+
+export class PrivyWalletsService extends Wallets {
+  private ethereumService: PrivyEthereumService;
+  private solanaService: PrivySolanaService;
+  private privyClient: PrivyClient;
+
+  constructor(privyApiClient: PrivyAPI, privyClient: PrivyClient) {
+    super(privyApiClient);
+    this.privyClient = privyClient;
+    this.ethereumService = new PrivyEthereumService(this);
+    this.solanaService = new PrivySolanaService(this);
+  }
+
+  public ethereum(): PrivyEthereumService {
+    return this.ethereumService;
+  }
+
+  public solana(): PrivySolanaService {
+    return this.solanaService;
+  }
+
+  public async rpc<Params extends PrivyWalletsService.RpcInput>(
+    walletId: string,
+    params: Params,
+  ): Promise<Extract<WalletRpcResponse, { method: Params['method'] }>>;
+  public async rpc(
+    walletId: string,
+    {
+      authorization_context: authorizationContext = {},
+      idempotency_key: idempotencyKey,
+      ...params
+    }: PrivyWalletsService.RpcInput,
+  ): Promise<WalletRpcResponse> {
+    const authorizationSignaturesHeader = await generateAuthorizationSignatures(this.privyClient, {
+      authorizationContext,
+      input: {
+        version: 1,
+        method: 'POST',
+        url: `${this._client.baseURL}/v1/wallets/${walletId}/rpc`,
+        body: params,
+        headers: {
+          'privy-app-id': this._client.appID,
+          ...(idempotencyKey && { 'privy-idempotency-key': idempotencyKey }),
+        },
+      },
+    });
+
+    return await this._rpc(walletId, {
+      ...params,
+      'privy-authorization-signature': authorizationSignaturesHeader.join(','),
+      ...(idempotencyKey && { 'privy-idempotency-key': idempotencyKey }),
+    });
+  }
+
+  public async rawSign(
+    walletId: string,
+    {
+      authorization_context: authorizationContext = {},
+      idempotency_key: idempotencyKey,
+      ...params
+    }: PrivyWalletsService.RawSignInput,
+  ): Promise<WalletRawSignResponse.Data> {
+    const authorizationSignaturesHeader = await generateAuthorizationSignatures(this.privyClient, {
+      authorizationContext,
+      input: {
+        version: 1,
+        method: 'POST',
+        url: `${this._client.baseURL}/v1/wallets/${walletId}/raw_sign`,
+        body: params,
+        headers: {
+          'privy-app-id': this._client.appID,
+          ...(idempotencyKey && { 'privy-idempotency-key': idempotencyKey }),
+        },
+      },
+    });
+
+    const response = await this._rawSign(walletId, {
+      ...params,
+      'privy-authorization-signature': authorizationSignaturesHeader.join(','),
+      ...(idempotencyKey && { 'privy-idempotency-key': idempotencyKey }),
+    });
+
+    return response.data;
+  }
+
+  public async update(
+    walletId: string,
+    { authorization_context: authorizationContext = {}, ...params }: PrivyWalletsService.UpdateInput,
+  ): Promise<Wallet> {
+    const authorizationSignaturesHeader = await generateAuthorizationSignatures(this.privyClient, {
+      authorizationContext,
+      input: {
+        version: 1,
+        method: 'PATCH',
+        url: `${this._client.baseURL}/v1/wallets/${walletId}`,
+        body: params,
+        headers: {
+          'privy-app-id': this._client.appID,
+        },
+      },
+    });
+
+    const response = await this._update(walletId, {
+      ...params,
+      'privy-authorization-signature': authorizationSignaturesHeader.join(','),
+    });
+
+    return response;
+  }
+
+  public async export(
+    walletId: string,
+    { authorization_context: authorizationContext = {}, ...outerParams }: PrivyWalletsService.ExportInput,
+  ): Promise<PrivyWalletsService.ExportResponse> {
+    const { publicKeySpki, decryptPayload } = await setupHPKERecipient();
+
+    const params: WalletExportParams = {
+      ...outerParams,
+      encryption_type: 'HPKE',
+      // We fall back to `Buffer` here as Uint8Array.toBase64 is not widely supported yet
+      recipient_public_key: Buffer.from(publicKeySpki).toString('base64'),
+    };
+
+    const authorizationSignaturesHeader = await generateAuthorizationSignatures(this.privyClient, {
+      authorizationContext,
+      input: {
+        version: 1,
+        method: 'POST',
+        url: `${this._client.baseURL}/v1/wallets/${walletId}/export`,
+        body: params,
+        headers: {
+          'privy-app-id': this._client.appID,
+        },
+      },
+    });
+
+    const response = await this._export(walletId, {
+      ...params,
+      'privy-authorization-signature': authorizationSignaturesHeader.join(','),
+    });
+    const decryptedPrivateKey = await decryptPayload(
+      // We fall back to `Buffer` here as Uint8Array.fromBase64 is not widely supported yet
+      Buffer.from(response.encapsulated_key, 'base64'),
+      Buffer.from(response.ciphertext, 'base64'),
+    );
+    const privateKey = new TextDecoder().decode(decryptedPrivateKey);
+
+    return { private_key: privateKey };
+  }
+
+  public async import({
+    wallet: { private_key, ...wallet },
+    ...params
+  }: PrivyWalletsService.ImportInput): Promise<Wallet> {
+    const hpkeSender = await setupHPKESender();
+
+    const privateKeyBytes = entropyToBytes({
+      entropy: private_key,
+      entropyType: wallet.entropy_type,
+      chainType: wallet.chain_type,
+    });
+
+    const initResponse = await this._initImport({
+      ...wallet,
+      encryption_type: 'HPKE',
+    });
+
+    if (initResponse.encryption_type !== 'HPKE') {
+      throw new PrivyAPIError(`Invalid encryption type: ${initResponse.encryption_type}`);
+    }
+
+    // We fall back to `Buffer` here as Uint8Array.fromBase64 is not widely supported yet
+    const encryptionPublicKey = Buffer.from(initResponse.encryption_public_key, 'base64');
+
+    const { encapsulatedKey, ciphertext } = await hpkeSender.encryptPayload(
+      encryptionPublicKey,
+      privateKeyBytes,
+    );
+
+    const submitResponse = await this._submitImport({
+      ...params,
+      wallet: {
+        ...wallet,
+        encryption_type: 'HPKE',
+        // We fall back to `Buffer` here as Uint8Array.toBase64 is not widely supported yet
+        encapsulated_key: Buffer.from(encapsulatedKey).toString('base64'),
+        ciphertext: Buffer.from(ciphertext).toString('base64'),
+      },
+    });
+
+    return submitResponse;
+  }
+}
+
+// prettier-ignore
+/**
+ * The namespace for types related to the Wallets service class.
+ * @see {@link PrivyWalletsService} class.
+ */
+export namespace PrivyWalletsService {
+  /** The input type for the {@link PrivyWalletsService.rpc} method. */
+  export type RpcInput = Prettify<WithIdempotency<WithAuthorization<WalletRpcParams>>>;
+  /** The input type for the {@link PrivyWalletsService.rawSign} method. */
+  export type RawSignInput = Prettify<WithIdempotency<WithAuthorization<WalletRawSignParams>>>;
+  /** The input type for the {@link PrivyWalletsService.update} method. */
+  export type UpdateInput = Prettify<WithAuthorization<WalletUpdateParams>>;
+  /** The input type for the {@link PrivyWalletsService.export} method. */
+  export type ExportInput = Prettify<WithAuthorization<Omit<WalletExportParams, 'encryption_type' | 'recipient_public_key'>>>;
+  /** The response type for the {@link PrivyWalletsService.export} method. */
+  export type ExportResponse = { private_key: string };
+  export type ImportInputWallet = Prettify<
+    (
+      | Omit<WalletSubmitImportParams.HDSubmitInput, 'encapsulated_key' | 'ciphertext' | 'encryption_type'>
+      | Omit<WalletSubmitImportParams.PrivateKeySubmitInput, 'encapsulated_key' | 'ciphertext' | 'encryption_type'>
+    ) & { private_key: Uint8Array | string }
+  >;
+  /** The input type for the {@link PrivyWalletsService.import} method. */
+  export type ImportInput = Prettify<
+    Omit<WalletSubmitImportParams, 'wallet'> &  {wallet: ImportInputWallet; }
+  >;
+}
+
+// prettier-ignore
+/**
+ * Helper type for the input to the RPC utility methods, such as `ethereum().signMessage()`.
+ * It modifies the raw input to the RPC method ({@link WalletRpcParams}) to:
+ * - Include the idempotency key string in place of the idempotency HTTP header via {@link WithIdempotency}
+ * - Include the authorization context over the authorization signature HTTP header via {@link WithAuthorization}
+ *
+ * Finally, it omits the `chain_type` and `method` properties from the input, as these will be
+ * internally set by the RPC utility method used.
+ * e.g. `ethereum().signMessage()` will set `chain_type=ethereum` and `method=personal_sign`.
+ */
+export type PrivyWalletsRpcInput<Params extends WalletRpcParams> =
+  Prettify<WithIdempotency<WithAuthorization<Omit<Params, 'chain_type'|'method'>>>>;
+
+// prettier-ignore
+/**
+ * Helper type that takes a parameters object and an extension object and returns a new parameters
+ * object with the extension object merged in, and the `params` property omitted.
+ *
+ * This is used to turn Params objects that accept the raw `params` object into ones that accept a
+ * more ergonomic extension object instead that can be used internally by Privy's service methods to
+ * turn into the right value for `params`.
+ *
+ * e.g. `ethereum().signMessage()` will accept a `message` string or `Uint8Array` that is
+ * automatically converted to the right `{ message: '...', encoding: '...' }` object.
+ */
+export type ReplaceParams<Params, Extension> =
+  Prettify<Omit<Params, 'params'> & Extension>;

package/src/resource.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from ./core/resource instead */
+export * from './core/resource';

package/src/resources/index.ts

@@ -0,0 +1,71 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export {
+  KeyQuorums,
+  type KeyQuorum,
+  type KeyQuorumDeleteResponse,
+  type KeyQuorumCreateParams,
+  type KeyQuorumDeleteParams,
+  type KeyQuorumUpdateParams,
+} from './key-quorums';
+export {
+  Policies,
+  type Policy,
+  type PolicyCreateRuleResponse,
+  type PolicyDeleteResponse,
+  type PolicyDeleteRuleResponse,
+  type PolicyUpdateRuleResponse,
+  type PolicyGetRuleResponse,
+  type PolicyCreateParams,
+  type PolicyCreateRuleParams,
+  type PolicyDeleteParams,
+  type PolicyDeleteRuleParams,
+  type PolicyUpdateParams,
+  type PolicyUpdateRuleParams,
+  type PolicyGetRuleParams,
+} from './policies';
+export { Transactions, type TransactionGetResponse } from './transactions';
+export {
+  Users,
+  type User,
+  type UserCreateParams,
+  type UserListParams,
+  type UserCreateCustomMetadataParams,
+  type UserGetByCustomAuthIDParams,
+  type UserGetByDiscordUsernameParams,
+  type UserGetByEmailAddressParams,
+  type UserGetByFarcasterIDParams,
+  type UserGetByGitHubUsernameParams,
+  type UserGetByPhoneNumberParams,
+  type UserGetBySmartWalletAddressParams,
+  type UserGetByTelegramUserIDParams,
+  type UserGetByTelegramUsernameParams,
+  type UserGetByTwitterSubjectParams,
+  type UserGetByTwitterUsernameParams,
+  type UserGetByWalletAddressParams,
+  type UserPregenerateWalletsParams,
+  type UserSearchParams,
+  type UserUnlinkLinkedAccountParams,
+  type UsersCursor,
+} from './users';
+export {
+  Wallets,
+  type Wallet,
+  type WalletExportResponse,
+  type WalletInitImportResponse,
+  type WalletRawSignResponse,
+  type WalletRpcResponse,
+  type WalletAuthenticateWithJwtResponse,
+  type WalletCreateWalletsWithRecoveryResponse,
+  type WalletCreateParams,
+  type WalletListParams,
+  type WalletExportParams,
+  type WalletInitImportParams,
+  type WalletRawSignParams,
+  type WalletRpcParams,
+  type WalletSubmitImportParams,
+  type WalletUpdateParams,
+  type WalletAuthenticateWithJwtParams,
+  type WalletCreateWalletsWithRecoveryParams,
+  type WalletsCursor,
+} from './wallets/wallets';

package/src/resources/key-quorums.ts

@@ -0,0 +1,177 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import { APIPromise } from '../core/api-promise';
+import { buildHeaders } from '../internal/headers';
+import { RequestOptions } from '../internal/request-options';
+import { path } from '../internal/utils/path';
+
+export class KeyQuorums extends APIResource {
+  /**
+   * Create a new key quorum.
+   *
+   * @example
+   * ```ts
+   * const keyQuorum = await client.keyQuorums.create();
+   * ```
+   */
+  create(body: KeyQuorumCreateParams, options?: RequestOptions): APIPromise<KeyQuorum> {
+    return this._client.post('/v1/key_quorums', { body, ...options });
+  }
+
+  /**
+   * Delete a key quorum by key quorum ID.
+   *
+   * @example
+   * ```ts
+   * const response = await client.keyQuorums._delete(
+   *   'key_quorum_id',
+   * );
+   * ```
+   */
+  _delete(
+    keyQuorumID: string,
+    params: KeyQuorumDeleteParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<KeyQuorumDeleteResponse> {
+    const { 'privy-authorization-signature': privyAuthorizationSignature } = params ?? {};
+    return this._client.delete(path`/v1/key_quorums/${keyQuorumID}`, {
+      ...options,
+      headers: buildHeaders([
+        {
+          ...(privyAuthorizationSignature != null ?
+            { 'privy-authorization-signature': privyAuthorizationSignature }
+          : undefined),
+        },
+        options?.headers,
+      ]),
+    });
+  }
+
+  /**
+   * Update a key quorum by key quorum ID.
+   *
+   * @example
+   * ```ts
+   * const keyQuorum = await client.keyQuorums._update(
+   *   'key_quorum_id',
+   * );
+   * ```
+   */
+  _update(
+    keyQuorumID: string,
+    params: KeyQuorumUpdateParams,
+    options?: RequestOptions,
+  ): APIPromise<KeyQuorum> {
+    const { 'privy-authorization-signature': privyAuthorizationSignature, ...body } = params;
+    return this._client.patch(path`/v1/key_quorums/${keyQuorumID}`, {
+      body,
+      ...options,
+      headers: buildHeaders([
+        {
+          ...(privyAuthorizationSignature != null ?
+            { 'privy-authorization-signature': privyAuthorizationSignature }
+          : undefined),
+        },
+        options?.headers,
+      ]),
+    });
+  }
+
+  /**
+   * Get a key quorum by ID.
+   *
+   * @example
+   * ```ts
+   * const keyQuorum = await client.keyQuorums.get(
+   *   'key_quorum_id',
+   * );
+   * ```
+   */
+  get(keyQuorumID: string, options?: RequestOptions): APIPromise<KeyQuorum> {
+    return this._client.get(path`/v1/key_quorums/${keyQuorumID}`, options);
+  }
+}
+
+export interface KeyQuorum {
+  id: string;
+
+  authorization_keys: Array<KeyQuorum.AuthorizationKey>;
+
+  authorization_threshold?: number;
+
+  display_name?: string;
+
+  user_ids?: Array<string>;
+}
+
+export namespace KeyQuorum {
+  export interface AuthorizationKey {
+    display_name: string | null;
+
+    public_key: string;
+  }
+}
+
+export interface KeyQuorumDeleteResponse {
+  /**
+   * Whether the key quorum was deleted successfully.
+   */
+  success: boolean;
+}
+
+export interface KeyQuorumCreateParams {
+  authorization_threshold?: number;
+
+  display_name?: string;
+
+  public_keys?: Array<string>;
+
+  user_ids?: Array<string>;
+}
+
+export interface KeyQuorumDeleteParams {
+  /**
+   * Request authorization signature. If multiple signatures are required, they
+   * should be comma separated.
+   */
+  'privy-authorization-signature'?: string;
+}
+
+export interface KeyQuorumUpdateParams {
+  /**
+   * Body param:
+   */
+  authorization_threshold?: number;
+
+  /**
+   * Body param:
+   */
+  display_name?: string;
+
+  /**
+   * Body param:
+   */
+  public_keys?: Array<string>;
+
+  /**
+   * Body param:
+   */
+  user_ids?: Array<string>;
+
+  /**
+   * Header param: Request authorization signature. If multiple signatures are
+   * required, they should be comma separated.
+   */
+  'privy-authorization-signature'?: string;
+}
+
+export declare namespace KeyQuorums {
+  export {
+    type KeyQuorum as KeyQuorum,
+    type KeyQuorumDeleteResponse as KeyQuorumDeleteResponse,
+    type KeyQuorumCreateParams as KeyQuorumCreateParams,
+    type KeyQuorumDeleteParams as KeyQuorumDeleteParams,
+    type KeyQuorumUpdateParams as KeyQuorumUpdateParams,
+  };
+}