Verify XRPL Signature

https://github.com/xrpl-labs/verify-xrpl-signature
Admin
This library verifies signed XRPL transactions (BLOB, hex) and can be used to verify signed XUMM...
Tokens:6,945
Snippets:20
Trust Score:8.2
License:MIT
Update:11 months ago
Show doc for...
Tokens:
Raw
### TypeScript for Type-Safe XRPL Signature Verification

Source: https://context7.com/xrpl-labs/verify-xrpl-signature/llms.txt

Provides type-safe usage with full TypeScript support, including interfaces for transaction structures and verification results. This example shows how to leverage the library's exported types for building robust XRPL applications. It depends on 'node-fetch' and 'xrpl-binary-codec-prerelease' for network interactions and type definitions.

```typescript
import {
  verifySignature,
  getDefinitions,
  verifySignatureResult,
  JsonTransaction,
  Signer
} from 'verify-xrpl-signature';
import { XrplDefinitions } from 'xrpl-binary-codec-prerelease';
import fetch from 'node-fetch';

// Type-safe request function
const request = async (url: string, body?: string): Promise<any> => {
  const response = await fetch(url, {
    method: body ? "POST" : "GET",
    body
  });
  return response.json();
};

// Type-safe verification function
async function verifyTransaction(
  txBlob: string,
  signer?: string,
  networkName?: string
): Promise<verifySignatureResult> {
  try {
    let defs: XrplDefinitions | undefined;

    if (networkName) {
      defs = await getDefinitions(networkName, request);
    }

    const result: verifySignatureResult = verifySignature(txBlob, signer, defs);

    return result;

  } catch (error) {
    throw new Error(`Transaction verification failed: ${(error as Error).message}`);
  }
}

// Example usage with type safety
(async () => {
  const txBlob = '2280000000240000000268400000000000000C73210333C718C9CB716E0575454F4A343D46B284ED51151B9C7383524B82C10B262095744730450221009A4D99017F8FD6881D888047E2F9F90C068C09EC9308BC8526116B539D6DD44102207FAA7E8756F67FE7EE1A88884F120A00A8EC37E7D3E5ED3E02FEA7B1D97AA05581146C0994D3FCB140CAB36BAE9465137448883FA487';

  const result: verifySignatureResult = await verifyTransaction(txBlob);

  // Type-safe property access
  const accountAddress: string = result.signedBy;
  const isValid: boolean = result.signatureValid;
  const isMultiSigned: boolean = result.signatureMultiSign;

  console.log(`Account: ${accountAddress}`);
  console.log(`Valid: ${isValid}`);
  console.log(`MultiSign: ${isMultiSigned}`);

  // Type-safe multi-sign verification
  if (isMultiSigned) {
    const specificSigner = 'rN7n7otQDd6FczFgLdlqtyMVrn3HMfL9MM';
    const specificResult = await verifyTransaction(txBlob, specificSigner);
    console.log(`Specific signer ${specificSigner}: ${specificResult.signatureValid}`);
  }
})();
```

--------------------------------

### ES Module Usage for XRPL Signature Verification

Source: https://context7.com/xrpl-labs/verify-xrpl-signature/llms.txt

Demonstrates using the verify-xrpl-signature library with modern JavaScript ES modules (MJS). This includes static imports, dynamic async operations for fetching network definitions, and signature verification for both simple and network-specific transactions. It relies on the 'node-fetch' library for network requests.

```javascript
import verifyXrplSignature from 'verify-xrpl-signature';
const { verifySignature, getDefinitions } = verifyXrplSignature;
import fetch from 'node-fetch';

// Request wrapper for ES modules
const request = (url, body) =>
  fetch(url, { method: body ? "POST" : "GET", body })
    .then(r => r.json());

// Example 1: Simple verification with ES modules
const simpleTxBlob = '2280000000240000000268400000000000000C73210333C718C9CB716E0575454F4A343D46B284ED51151B9C7383524B82C10B262095744730450221009A4D99017F8FD6881D888047E2F9F90C068C09EC9308BC8526116B539D6DD44102207FAA7E8756F67FE7EE1A88884F120A00A8EC37E7D3E5ED3E02FEA7B1D97AA05581146C0994D3FCB140CAB36BAE9465137448883FA487';

const simpleResult = verifySignature(simpleTxBlob);
console.log(simpleResult);

// Example 2: Async verification with network definitions
const xahauTxBlob = '1200632200000000240000000220190000000168400000000000000C';

(async () => {
  try {
    const definitions = await getDefinitions("XAHAU", request);
    const result = verifySignature(xahauTxBlob, undefined, definitions);

    console.log(`Network: XAHAU`);
    console.log(`Signed By: ${result.signedBy}`);
    console.log(`Valid: ${result.signatureValid}`);
    console.log(`MultiSign: ${result.signatureMultiSign}`);

    // Chain multiple verifications
    const transactions = [txBlob1, txBlob2, txBlob3];
    const results = transactions.map(tx => verifySignature(tx, undefined, definitions));

    console.log(`Batch verification: ${results.filter(r => r.signatureValid).length}/${results.length} valid`);

  } catch (error) {
    console.error(`Error: ${error.message}`);
  }
})();
```

