@spectratools/tx-shared 0.4.2 → 0.4.3

package/README.md

@@ -56,7 +56,7 @@ export PRIVY_WALLET_ID="..."
 export PRIVY_AUTHORIZATION_KEY="..."
 ```
 
-> Privy signer execution is intentionally stubbed right now and throws `PRIVY_AUTH_FAILED` with a deterministic message. Full implementation is tracked in [issue #117](https://github.com/spectra-the-bot/spectra-tools/issues/117).
+> Privy signer resolution now performs wallet address lookup and exposes a Privy-backed account helper for `eth_sendTransaction` intents. Additional signing methods (for example `personal_sign` and typed-data) are tracked in [issue #117](https://github.com/spectra-the-bot/spectra-tools/issues/117).
 
 ## `resolveSigner()` usage
 
@@ -185,7 +185,7 @@ try {
   - ensure keystore is valid V3 JSON
 - **`PRIVY_AUTH_FAILED`**
   - verify all `PRIVY_*` variables are set
-  - note: provider is not live yet (see #117)
+  - check signer/owner policy constraints for the Privy wallet
 - **`GAS_ESTIMATION_FAILED` / `TX_REVERTED`**
   - validate function args and `value`
   - run with `dryRun: true` first

package/dist/index.d.ts

@@ -4,8 +4,8 @@ export { TxError, TxErrorCode, toTxError } from './errors.js';
 export { abstractMainnet, createAbstractClient } from './chain.js';
 export { DryRunResult, ExecuteTxOptions, executeTx } from './execute-tx.js';
 import { z } from 'incur';
+import { Account, Address, Hex, Hash } from 'viem';
 import { KeyObject } from 'node:crypto';
-import 'viem';
 
 /**
  * Resolve the active signer provider using deterministic precedence:
@@ -65,11 +65,17 @@ interface PrivyRpcIntentRequest {
     params: Record<string, unknown>;
     [key: string]: unknown;
 }
+type PrivyIntentStatus = 'pending' | 'executed' | 'failed' | 'expired' | 'rejected' | 'dismissed' | string;
 interface PrivyRpcIntentResponse {
     intent_id: string;
-    status: string;
+    status: PrivyIntentStatus;
     resource_id?: string;
     request_details?: Record<string, unknown>;
+    dismissal_reason?: string;
+    action_result?: {
+        response_body?: Record<string, unknown>;
+        [key: string]: unknown;
+    };
     [key: string]: unknown;
 }
 interface PrivyWalletResponse {
@@ -105,6 +111,30 @@ interface PrivyClient {
 }
 declare function createPrivyClient(options: CreatePrivyClientOptions): PrivyClient;
 
+type PrivyNumberish = bigint | number | string;
+interface PrivySendTransactionRequest {
+    to?: Address;
+    data?: Hex;
+    value?: PrivyNumberish;
+    nonce?: PrivyNumberish;
+    gas?: PrivyNumberish;
+    gasPrice?: PrivyNumberish;
+    maxFeePerGas?: PrivyNumberish;
+    maxPriorityFeePerGas?: PrivyNumberish;
+    chainId?: PrivyNumberish;
+    type?: number;
+}
+type PrivyAccount = Extract<Account, {
+    type: 'json-rpc';
+}> & {
+    sendTransaction: (request: PrivySendTransactionRequest) => Promise<Hash>;
+};
+interface CreatePrivyAccountOptions {
+    client: PrivyClient;
+    chainId?: number;
+}
+declare function createPrivyAccount(options: CreatePrivyAccountOptions): Promise<PrivyAccount>;
+
 type PrivyAuthorizationMethod = 'POST' | 'PUT' | 'PATCH' | 'DELETE';
 interface PrivyAuthorizationPayloadHeaders {
     'privy-app-id': string;
@@ -137,6 +167,7 @@ interface PrivySignerOptions {
     privyApiUrl?: string;
 }
 interface PrivySigner extends TxSigner {
+    account: PrivyAccount;
     provider: 'privy';
     privy: {
         appId: string;
@@ -148,9 +179,9 @@ interface PrivySigner extends TxSigner {
 /**
  * Create a Privy signer envelope with reusable transport and request-signing primitives.
  *
- * This initializes the shared client utilities used by tx-shared Privy integrations.
- * Transaction account execution is implemented in follow-up work for issue #191.
+ * The resolved account is backed by Privy RPC intents and includes a `sendTransaction`
+ * helper that submits `eth_sendTransaction` intents and returns the resulting tx hash.
  */
 declare function createPrivySigner(options: PrivySignerOptions): Promise<PrivySigner>;
 
-export { type KeystoreSignerOptions, type PrivyAuthorizationPayload, type PrivyAuthorizationPayloadHeaders, type PrivyClient, type PrivySigner, type PrivySignerOptions, type SignerEnv, type SignerFlags, SignerOptions, TxSigner, createKeystoreSigner, createPrivateKeySigner, createPrivyAuthorizationPayload, createPrivyClient, createPrivySigner, generatePrivyAuthorizationSignature, normalizePrivyApiUrl, parsePrivyAuthorizationKey, resolveSigner, serializePrivyAuthorizationPayload, signerEnvSchema, signerFlagSchema, toSignerOptions };
+export { type KeystoreSignerOptions, type PrivyAccount, type PrivyAuthorizationPayload, type PrivyAuthorizationPayloadHeaders, type PrivyClient, type PrivySendTransactionRequest, type PrivySigner, type PrivySignerOptions, type SignerEnv, type SignerFlags, SignerOptions, TxSigner, createKeystoreSigner, createPrivateKeySigner, createPrivyAccount, createPrivyAuthorizationPayload, createPrivyClient, createPrivySigner, generatePrivyAuthorizationSignature, normalizePrivyApiUrl, parsePrivyAuthorizationKey, resolveSigner, serializePrivyAuthorizationPayload, signerEnvSchema, signerFlagSchema, toSignerOptions };

package/dist/index.js

@@ -57,6 +57,223 @@ function createKeystoreSigner(options) {
   return { account, address: account.address, provider: "keystore" };
 }
 
+// src/signers/privy-account.ts
+import { isAddress } from "viem";
+var DEFAULT_CHAIN_ID = 2741;
+var HASH_REGEX = /^0x[a-fA-F0-9]{64}$/;
+async function createPrivyAccount(options) {
+  const wallet = await options.client.getWallet();
+  if (typeof wallet.address !== "string" || !isAddress(wallet.address)) {
+    throw new TxError(
+      "PRIVY_TRANSPORT_FAILED",
+      "Privy get wallet request failed: wallet address is missing or invalid"
+    );
+  }
+  const address = wallet.address;
+  const defaultChainId = options.chainId ?? DEFAULT_CHAIN_ID;
+  return {
+    address,
+    type: "json-rpc",
+    async sendTransaction(request) {
+      const chainId = normalizeChainId(request.chainId ?? defaultChainId);
+      const rpcRequest = createSendTransactionRpcRequest(address, chainId, request);
+      const response = await options.client.createRpcIntent(rpcRequest);
+      return parsePrivyTransactionHash(response);
+    }
+  };
+}
+function createSendTransactionRpcRequest(from, chainId, request) {
+  const transaction = {
+    from
+  };
+  if (request.to !== void 0) {
+    transaction.to = request.to;
+  }
+  if (request.data !== void 0) {
+    transaction.data = request.data;
+  }
+  if (request.value !== void 0) {
+    transaction.value = normalizeNumberish(request.value, "value");
+  }
+  if (request.nonce !== void 0) {
+    transaction.nonce = normalizeNumberish(request.nonce, "nonce");
+  }
+  if (request.gas !== void 0) {
+    transaction.gas_limit = normalizeNumberish(request.gas, "gas");
+  }
+  if (request.gasPrice !== void 0) {
+    transaction.gas_price = normalizeNumberish(request.gasPrice, "gasPrice");
+  }
+  if (request.maxFeePerGas !== void 0) {
+    transaction.max_fee_per_gas = normalizeNumberish(request.maxFeePerGas, "maxFeePerGas");
+  }
+  if (request.maxPriorityFeePerGas !== void 0) {
+    transaction.max_priority_fee_per_gas = normalizeNumberish(
+      request.maxPriorityFeePerGas,
+      "maxPriorityFeePerGas"
+    );
+  }
+  if (request.type !== void 0) {
+    transaction.type = request.type;
+  }
+  transaction.chain_id = chainId;
+  return {
+    method: "eth_sendTransaction",
+    caip2: `eip155:${chainId}`,
+    params: {
+      transaction
+    }
+  };
+}
+function parsePrivyTransactionHash(response) {
+  const intentId = response.intent_id;
+  if (response.status !== "executed") {
+    const reason = extractIntentReason(response) ?? "no reason provided";
+    if (response.status === "failed") {
+      throw new TxError("TX_REVERTED", `Privy rpc intent ${intentId} failed: ${reason}`);
+    }
+    if (response.status === "rejected" || response.status === "dismissed" || response.status === "expired") {
+      throw new TxError(
+        "PRIVY_AUTH_FAILED",
+        `Privy rpc intent ${intentId} ${response.status}: ${reason}`
+      );
+    }
+    throw new TxError(
+      "PRIVY_TRANSPORT_FAILED",
+      `Privy rpc intent ${intentId} did not execute (status: ${response.status})`
+    );
+  }
+  const hash = extractIntentHash(response);
+  if (hash === void 0 || !HASH_REGEX.test(hash)) {
+    throw new TxError(
+      "PRIVY_TRANSPORT_FAILED",
+      `Privy rpc intent ${intentId} executed without a valid transaction hash`
+    );
+  }
+  return hash;
+}
+function extractIntentHash(response) {
+  if (!isRecord(response.action_result)) {
+    return void 0;
+  }
+  const responseBody = response.action_result.response_body;
+  if (!isRecord(responseBody)) {
+    return void 0;
+  }
+  const data = responseBody.data;
+  if (!isRecord(data)) {
+    return void 0;
+  }
+  return typeof data.hash === "string" ? data.hash : void 0;
+}
+function extractIntentReason(response) {
+  if (typeof response.dismissal_reason === "string" && response.dismissal_reason.length > 0) {
+    return response.dismissal_reason;
+  }
+  if (isRecord(response.action_result)) {
+    const responseBody = response.action_result.response_body;
+    if (isRecord(responseBody)) {
+      const error = responseBody.error;
+      if (typeof error === "string" && error.length > 0) {
+        return error;
+      }
+      if (isRecord(error)) {
+        const errorMessage = error.message;
+        if (typeof errorMessage === "string" && errorMessage.length > 0) {
+          return errorMessage;
+        }
+      }
+      const message = responseBody.message;
+      if (typeof message === "string" && message.length > 0) {
+        return message;
+      }
+    }
+  }
+  return void 0;
+}
+function normalizeChainId(chainId) {
+  if (typeof chainId === "number") {
+    if (!Number.isInteger(chainId) || chainId <= 0) {
+      throw new TxError(
+        "PRIVY_TRANSPORT_FAILED",
+        "Failed to build Privy eth_sendTransaction payload: chainId must be a positive integer"
+      );
+    }
+    return chainId;
+  }
+  if (typeof chainId === "bigint") {
+    if (chainId <= 0n || chainId > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new TxError(
+        "PRIVY_TRANSPORT_FAILED",
+        "Failed to build Privy eth_sendTransaction payload: chainId must be a positive safe integer"
+      );
+    }
+    return Number(chainId);
+  }
+  const trimmed = chainId.trim();
+  if (trimmed.length === 0) {
+    throw new TxError(
+      "PRIVY_TRANSPORT_FAILED",
+      "Failed to build Privy eth_sendTransaction payload: chainId is empty"
+    );
+  }
+  if (/^0x[0-9a-fA-F]+$/.test(trimmed)) {
+    const parsed2 = Number.parseInt(trimmed.slice(2), 16);
+    if (!Number.isSafeInteger(parsed2) || parsed2 <= 0) {
+      throw new TxError(
+        "PRIVY_TRANSPORT_FAILED",
+        "Failed to build Privy eth_sendTransaction payload: chainId must be a positive safe integer"
+      );
+    }
+    return parsed2;
+  }
+  if (!/^[0-9]+$/.test(trimmed)) {
+    throw new TxError(
+      "PRIVY_TRANSPORT_FAILED",
+      "Failed to build Privy eth_sendTransaction payload: chainId must be a positive safe integer"
+    );
+  }
+  const parsed = Number(trimmed);
+  if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+    throw new TxError(
+      "PRIVY_TRANSPORT_FAILED",
+      "Failed to build Privy eth_sendTransaction payload: chainId must be a positive safe integer"
+    );
+  }
+  return parsed;
+}
+function normalizeNumberish(value, fieldName) {
+  if (typeof value === "bigint") {
+    if (value < 0n) {
+      throw new TxError(
+        "PRIVY_TRANSPORT_FAILED",
+        `Failed to build Privy eth_sendTransaction payload: ${fieldName} cannot be negative`
+      );
+    }
+    return value.toString(10);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new TxError(
+        "PRIVY_TRANSPORT_FAILED",
+        `Failed to build Privy eth_sendTransaction payload: ${fieldName} must be a non-negative number`
+      );
+    }
+    return Number.isInteger(value) ? value : value.toString();
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    throw new TxError(
+      "PRIVY_TRANSPORT_FAILED",
+      `Failed to build Privy eth_sendTransaction payload: ${fieldName} is empty`
+    );
+  }
+  return trimmed;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
 // src/signers/privy-signature.ts
 import { createPrivateKey, sign as signWithCrypto } from "crypto";
 var PRIVY_AUTHORIZATION_KEY_PREFIX = "wallet-auth:";
@@ -319,7 +536,7 @@ async function sendPrivyRequest(options) {
       `Privy ${options.operation} request failed (${response.status}): ${message}`
     );
   }
-  if (!isRecord(payload)) {
+  if (!isRecord2(payload)) {
     throw new TxError(
       "PRIVY_TRANSPORT_FAILED",
       `Privy ${options.operation} request failed: invalid JSON response shape`
@@ -342,11 +559,11 @@ async function parseJsonResponse(response, operation) {
     );
   }
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 function extractPrivyErrorMessage(payload) {
-  if (!isRecord(payload)) {
+  if (!isRecord2(payload)) {
     return void 0;
   }
   const directMessage = payload.message;
@@ -357,7 +574,7 @@ function extractPrivyErrorMessage(payload) {
   if (typeof errorValue === "string" && errorValue.length > 0) {
     return errorValue;
   }
-  if (isRecord(errorValue)) {
+  if (isRecord2(errorValue)) {
     const nestedMessage = errorValue.message;
     if (typeof nestedMessage === "string" && nestedMessage.length > 0) {
       return nestedMessage;
@@ -367,7 +584,6 @@ function extractPrivyErrorMessage(payload) {
 }
 
 // src/signers/privy.ts
-import { zeroAddress } from "viem";
 var REQUIRED_FIELDS = [
   "privyAppId",
   "privyWalletId",
@@ -418,10 +634,9 @@ async function createPrivySigner(options) {
     authorizationKey,
     apiUrl
   });
-  const account = {
-    address: zeroAddress,
-    type: "json-rpc"
-  };
+  const account = await createPrivyAccount({
+    client
+  });
   return {
     provider: "privy",
     account,
@@ -507,6 +722,7 @@ export {
   createAbstractClient,
   createKeystoreSigner,
   createPrivateKeySigner,
+  createPrivyAccount,
   createPrivyAuthorizationPayload,
   createPrivyClient,
   createPrivySigner,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spectratools/tx-shared",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "Shared transaction primitives, signer types, and chain config for spectra tools",
   "type": "module",
   "license": "MIT",