feat: hook_hash (#32)

Author: 9oelM

README.md

@@ -190,11 +190,11 @@ Utilities
 Hook context
 
 - [x] `hook_account`
-- [ ] `hook_hash`
+- [x] `hook_hash`
 - [x] `hook_param`
 - [ ] `hook_param_set`
 - [ ] `hook_skip`
-- [ ] `hook_pos`
+- [x] `hook_pos`
 - [ ] `hook_again`
 
 Serialization

hooks-rs/examples/hook_hash.rs

@@ -0,0 +1,18 @@
+#![no_std]
+#![no_main]
+
+use hooks_rs::*;
+
+#[no_mangle]
+pub extern "C" fn cbak(_: u32) -> i64 {
+    0
+}
+
+#[no_mangle]
+pub extern "C" fn hook(_: u32) -> i64 {
+    max_iter(1);
+
+    let hook_hash = hook_hash(HookNumber::CurrentHook).unwrap_line_number();
+
+    accept(&hook_hash, 0);
+}

hooks-rs/src/api/hook.rs

@@ -3,6 +3,15 @@ use core::mem::MaybeUninit;
 use super::*;
 use crate::c;
 
+/// Meant to be used as an argument to `hook_hash` to specify the hook number.
+#[derive(Copy, Clone)]
+pub enum HookNumber {
+    /// The currently executing hook
+    CurrentHook,
+    /// The position in the hook chain the hook is located at,
+    Custom(i32),
+}
+
 /// Retreive the 20 byte Account ID the Hook is executing on
 ///
 /// # Example
@@ -70,3 +79,36 @@ pub fn hook_param<const HOOK_PARAM_LEN: usize>(
 pub fn hook_pos() -> i64 {
     unsafe { c::hook_pos() }
 }
+
+/// Retreive the 32 byte namespace biased SHA512H of the currently executing Hook
+///
+/// # Example
+/// ```
+/// let hook_hash = hook_hash(HookNumber::CurrentHook);
+/// ```
+#[inline(always)]
+pub fn hook_hash(hook_number: HookNumber) -> Result<[u8; HOOK_HASH_LEN]> {
+    let func = |buffer_mut_ptr: *mut MaybeUninit<u8>| {
+        let result: Result<u64> = unsafe {
+            c::hook_hash(
+                buffer_mut_ptr as u32,
+                HOOK_HASH_LEN as u32,
+                hook_number.into(),
+            )
+            .into()
+        };
+
+        result
+    };
+
+    init_buffer_mut(func)
+}
+
+impl From<HookNumber> for i32 {
+    fn from(hook_no: HookNumber) -> i32 {
+        match hook_no {
+            HookNumber::CurrentHook => -1,
+            HookNumber::Custom(hook_no) => hook_no,
+        }
+    }
+}

hooks-rs/src/api/mod.rs

@@ -43,6 +43,8 @@ pub const STATE_KEY_LEN: usize = 32;
 pub const NONCE_LEN: usize = 32;
 /// Hash byte length
 pub const HASH_LEN: usize = 32;
+/// Hook Hash byte length
+pub const HOOK_HASH_LEN: usize = 32;
 /// Amount byte length
 pub const AMOUNT_LEN: usize = 48;
 /// Payment simple transaction byte length

hooks-rs/tests/hook_hash.test.ts

@@ -0,0 +1,88 @@
+// xrpl
+import { Client, Invoke, Transaction, Wallet } from "@transia/xrpl";
+import { TestUtils } from "./setup";
+import { HookExecution } from "@transia/xrpl/dist/npm/models/transactions/metadata";
+
+const HOOK_NAME = "hook_hash";
+
+describe("hook_hash.rs", () => {
+  let client: Client;
+  let alice: Wallet;
+  let bob: Wallet;
+
+  beforeAll(async () => {
+    const hook = await TestUtils.buildHook(HOOK_NAME);
+    client = new Client("wss://xahau-test.net", {});
+    await client.connect();
+    client.networkID = await client.getNetworkID();
+    // Because Faucet only allows one account to be created every 60 seconds,
+    // we will use the following accounts for testing. Change the secrets when
+    // running out of funds.
+    // rMXRvoMFnuf2xPK5Pio94D5LhttE7X5H6e
+    alice = Wallet.fromSecret(`ssJaynfvJVm7wANHyCFAWYV94SXWP`);
+    // rniKiTrsgGkDFc65pw7zruXJirs4aPweN6
+    bob = Wallet.fromSecret(`ssz1zWkMuEQN9twEvTTnGZW8KtZjw`);
+    await TestUtils.setHook(client, alice.seed!, hook);
+  }, 3 * 60_000);
+
+  afterAll(async () => {
+    await client.disconnect();
+  }, 10_000);
+
+  it(
+    "accepts with the hook hash of the currently executing hook",
+    async () => {
+      const tx: Invoke & Transaction = {
+        TransactionType: "Invoke",
+        Account: bob.classicAddress,
+        Destination: alice.classicAddress,
+      };
+      // Autofilling fee does not work with hooks yet
+      const { Fee, ...rest } = await client.autofill(tx);
+      const fee = await TestUtils.getTransactionFee(client, rest);
+      const txResponse = await TestUtils.submitAndWaitWithRetries(
+        client,
+        {
+          ...tx,
+          Fee: fee,
+        },
+        {
+          wallet: bob,
+          autofill: true,
+        },
+      );
+      if (!txResponse.result.meta) {
+        throw new Error("No meta in tx response");
+      }
+      if (typeof txResponse.result.meta === "string") {
+        throw new Error("Meta is string, not object");
+      }
+
+      const { meta } = txResponse.result;
+      if (!(meta.HookExecutions && meta.HookExecutions.length > 0)) {
+        throw new Error(`Hook execution data is empty`);
+      }
+
+      if (meta.HookExecutions.length > 1) {
+        throw new Error(`Hook execution happened more than once`);
+      }
+
+      if (txResponse.result.meta.TransactionResult !== "tesSUCCESS") {
+        console.error(JSON.stringify(txResponse, null, 2));
+
+        throw new Error(`Transaction failed`);
+      }
+
+      // safe type: we checked everything
+      const [hookExecution] = meta.HookExecutions as [HookExecution];
+
+      const { HookReturnString, HookReturnCode, HookHash } =
+        hookExecution.HookExecution;
+
+      expect(HookReturnString).toBe(HookHash);
+      // HookPos should be 0
+      expect(Number(HookReturnCode)).toBe(0);
+    },
+    3 * 60_000,
+  );
+});