--------------------------------

### Verify XRPL Transaction Signature with Dynamic Definitions (JavaScript)

Source: https://github.com/xrpl-labs/verify-xrpl-signature/blob/master/README.md

Verifies an XRPL transaction signature using dynamically fetched network definitions for a specified network (e.g., Xahau). It requires a `fetch` implementation for retrieving definitions and then uses `verifySignature`. This method is suitable for environments where network definitions need to be loaded at runtime.

```javascript
const verifyXrplSignature = require('verify-xrpl-signature')
const { verifySignature, getDefinitions } = verifyXrplSignature 
const fetch = require('node-fetch')

const request = (url, body) => fetch(url, { method: body ? "POST" : "GET", body }).then(r => r.json())

;(async () => {
  const definitions = await getDefinitions("XAHAU", request) // Network = XAHHAU (id: 21337 would work too), pass `request` method.

  const someTx = '2280000000240000000268400000000000000C73210333C718C9CB716E0575454F4A343D46B284ED51151B9C7383524B82C10B262095744730450221009A4D99017F8FD6881D888047E2F9F90C068C09EC9308BC8526116B539D6DD44102207FAA7E8756F67FE7EE1A88884F120A00A8EC37E7D3E5ED3E02FEA7B1D97AA05581146C0994D3FCB140CAB36BAE9465137448883FA487'

  console.log(verifySignature(someTx, undefined, definitions))

  // In case of explicit MultiSign signer verification:
  // console.log(verifySignature(someTx, 'rwiETSee2wMz3SBnAG8hkMsCgvGy9LWbZ1', definitions))
})()
```

--------------------------------

### Verify XRPL Transaction Signature (MJS/ESM)

Source: https://github.com/xrpl-labs/verify-xrpl-signature/blob/master/README.md

Demonstrates how to verify an XRPL transaction signature using the library within an ES Module (MJS) environment. It utilizes dynamic import for `node-fetch` and the `getDefinitions` function to retrieve network configurations before verifying the signature.

```javascript
import verifyXrplSignature from 'verify-xrpl-signature'
const { verifySignature, getDefinitions } = verifyXrplSignature 
import fetch from 'node-fetch'

const request = (url, body) => fetch(url, { method: body ? "POST" : "GET", body }).then(r => r.json())

const someTx = '<<binhex>>'

console.log(verifySignature(someTx, undefined, await getDefinitions("XAHAU", request)))

// In case of explicit MultiSign signer verification:
// console.log(verifySignature(someTx, 'rwiETSee2wMz3SBnAG8hkMsCgvGy9LWbZ1', definitions))
```

--------------------------------

### Fetch XRPL Network Definitions for Alternative Networks

Source: https://context7.com/xrpl-labs/verify-xrpl-signature/llms.txt

Retrieves network-specific transaction field definitions for alternative XRPL networks like Xahau. This is necessary for verifying transactions on networks that have custom transaction types or fields not present in the standard XRPL definitions. It requires a request wrapper function that returns parsed JSON.

