@hwlt/era-connect 0.1.0

package/dist/verify.d.cts

@@ -0,0 +1,162 @@
+import { n as EvmDataType } from "./evm-DJxGGAbD.cjs";
+import { n as TronLatestBlock, t as SignedTronTx } from "./messages-DsPvW8Oi.cjs";
+//#region src/verify/result.d.ts
+/** Outcome of a verification helper. Helpers return, never throw, on mismatches. */
+type VerifyResult =
+/** Verified cryptographically / byte-for-byte. */
+{
+  readonly ok: true;
+  readonly checked: true;
+} |
+/**
+ * Nothing client-side is verifiable for this input (EIP-712 typed data:
+ * the digest is the hash of the structure, which only the device computes).
+ * The UR-type pin and the request-id echo are the whole binding.
+ */
+{
+  readonly ok: true;
+  readonly checked: false;
+  readonly reason: string;
+} | {
+  readonly ok: false;
+  readonly reason: string;
+};
+//#endregion
+//#region src/verify/btc.d.ts
+interface VerifySignedPsbtArgs {
+  /** The PSBT you sent to the device. */
+  readonly sentPsbt: Uint8Array;
+  /** The PSBT the device returned. */
+  readonly signedPsbt: Uint8Array;
+  /**
+   * true (default) on flows where every input is yours (a plain send): a
+   * reply that signed only part of the transaction is refused here with a
+   * reason instead of failing later inside a finalizer. Set false for dApp
+   * `signPsbt` hand-backs, where a PSBT legitimately carries inputs you
+   * cannot sign.
+   */
+  readonly requireEveryInputSigned?: boolean;
+}
+/**
+ * The `crypto-psbt` reply carries NO request id — this comparison IS the
+ * anti-replay binding for Bitcoin. It is not optional.
+ *
+ * The unsigned transaction is compared byte for byte, which pins the input
+ * set and order, the outputs, their amounts, the version and the locktime in
+ * one shot — and therefore the txid. The device only ADDS per-input
+ * signature fields, so a legitimate reply always matches.
+ */
+declare function verifySignedPsbt(args: VerifySignedPsbtArgs): VerifyResult;
+interface VerifyBtcMessageHeaderArgs {
+  /** The address the request asked the device to sign with. */
+  readonly address: string;
+  /** The raw 65-byte BIP-137 signature. */
+  readonly signature: Uint8Array;
+}
+/**
+ * BIP-137: the recovery header names the address type a verifier derives
+ * before comparing. A header of the wrong range produces a signature that
+ * LOOKS fine (65 bytes, valid base64) but fails every verifier downstream —
+ * this check is the only place that difference is visible.
+ */
+declare function verifyBtcMessageHeader(args: VerifyBtcMessageHeaderArgs): VerifyResult;
+//#endregion
+//#region src/verify/evm.d.ts
+interface VerifyEvmSignatureArgs {
+  /** The exact bytes the request carried in `signData`. */
+  readonly signData: Uint8Array;
+  readonly dataType: EvmDataType;
+  /** Raw `r || s || v` from the reply (65+ bytes; multi-byte legacy `v` handled). */
+  readonly signature: Uint8Array;
+  /** The signer address the request was built for. */
+  readonly address: Uint8Array | `0x${string}`;
+  /**
+   * Optional: the signing payload re-derived from the transaction you are
+   * ABOUT TO BROADCAST. Recovering against `signData` alone proves the device
+   * signed something you asked for — this closes the second half: that it is
+   * the transaction still in your hands (payloads can legitimately change
+   * between build and send, e.g. a blockhash refresh in your own state).
+   */
+  readonly reEncodedSignData?: Uint8Array;
+}
+/**
+ * "Did the device sign exactly what I sent, with the key I expected?"
+ * keccak digest + public-key recovery; the recovered address must equal the
+ * request's. Run it before broadcasting.
+ */
+declare function verifyEvmSignature(args: VerifyEvmSignatureArgs): VerifyResult;
+//#endregion
+//#region src/verify/psbt-reader.d.ts
+/**
+ * Minimal PSBT v0 (BIP-174) reader — just enough structure for the
+ * verification guard: the global unsigned transaction (verbatim slice, never
+ * re-serialized), the PSBT version, and per-input key/value maps.
+ *
+ * Hardened: compact-size lengths bounds-checked before slicing, duplicate
+ * keys within one map refused (a hostile PSBT carrying two final scriptSigs
+ * for one input must not survive parsing).
+ */
+interface PsbtKeyValue {
+  readonly keyType: number;
+  readonly keyData: Uint8Array;
+  readonly value: Uint8Array;
+}
+interface ParsedPsbt {
+  /** The global UNSIGNED_TX value, verbatim. */
+  readonly unsignedTx: Uint8Array;
+  /** Global PSBT_GLOBAL_VERSION (0xFB) if present; v0 files normally omit it. */
+  readonly version: number;
+  readonly inputs: readonly (readonly PsbtKeyValue[])[];
+  readonly outputs: readonly (readonly PsbtKeyValue[])[];
+}
+declare const PsbtInputType: {
+  readonly partialSig: 2;
+  readonly finalScriptSig: 7;
+  readonly finalScriptWitness: 8;
+  readonly taprootKeySpendSignature: 19;
+  readonly taprootScriptSpendSignature: 20;
+};
+declare function parsePsbt(bytes: Uint8Array): ParsedPsbt;
+//#endregion
+//#region src/verify/solana.d.ts
+interface VerifySolanaSignatureArgs {
+  /** The exact bytes the request carried in `signData` (the compiled message). */
+  readonly signData: Uint8Array;
+  /** 64-byte Ed25519 signature from the reply. */
+  readonly signature: Uint8Array;
+  /** The 32-byte signer public key the request was built for. */
+  readonly publicKey: Uint8Array;
+  /**
+   * Optional: the message bytes you are ABOUT TO BROADCAST. Matters most on
+   * Solana — a blockhash refresh between build and send makes "what was
+   * signed" and "what will be sent" two different objects that must agree.
+   */
+  readonly broadcastMessageBytes?: Uint8Array;
+}
+declare function verifySolanaSignature(args: VerifySolanaSignatureArgs): VerifyResult;
+//#endregion
+//#region src/verify/tron.d.ts
+interface VerifyTronSignatureArgs {
+  /** The `raw_data` bytes the request carried. */
+  readonly rawData: Uint8Array;
+  /** The base58 owner address the transaction spends from. */
+  readonly from: string;
+  /** The reference block the request carried (enables the rebuild-path window check). */
+  readonly latestBlock?: TronLatestBlock;
+  /** The reply: either the split frame from `TronSignatureResult.signedTx`, or the raw hex. */
+  readonly signedTx: SignedTronTx | string;
+}
+/**
+ * The Tron reply is a fully signed transaction broadcast VERBATIM, so it is
+ * checked on both counts: every signature must recover to the owner address,
+ * and the transaction must move what the user approved.
+ *
+ * Byte equality with the request's `rawData` is the strong form. When the
+ * bytes differ (a firmware that rebuilds `raw_data` from the semantic
+ * fields), the fallback compares the fields that decide where the money goes,
+ * plus the validity window against the reference block.
+ */
+declare function verifyTronSignature(args: VerifyTronSignatureArgs): VerifyResult;
+//#endregion
+export { type ParsedPsbt, PsbtInputType, type PsbtKeyValue, type VerifyBtcMessageHeaderArgs, type VerifyEvmSignatureArgs, type VerifyResult, type VerifySignedPsbtArgs, type VerifySolanaSignatureArgs, type VerifyTronSignatureArgs, parsePsbt, verifyBtcMessageHeader, verifyEvmSignature, verifySignedPsbt, verifySolanaSignature, verifyTronSignature };
+//# sourceMappingURL=verify.d.cts.map

