@privy-io/node 0.6.2 → 0.7.0

package/src/resources/wallets/index.ts

@@ -10,6 +10,12 @@ export {
   type WalletChainType,
   type ExtendedChainType,
   type WalletCustodian,
+  type CustodialWalletProvider,
+  type CustodialWalletChainType,
+  type CustodialWalletCreateInput,
+  type CustodialWallet,
+  type HpkeImportConfig,
+  type SuiCommandName,
   type EthereumPersonalSignRpcInput,
   type EthereumSignTransactionRpcInput,
   type EthereumSendTransactionRpcInput,

package/src/resources/wallets/wallets.ts

@@ -17,7 +17,7 @@ export class Wallets extends APIResource {
   balance: BalanceAPI.Balance = new BalanceAPI.Balance(this._client);
 
   /**
-   * Create a new wallet.
+   * Creates a new wallet on the requested chain and for the requested owner.
    *
    * @example
    * ```ts
@@ -399,6 +399,108 @@ export interface WalletCustodian {
   name: string;
 }
 
+/**
+ * The provider of the custodial wallet.
+ */
+export type CustodialWalletProvider = 'bridge';
+
+/**
+ * The chain type of the custodial wallet.
+ */
+export type CustodialWalletChainType = 'ethereum';
+
+/**
+ * The input for creating a custodial wallet.
+ */
+export interface CustodialWalletCreateInput {
+  /**
+   * The chain type of the custodial wallet.
+   */
+  chain_type: CustodialWalletChainType;
+
+  /**
+   * The provider of the custodial wallet.
+   */
+  provider: CustodialWalletProvider;
+
+  /**
+   * The resource ID of the beneficiary of the custodial wallet, given by the
+   * licensing provider.
+   */
+  provider_user_id: string;
+
+  additional_signers?: Array<CustodialWalletCreateInput.AdditionalSigner>;
+
+  owner?: CustodialWalletCreateInput.UserID | CustodialWalletCreateInput.PublicKey | null;
+
+  policy_ids?: Array<string>;
+}
+
+export namespace CustodialWalletCreateInput {
+  export interface AdditionalSigner {
+    signer_id: string;
+
+    override_policy_ids?: Array<string>;
+  }
+
+  export interface UserID {
+    user_id: string;
+  }
+
+  export interface PublicKey {
+    public_key: string;
+  }
+}
+
+/**
+ * Information about a custodial wallet.
+ */
+export interface CustodialWallet {
+  id: string;
+
+  address: string;
+
+  /**
+   * The chain type of the custodial wallet.
+   */
+  chainType: CustodialWalletChainType;
+
+  /**
+   * The provider of the custodial wallet.
+   */
+  provider: CustodialWalletProvider;
+}
+
+/**
+ * Optional HPKE configuration for wallet import decryption. These parameters allow
+ * importing wallets encrypted by external providers that use different HPKE
+ * configurations.
+ */
+export interface HpkeImportConfig {
+  /**
+   * Additional Authenticated Data (AAD) used during encryption. Should be
+   * base64-encoded bytes.
+   */
+  aad?: string;
+
+  /**
+   * The AEAD algorithm used for encryption. Defaults to CHACHA20_POLY1305 if not
+   * specified.
+   */
+  aead_algorithm?: 'CHACHA20_POLY1305' | 'AES_GCM256';
+
+  /**
+   * Application-specific context information (INFO) used during HPKE encryption.
+   * Should be base64-encoded bytes.
+   */
+  info?: string;
+}
+
+/**
+ * SUI transaction commands allowlist for raw_sign endpoint policy evaluation
+ */
+export type SuiCommandName = 'TransferObjects' | 'SplitCoins' | 'MergeCoins';
+
 /**
  * Executes the EVM `personal_sign` RPC (EIP-191) to sign a message.
  */
@@ -1252,12 +1354,12 @@ export namespace WalletRawSignParams {
     /**
      * The encoding scheme for the bytes.
      */
-    encoding: 'utf-8' | 'hex';
+    encoding: 'utf-8' | 'hex' | 'base64';
 
     /**
      * The hash function to hash the bytes.
      */
-    hash_function: 'keccak256' | 'sha256';
+    hash_function: 'keccak256' | 'sha256' | 'blake2b256';
   }
 }
 
@@ -1861,6 +1963,13 @@ export namespace WalletSubmitImportParams {
      * The index of the wallet to import.
      */
     index: number;
+
+    /**
+     * Optional HPKE configuration for wallet import decryption. These parameters allow
+     * importing wallets encrypted by external providers that use different HPKE
+     * configurations.
+     */
+    hpke_config?: WalletsAPI.HpkeImportConfig;
   }
 
   export interface PrivateKeySubmitInput {
@@ -1892,6 +2001,13 @@ export namespace WalletSubmitImportParams {
     encryption_type: 'HPKE';
 
     entropy_type: 'private-key';
+
+    /**
+     * Optional HPKE configuration for wallet import decryption. These parameters allow
+     * importing wallets encrypted by external providers that use different HPKE
+     * configurations.
+     */
+    hpke_config?: WalletsAPI.HpkeImportConfig;
   }
 
   export interface AdditionalSigner {
@@ -2055,6 +2171,12 @@ export declare namespace Wallets {
     type WalletChainType as WalletChainType,
     type ExtendedChainType as ExtendedChainType,
     type WalletCustodian as WalletCustodian,
+    type CustodialWalletProvider as CustodialWalletProvider,
+    type CustodialWalletChainType as CustodialWalletChainType,
+    type CustodialWalletCreateInput as CustodialWalletCreateInput,
+    type CustodialWallet as CustodialWallet,
+    type HpkeImportConfig as HpkeImportConfig,
+    type SuiCommandName as SuiCommandName,
     type EthereumPersonalSignRpcInput as EthereumPersonalSignRpcInput,
     type EthereumSignTransactionRpcInput as EthereumSignTransactionRpcInput,
     type EthereumSendTransactionRpcInput as EthereumSendTransactionRpcInput,

package/src/solana-kit.ts

@@ -0,0 +1,148 @@
+import {
+  getBase64EncodedWireTransaction,
+  getTransactionDecoder,
+  type Address,
+  type SignatureBytes,
+} from '@solana/kit';
+import { base58, base64 } from '@scure/base';
+import type {
+  MessagePartialSigner,
+  TransactionPartialSigner,
+  TransactionSendingSigner,
+} from '@solana/signers';
+import type { AuthorizationContext } from './lib/authorization';
+import type { PrivyClient } from './public-api/PrivyClient';
+
+export interface CreateSolanaKitSignerInput {
+  /** ID for the wallet. */
+  walletId: string;
+  /** Solana address for the wallet. */
+  address: Address;
+  /** Authorization context for the wallet. */
+  authorizationContext?: AuthorizationContext;
+  /**
+   * CAIP-2 for the Solana network.
+   * @optional This field is only required for sending transactions.
+   */
+  caip2?: string;
+}
+
+/**
+ * Defines a signer that uses a {@link PrivyClient} to sign messages and transactions.
+ *
+ * It implements the {@link MessagePartialSigner}, {@link TransactionPartialSigner},
+ * and {@link TransactionSendingSigner} interfaces and keeps track of the ID of the
+ * wallet used to sign them.
+ */
+export type SolanaKitSigner = MessagePartialSigner &
+  TransactionPartialSigner &
+  TransactionSendingSigner &
+  Readonly<{ walletId: string; address: Address }>;
+
+/**
+ * Creates a {@link SolanaKitSigner} from a provided Privy wallet and authorization context.
+ *
+ * The returned signer implements:
+ * - {@link MessagePartialSigner} - for signing messages via `signMessages`
+ * - {@link TransactionPartialSigner} - for signing transactions via `signTransactions`
+ * - {@link TransactionSendingSigner} - for signing and sending transactions via `signAndSendTransactions`
+ *
+ * And it keeps track of the `walletId` used to sign them.
+ *
+ * @example
+ * ```ts
+ * import { PrivyClient } from '@privy-io/node';
+ * import { createSolanaKitSigner } from '@privy-io/node/solana-kit';
+ * import { address } from '@solana/kit';
+ *
+ * const client = new PrivyClient({ appId: '...', appSecret: '...' });
+ * const signer = createSolanaKitSigner(client, {
+ *   walletId: 'wallet-id',
+ *   address: address('...'),
+ * });
+ * ```
+ */
+export function createSolanaKitSigner(
+  client: PrivyClient,
+  { walletId, address, authorizationContext, caip2 }: CreateSolanaKitSignerInput,
+): SolanaKitSigner {
+  const authCtxOptions = authorizationContext ? { authorization_context: authorizationContext } : {};
+  return {
+    address,
+    walletId,
+
+    async signMessages(messages) {
+      return await Promise.all(
+        messages.map(async (message) => {
+          const response = await client
+            .wallets()
+            .solana()
+            .signMessage(walletId, {
+              message: message.content,
+              ...authCtxOptions,
+            });
+
+          // We assert the signature is valid by casting to `SignatureBytes`
+          const signatureBytes = base64.decode(response.signature) as SignatureBytes;
+          return {
+            [address]: signatureBytes,
+          };
+        }),
+      );
+    },
+
+    async signTransactions(transactions) {
+      return await Promise.all(
+        transactions.map(async (transaction) => {
+          // Convert compiled transaction to wire format base64
+          const transactionBase64 = getBase64EncodedWireTransaction(transaction);
+
+          const response = await client
+            .wallets()
+            .solana()
+            .signTransaction(walletId, {
+              transaction: transactionBase64,
+              ...authCtxOptions,
+            });
+
+          const signedTransactionBytes = base64.decode(response.signed_transaction);
+          const decoder = getTransactionDecoder();
+          const signedTransaction = decoder.decode(signedTransactionBytes);
+
+          return {
+            // We assert the signature exists by asserting as non-null
+            [address]: signedTransaction.signatures[address]!,
+          };
+        }),
+      );
+    },
+
+    async signAndSendTransactions(transactions) {
+      if (!caip2) {
+        throw new Error(
+          'CAIP-2 is required for sending transactions. Please provide one in the createSolanaKitSigner input.',
+        );
+      }
+
+      return await Promise.all(
+        transactions.map(async (transaction) => {
+          // Convert compiled transaction to wire format base64
+          const transactionBase64 = getBase64EncodedWireTransaction(transaction);
+
+          const response = await client
+            .wallets()
+            .solana()
+            .signAndSendTransaction(walletId, {
+              transaction: transactionBase64,
+              caip2,
+              ...authCtxOptions,
+            });
+
+          // The hash returned is base58-encoded, convert to bytes
+          // and cast as a SignatureBytes, asserting it is a valid signature.
+          return base58.decode(response.hash) as SignatureBytes;
+        }),
+      );
+    },
+  };
+}

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.6.2'; // x-release-please-version
+export const VERSION = '0.7.0'; // x-release-please-version

package/version.d.mts

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

package/version.d.ts

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

package/version.js

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

package/version.mjs

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