```javascript
const { getDefinitions, verifySignature } = require('verify-xrpl-signature');
const fetch = require('node-fetch');

// Define request wrapper (must return parsed JSON)
const request = async (url, body) => {
  const response = await fetch(url, {
    method: body ? "POST" : "GET",
    body: body
  });
  return response.json();
};

(async () => {
  try {
    // Fetch definitions by network name
    const xahauDefs = await getDefinitions("XAHAU", request);
    console.log('Xahau definitions loaded:', xahauDefs ? 'Success' : 'Failed');

    // Or fetch by network chain ID
    const defsByChainId = await getDefinitions(21337, request);

    // Use definitions to verify Xahau-specific transaction
    const xahauTxBlob = '1200632200000000240000000220190000000168400000000000000C732102D5C8D5B8F6C1E5A7C2D9B3E8F0A1C5D7E2F8B4C6D1E9F3A7B2C8D5E0F673210330E7FC9D56BB25D6893BA3F317AE5BCF33B3291BD63DB32654A313222F7FD020740730440220787B48DE14743C1A2E0D7DC4838A7C0AC31F838A4B46F9F9E60D914DA9A83F0102200A40F1A0A3CE49EF0AD345ABCD40AD6A3DCE1D05A01FD1C92DD1656B5BB36814811488CB5ACCEB6E9E2A6D6C81FA4A4AD25CC0EA0DCE';

    const result = verifySignature(xahauTxBlob, undefined, xahauDefs);
    console.log('Xahau transaction verification:', result);
    // Output:
    // {
    //   signedBy: 'rXahauAccountAddress...',
    //   signatureValid: true,
    //   signatureMultiSign: false
    // }

  } catch (error) {
    console.error('Definition fetch failed:', error.message);
    // Could not fetch network rails: [error details]
  }
})();
```

--------------------------------

### Verify XRPL Transactions with Custom Network Definitions

Source: https://context7.com/xrpl-labs/verify-xrpl-signature/llms.txt

Verifies transactions that use custom or network-specific transaction types by providing pre-loaded network definitions. This is essential for networks like Xahau that support features like Hooks or Import transactions not available on XRPL mainnet. It requires the 'xrpl-binary-codec-prerelease' package and a JSON file containing the custom definitions.

```javascript
const { verifySignature } = require('verify-xrpl-signature');
const { XrplDefinitions } = require('xrpl-binary-codec-prerelease');

// Load custom definitions from JSON
const customDefsJson = require('./custom-network-definitions.json');
const customDefinitions = new XrplDefinitions(customDefsJson);

// Transaction blob from custom network with Hooks enabled
const hookTxBlob = '120022800000002400000001201B0000052868400000000000000C730000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000';

try {
  // Verify with standard definitions (will fail)
  try {
    verifySignature(hookTxBlob);
  } catch (error) {
    console.error('Standard verification failed:', error.message);
    // Could not decode the transaction blob, possibly specify alternative definitions?
  }

  // Verify with custom definitions (will succeed)
  const result = verifySignature(hookTxBlob, undefined, customDefinitions);
  console.log('Custom network verification:', result);
  // Output:
  // {
  //   signedBy: 'rCustomNetworkAccount...',
  //   signatureValid: true,
  //   signatureMultiSign: false
  // }

  console.log(`Transaction type recognized: Success`);
  console.log(`Signature verified: ${result.signatureValid}`);
  console.log(`Signed by account: ${result.signedBy}`);

} catch (error) {
  console.error('Verification error:', error.message);
}
```

--------------------------------

### Verify XRPL Transaction Signature (JavaScript)

Source: https://github.com/xrpl-labs/verify-xrpl-signature/blob/master/README.md

Verifies the signature of a given XRPL transaction blob using predefined network definitions. It takes the transaction blob, an optional multisigner address, and the network definitions as input. The output indicates the signer and validity of the signature.

```javascript
const verifySignature = require('verify-xrpl-signature').verifySignature
const someTx = '2280000000240000000268400000000000000C73210333C718C9CB716E0575454F4A343D46B284ED51151B9C7383524B82C10B262095744730450221009A4D99017F8FD6881D888047E2F9F90C068C09EC9308BC8526116B539D6DD44102207FAA7E8756F67FE7EE1A88884F120A00A8EC37E7D3E5ED3E02FEA7B1D97AA05581146C0994D3FCB140CAB36BAE9465137448883FA487'

console.log(verifySignature(someTx, undefined, definitions))

// In case of explicit MultiSign signer verification:
// console.log(verifySignature(someTx, 'rwiETSee2wMz3SBnAG8hkMsCgvGy9LWbZ1'))
```

--------------------------------

### Verify Single-Signed XRPL Transaction

Source: https://context7.com/xrpl-labs/verify-xrpl-signature/llms.txt

Verifies a standard XRPL transaction signed by a single account. It decodes the hex transaction blob, extracts the signing public key, derives the account address, and validates the signature against the transaction data. Requires the 'verify-xrpl-signature' library.