package/dist/verify.d.ts

@@ -0,0 +1,162 @@
+import { n as EvmDataType } from "./evm-KrV5wK08.js";
+import { n as TronLatestBlock, t as SignedTronTx } from "./messages-DsPvW8Oi.js";
+//#region src/verify/result.d.ts
+/** Outcome of a verification helper. Helpers return, never throw, on mismatches. */
+type VerifyResult =
+/** Verified cryptographically / byte-for-byte. */
+{
+  readonly ok: true;
+  readonly checked: true;
+} |
+/**
+ * Nothing client-side is verifiable for this input (EIP-712 typed data:
+ * the digest is the hash of the structure, which only the device computes).
+ * The UR-type pin and the request-id echo are the whole binding.
+ */
+{
+  readonly ok: true;
+  readonly checked: false;
+  readonly reason: string;
+} | {
+  readonly ok: false;
+  readonly reason: string;
+};
+//#endregion
+//#region src/verify/btc.d.ts
+interface VerifySignedPsbtArgs {
+  /** The PSBT you sent to the device. */
+  readonly sentPsbt: Uint8Array;
+  /** The PSBT the device returned. */
+  readonly signedPsbt: Uint8Array;
+  /**
+   * true (default) on flows where every input is yours (a plain send): a
+   * reply that signed only part of the transaction is refused here with a
+   * reason instead of failing later inside a finalizer. Set false for dApp
+   * `signPsbt` hand-backs, where a PSBT legitimately carries inputs you
+   * cannot sign.
+   */
+  readonly requireEveryInputSigned?: boolean;
+}
+/**
+ * The `crypto-psbt` reply carries NO request id — this comparison IS the
+ * anti-replay binding for Bitcoin. It is not optional.
+ *
+ * The unsigned transaction is compared byte for byte, which pins the input
+ * set and order, the outputs, their amounts, the version and the locktime in
+ * one shot — and therefore the txid. The device only ADDS per-input
+ * signature fields, so a legitimate reply always matches.
+ */
+declare function verifySignedPsbt(args: VerifySignedPsbtArgs): VerifyResult;
+interface VerifyBtcMessageHeaderArgs {
+  /** The address the request asked the device to sign with. */
+  readonly address: string;
+  /** The raw 65-byte BIP-137 signature. */
+  readonly signature: Uint8Array;
+}
+/**
+ * BIP-137: the recovery header names the address type a verifier derives
+ * before comparing. A header of the wrong range produces a signature that
+ * LOOKS fine (65 bytes, valid base64) but fails every verifier downstream —
+ * this check is the only place that difference is visible.
+ */
+declare function verifyBtcMessageHeader(args: VerifyBtcMessageHeaderArgs): VerifyResult;
+//#endregion
+//#region src/verify/evm.d.ts
+interface VerifyEvmSignatureArgs {
+  /** The exact bytes the request carried in `signData`. */
+  readonly signData: Uint8Array;
+  readonly dataType: EvmDataType;
+  /** Raw `r || s || v` from the reply (65+ bytes; multi-byte legacy `v` handled). */
+  readonly signature: Uint8Array;
+  /** The signer address the request was built for. */
+  readonly address: Uint8Array | `0x${string}`;
+  /**
+   * Optional: the signing payload re-derived from the transaction you are
+   * ABOUT TO BROADCAST. Recovering against `signData` alone proves the device
+   * signed something you asked for — this closes the second half: that it is
+   * the transaction still in your hands (payloads can legitimately change
+   * between build and send, e.g. a blockhash refresh in your own state).
+   */
+  readonly reEncodedSignData?: Uint8Array;
+}
+/**
+ * "Did the device sign exactly what I sent, with the key I expected?"
+ * keccak digest + public-key recovery; the recovered address must equal the
+ * request's. Run it before broadcasting.
+ */
+declare function verifyEvmSignature(args: VerifyEvmSignatureArgs): VerifyResult;
+//#endregion
+//#region src/verify/psbt-reader.d.ts
+/**
+ * Minimal PSBT v0 (BIP-174) reader — just enough structure for the
+ * verification guard: the global unsigned transaction (verbatim slice, never
+ * re-serialized), the PSBT version, and per-input key/value maps.
+ *
+ * Hardened: compact-size lengths bounds-checked before slicing, duplicate
+ * keys within one map refused (a hostile PSBT carrying two final scriptSigs
+ * for one input must not survive parsing).
+ */
+interface PsbtKeyValue {
+  readonly keyType: number;
+  readonly keyData: Uint8Array;
+  readonly value: Uint8Array;
+}
+interface ParsedPsbt {
+  /** The global UNSIGNED_TX value, verbatim. */
+  readonly unsignedTx: Uint8Array;
+  /** Global PSBT_GLOBAL_VERSION (0xFB) if present; v0 files normally omit it. */
+  readonly version: number;
+  readonly inputs: readonly (readonly PsbtKeyValue[])[];
+  readonly outputs: readonly (readonly PsbtKeyValue[])[];
+}
+declare const PsbtInputType: {
+  readonly partialSig: 2;
+  readonly finalScriptSig: 7;
+  readonly finalScriptWitness: 8;
+  readonly taprootKeySpendSignature: 19;
+  readonly taprootScriptSpendSignature: 20;
+};
+declare function parsePsbt(bytes: Uint8Array): ParsedPsbt;
+//#endregion
+//#region src/verify/solana.d.ts
+interface VerifySolanaSignatureArgs {
+  /** The exact bytes the request carried in `signData` (the compiled message). */
+  readonly signData: Uint8Array;
+  /** 64-byte Ed25519 signature from the reply. */
+  readonly signature: Uint8Array;
+  /** The 32-byte signer public key the request was built for. */
+  readonly publicKey: Uint8Array;
+  /**
+   * Optional: the message bytes you are ABOUT TO BROADCAST. Matters most on
+   * Solana — a blockhash refresh between build and send makes "what was
+   * signed" and "what will be sent" two different objects that must agree.
+   */
+  readonly broadcastMessageBytes?: Uint8Array;
+}
+declare function verifySolanaSignature(args: VerifySolanaSignatureArgs): VerifyResult;
+//#endregion
+//#region src/verify/tron.d.ts
+interface VerifyTronSignatureArgs {
+  /** The `raw_data` bytes the request carried. */
+  readonly rawData: Uint8Array;
+  /** The base58 owner address the transaction spends from. */
+  readonly from: string;
+  /** The reference block the request carried (enables the rebuild-path window check). */
+  readonly latestBlock?: TronLatestBlock;
+  /** The reply: either the split frame from `TronSignatureResult.signedTx`, or the raw hex. */
+  readonly signedTx: SignedTronTx | string;
+}
+/**
+ * The Tron reply is a fully signed transaction broadcast VERBATIM, so it is
+ * checked on both counts: every signature must recover to the owner address,
+ * and the transaction must move what the user approved.
+ *
+ * Byte equality with the request's `rawData` is the strong form. When the
+ * bytes differ (a firmware that rebuilds `raw_data` from the semantic
+ * fields), the fallback compares the fields that decide where the money goes,
+ * plus the validity window against the reference block.
+ */
+declare function verifyTronSignature(args: VerifyTronSignatureArgs): VerifyResult;
+//#endregion
+export { type ParsedPsbt, PsbtInputType, type PsbtKeyValue, type VerifyBtcMessageHeaderArgs, type VerifyEvmSignatureArgs, type VerifyResult, type VerifySignedPsbtArgs, type VerifySolanaSignatureArgs, type VerifyTronSignatureArgs, parsePsbt, verifyBtcMessageHeader, verifyEvmSignature, verifySignedPsbt, verifySolanaSignature, verifyTronSignature };
+//# sourceMappingURL=verify.d.ts.map