```javascript
const { verifySignature } = require('verify-xrpl-signature');

// Example transaction blob (hex-encoded signed transaction)
const txBlob = '2280000000240000000268400000000000000C73210333C718C9CB716E0575454F4A343D46B284ED51151B9C7383524B82C10B262095744730450221009A4D99017F8FD6881D888047E2F9F90C068C09EC9308BC8526116B539D6DD44102207FAA7E8756F67FE7EE1A88884F120A00A8EC37E7D3E5ED3E02FEA7B1D97AA05581146C0994D3FCB140CAB36BAE9465137448883FA487';

try {
  const result = verifySignature(txBlob);
  console.log(result);
  // Output:
  // {
  //   signedBy: 'rwiETSee2wMz3SBnAG8hkMsCgvGy9LWbZ1',
  //   signatureValid: true,
  //   signatureMultiSign: false
  // }

  if (result.signatureValid) {
    console.log(`Transaction signed by ${result.signedBy} is valid`);
  } else {
    console.log(`Invalid signature detected`);
  }
} catch (error) {
  console.error(`Verification failed: ${error.message}`);
}
```

--------------------------------

### Verify Multi-Signed XRPL Transaction

Source: https://context7.com/xrpl-labs/verify-xrpl-signature/llms.txt

Verifies XRPL transactions signed by multiple accounts. By default, it verifies the first signer. You can optionally specify a particular signer's account address or public key hex to verify a specific multisigner. Requires the 'verify-xrpl-signature' library.

```javascript
const { verifySignature } = require('verify-xrpl-signature');

// Multi-signed transaction blob
const multiSignedTxBlob = '73210330E7FC9D56BB25D6893BA3F317AE5BCF33B3291BD63DB32654A313222F7FD020740730440220787B48DE14743C1A2E0D7DC4838A7C0AC31F838A4B46F9F9E60D914DA9A83F0102200A40F1A0A3CE49EF0AD345ABCD40AD6A3DCE1D05A01FD1C92DD1656B5BB36814811488CB5ACCEB6E9E2A6D6C81FA4A4AD25CC0EA0DCE7321028FFD43E4BB6F5B0B1C6A88E4CD3E2F7F0A04A4B17A1DA9D96CB1D7A3B41B4E8774473045022100E5E6ACF7DD5E8D1CF95BE9B2C0C8F45DD1734C8C0BE55E1B6F28AF60B0B7C67302201D8A30CCA3F5C0E8F1A6B6C3E9C6D3E1D8A7C1F0D2E5E2B6F5C0E8F1A6B681148C35F1B9F8E2D1E0C6A3B7D5E1F8C2B3F5D0E1C4E7321030F5B1C8E2D6A3C8E1F0B5C2E8F1A6B3C0D5E2F8B1C3D0E5F8A2C1D3B5E0F874463044022078A1C2D3E4F5B0C1D2E3F4A5B6C0D1E2F3A4B5C6D0E1F2A3B402201C3D4E5F0A1B2C3D4E5F6A0B1C2D3E4F5A6B0C1D2E3F4A5B6C0D1E2F3A4B5C6';

try {
  // Verify first signer (default behavior)
  const result = verifySignature(multiSignedTxBlob);
  console.log(result);
  // Output:
  // {
  //   signedBy: 'rN7n7otQDd6FczFgLdlqtyMVrn3HMfL9MM',
  //   signatureValid: true,
  //   signatureMultiSign: true
  // }

  // Verify specific signer by account address
  const specificSigner = 'rwiETSee2wMz3SBnAG8hkMsCgvGy9LWbZ1';
  const specificResult = verifySignature(multiSignedTxBlob, specificSigner);
  console.log(`Signer ${specificResult.signedBy}: ${specificResult.signatureValid ? 'Valid' : 'Invalid'}`);

  // Verify specific signer by public key hex
  const pubKeyHex = '0333C718C9CB716E0575454F4A343D46B284ED51151B9C7383524B82C10B262095';
  const pubKeyResult = verifySignature(multiSignedTxBlob, pubKeyHex);
  console.log(`PubKey signer verification: ${pubKeyResult.signatureValid}`);
} catch (error) {
  if (error.message.includes('Explicit MultiSigner not in Signers')) {
    console.error('Specified signer is not part of this multi-signed transaction');
  } else {
    console.error(`Verification failed: ${error.message}`);
  }
}
```

--------------------------------

### Verify Single-Signed Transaction

Source: https://context7.com/xrpl-labs/verify-xrpl-signature/llms.txt

Verifies a standard XRPL transaction blob signed by a single account. The function decodes the hexadecimal transaction blob, extracts the signing public key, derives the account address, and validates the cryptographic signature against the transaction data.

```APIDOC
## POST /verify-signature

### Description
Verifies a standard XRPL transaction blob signed by a single account. The function decodes the hexadecimal transaction blob, extracts the signing public key, derives the account address, and validates the cryptographic signature against the transaction data.

### Method
POST

### Endpoint
/verify-signature

### Parameters
#### Request Body
- **txBlob** (string) - Required - The hexadecimal-encoded signed transaction blob.

### Request Example
```json
{
  "txBlob": "2280000000240000000268400000000000000C73210333C718C9CB716E0575454F4A343D46B284ED51151B9C7383524B82C10B262095744730450221009A4D99017F8FD6881D888047E2F9F90C068C09EC9308BC8526116B539D6DD44102207FAA7E8756F67FE7EE1A88884F120A00A8EC37E7D3E5ED3E02FEA7B1D97AA05581146C0994D3FCB140CAB36BAE9465137448883FA487"
}
```

### Response
#### Success Response (200)
- **signedBy** (string) - The XRPL account address that signed the transaction.
- **signatureValid** (boolean) - Indicates if the signature is valid.
- **signatureMultiSign** (boolean) - Indicates if the transaction is multi-signed.

#### Response Example
```json
{
  "signedBy": "rwiETSee2wMz3SBnAG8hkMsCgvGy9LWbZ1",
  "signatureValid": true,
  "signatureMultiSign": false
}
```

#### Error Response (400)
- **message** (string) - A message describing the error.

#### Error Example
```json
{
  "message": "Invalid transaction blob format."
}
```
```

--------------------------------

### Verify Multi-Signed Transaction

Source: https://context7.com/xrpl-labs/verify-xrpl-signature/llms.txt

Verifies XRPL transactions that have been signed by multiple accounts. By default, it verifies the first signer in the Signers array. You can optionally specify a particular signer's account address or public key to verify a specific multisigner.

```APIDOC
## POST /verify-signature

### Description
Verifies XRPL transactions that have been signed by multiple accounts. By default, it verifies the first signer in the Signers array. You can optionally specify a particular signer's account address or public key to verify a specific multisigner.

### Method
POST

### Endpoint
/verify-signature

### Parameters
#### Request Body
- **txBlob** (string) - Required - The hexadecimal-encoded signed transaction blob.
- **signerIdentifier** (string) - Optional - The account address or public key hex of the specific signer to verify.

### Request Example
```json
{
  "txBlob": "73210330E7FC9D56BB25D6893BA3F317AE5BCF33B3291BD63DB32654A313222F7FD020740730440220787B48DE14743C1A2E0D7DC4838A7C0AC31F838A4B46F9F9E60D914DA9A83F0102200A40F1A0A3CE49EF0AD345ABCD40AD6A3DCE1D05A01FD1C92DD1656B5BB36814811488CB5ACCEB6E9E2A6D6C81FA4A4AD25CC0EA0DCE7321028FFD43E4BB6F5B0B1C6A88E4CD3E2F7F0A04A4B17A1DA9D96CB1D7A3B41B4E8774473045022100E5E6ACF7DD5E8D1CF95BE9B2C0C8F45DD1734C8C0BE55E1B6F28AF60B0B7C67302201D8A30CCA3F5C0E8F1A6B6C3E9C6D3E1D8A7C1F0D2E5E2B6F5C0E8F1A6B3C0D5E2F8B1C3D0E5F8A2C1D3B5E0F874463044022078A1C2D3E4F5B0C1D2E3F4A5B6C0D1E2F3A4B5C6D0E1F2A3B402201C3D4E5F0A1B2C3D4E5F6A0B1C2D3E4F5A6B0C1D2E3F4A5B6C0D1E2F3A4B5C6",
  "signerIdentifier": "rN7n7otQDd6FczFgLdlqtyMVrn3HMfL9MM" 
}
```

### Response
#### Success Response (200)
- **signedBy** (string) - The XRPL account address that signed the transaction.
- **signatureValid** (boolean) - Indicates if the signature is valid.
- **signatureMultiSign** (boolean) - Indicates if the transaction is multi-signed.

#### Response Example
```json
{
  "signedBy": "rN7n7otQDd6FczFgLdlqtyMVrn3HMfL9MM",
  "signatureValid": true,
  "signatureMultiSign": true
}
```

#### Error Response (400)
- **message** (string) - A message describing the error.

#### Error Example
```json
{
  "message": "Specified signer is not part of this multi-signed transaction."
}
```
```
Tokens:
Raw