@layerzerolabs/pubkey-policy-hook-solana-contracts 0.0.0-stage → 1.2.82

package/Anchor.toml

@@ -0,0 +1,17 @@
+[toolchain]
+anchor_version = "1.2.1"
+solana_version = "4.3.0"
+
+[features]
+resolution = false
+skip-lint = false
+
+[workspace]
+members = ["programs/pubkey_policy_hook"]
+
+[programs.localnet]
+pubkey_policy_hook = "7HTVK1Jwzjd4yRGCZnLT4QmwhmZidurFxwz2RMAiUyzk"
+
+[provider]
+cluster = "Localnet"
+wallet = "/dev/null"

package/Cargo.toml

@@ -0,0 +1,21 @@
+[workspace]
+resolver = "2"
+members = ["programs/pubkey_policy_hook"]
+exclude = ["dependencies"]
+
+[workspace.dependencies]
+anchor-lang = { version = "=1.2.1", default-features = false, features = ["init-if-needed", "event-cpi", "solana-v4"] }
+anchor-spl = { version = "=1.2.1", default-features = false, features = ["token", "token_2022", "associated_token", "solana-v4"] }
+program-id = { path = "dependencies/program-id-solana-contracts/lib" }
+pubkey-policy-interface = { path = "dependencies/pubkey-policy-solana-contracts/interface" }
+spl-discriminator = "0.5.2"
+spl-tlv-account-resolution = "0.11.2"
+spl-token-2022 = { version = "=11.0.0", features = ["no-entrypoint"] }
+spl-token-2022-interface = "=3.1.1"
+spl-transfer-hook-interface = "2.1.0"
+
+[profile.release]
+overflow-checks = true
+
+[workspace.lints.rust]
+unexpected_cfgs = { level = "allow", check-cfg = ['cfg(target_os, values("solana"))', 'cfg(feature, values("anchor-debug", "custom-heap", "custom-panic"))'] }

package/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2026 - LayerZero Labs Ltd.
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,3 +1,39 @@
-# Temporary Holding Version
+# Pubkey policy hook — Solana
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+`pubkey_policy_hook` is an optional Token-2022 transfer hook. On every transfer it checks the
+source owner, the destination owner and the executing authority against the pubkey policy bound
+into the mint's manifest; the Permanent Delegate is exempt. The mint's hook-update authority binds
+or re-binds the policy with `init_transfer_hook`, and only a policy for the mint binds. Handing that
+authority to a token-manager root's `TransferHook` signer puts rebinding under its DefaultAdmin
+(`set_transfer_hook_policy`).
+
+`init_transfer_hook`'s `authority` is an unchecked account, so generated clients mark it as a
+non-signer. A plain key or a CPI-signing PDA must be passed as a signer; a native multisig is passed
+as a non-signer, with its member signers appended as signing remaining accounts.
+
+The hook screens transfers only. Token-2022's `SetAuthority(AccountOwner)` reassigns a token
+account, balance included, without a transfer, so it never runs the hook: a blocked owner of a
+non-ATA account can hand it to an allowed key. ATAs (`ImmutableOwner`) and frozen accounts cannot be
+reassigned, so blocking a holder means freezing their accounts too.
+
+It is used alongside the [token manager](../token-manager/README.md), whose README and
+[usage doc](../token-manager/docs/usage.md) cover setup with Token ACL; the cross-program scenarios
+that exercise the hook live in token-manager's integration suite.
+
+## Build and test
+
+```bash
+pnpm build       # anchor build + IDL and TS type generation
+pnpm test:rust   # host tests in programs/pubkey_policy_hook/tests
+pnpm lint        # rustfmt --check + clippy -D warnings
+```
+
+Every command runs through the repo Docker VM tooling (`lz-tool anchor`).
+
+`PUBKEY_POLICY_HOOK_ID` sets the program ID compiled into the binary and IDL; the default is the
+development ID `7HTVK1Jwzjd4yRGCZnLT4QmwhmZidurFxwz2RMAiUyzk`. `lz-tool` does not pass host
+environment variables into its container, so pass it explicitly:
+
+```sh
+pnpm exec lz-tool --env PUBKEY_POLICY_HOOK_ID=<pubkey> --script 'sh scripts/build.sh' anchor
+```

package/package.json

@@ -1,6 +1,54 @@
 {
   "name": "@layerzerolabs/pubkey-policy-hook-solana-contracts",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.2.82",
+  "private": false,
+  "license": "MIT",
+  "type": "module",
+  "files": [
+    "programs",
+    "scripts",
+    "Anchor.toml",
+    "Cargo.toml",
+    "rust-toolchain.toml",
+    "rustfmt.toml",
+    "turbo.json",
+    "turbo-snapshot.lock.json",
+    "!**/target/**",
+    "!**/*-keypair.json"
+  ],
+  "dependencies": {
+    "@layerzerolabs/program-id-solana-contracts": "1.2.82",
+    "@layerzerolabs/pubkey-policy-solana-contracts": "1.2.82"
+  },
+  "devDependencies": {
+    "@layerzerolabs/build-utils-rust": "1.2.82",
+    "@layerzerolabs/vm-tooling-solana": "1.2.82"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "externalRepoConfig": {
+    "targets": [
+      "audit-external",
+      "monorepo-external"
+    ]
+  },
+  "implicitDependencies": {
+    "@layerzerolabs/program-id-solana-contracts": "workspace:*",
+    "@layerzerolabs/pubkey-policy-solana-contracts": "workspace:*"
+  },
+  "scripts": {
+    "allow-read-write": "[ -z \"$CI\" ] || sudo chmod -R a+rwx ./target",
+    "build": "pnpm resolve-dependencies && pnpm exec lz-tool --script 'sh scripts/build.sh' anchor && pnpm build:check && pnpm allow-read-write",
+    "build:check": "sh scripts/check-build-outputs.sh",
+    "format": "pnpm exec lz-tool --script 'cargo +nightly-2025-06-01 fmt --all' anchor",
+    "format:check": "pnpm exec lz-tool --script 'cargo +nightly-2025-06-01 fmt --all -- --check' anchor",
+    "lint": "pnpm resolve-dependencies && pnpm format:check && pnpm exec lz-tool --script 'cargo clippy --workspace --all-targets --locked -- -D warnings' anchor",
+    "resolve-dependencies": "pnpm exec build-utils-rust resolve",
+    "test": "pnpm test:rust",
+    "test:rust": "pnpm resolve-dependencies && pnpm exec lz-tool --script 'cargo test --workspace --locked' anchor",
+    "test:snapshot:check": "pnpm build:check && pnpm exec turbo-snapshot check",
+    "test:snapshot:update": "pnpm build:check && pnpm exec turbo-snapshot update"
+  }
 }

package/programs/pubkey_policy_hook/Cargo.toml

@@ -0,0 +1,36 @@
+[package]
+name = "pubkey-policy-hook"
+version = "0.1.0"
+authors = ["LayerZero Labs", "Shankar (@shankars99)"]
+edition = "2021"
+license = "MIT"
+description = "Optional Token-2022 hook enforcing a bound pubkey policy"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+name = "pubkey_policy_hook"
+
+[features]
+default = []
+no-entrypoint = []
+no-idl = []
+no-log-ix-name = []
+cpi = ["no-entrypoint"]
+custom-heap = []
+custom-panic = []
+anchor-debug = []
+idl-build = ["anchor-lang/idl-build", "anchor-spl/idl-build", "pubkey-policy-interface/idl-build"]
+
+[dependencies]
+anchor-lang.workspace = true
+anchor-spl.workspace = true
+pubkey-policy-interface.workspace = true
+program-id.workspace = true
+spl-discriminator.workspace = true
+spl-tlv-account-resolution.workspace = true
+spl-token-2022.workspace = true
+spl-token-2022-interface.workspace = true
+spl-transfer-hook-interface.workspace = true
+
+[lints]
+workspace = true

package/programs/pubkey_policy_hook/src/errors.rs

@@ -0,0 +1,10 @@
+pubkey_policy_interface::declare_policy_errors! {
+pub enum HookError {
+    #[msg("Only the mint transfer-hook authority may configure its pubkey policy")]
+    Unauthorized = 9000,
+    #[msg("The bound pubkey policy is for another mint")]
+    WrongPolicyMint,
+    #[msg("The hook only runs inside a Token-2022 transfer")]
+    NotTransferring,
+}
+}

package/programs/pubkey_policy_hook/src/events.rs

@@ -0,0 +1,8 @@
+use anchor_lang::prelude::*;
+
+#[event]
+pub struct TransferHookInitialized {
+    pub mint: Pubkey,
+    pub pubkey_policy: Pubkey,
+    pub authority: Pubkey,
+}

package/programs/pubkey_policy_hook/src/instructions/init_transfer_hook.rs

@@ -0,0 +1,99 @@
+use crate::{
+    account_metas, errors::HookError, TransferHookInitialized, EXTRA_COUNT, EXTRA_METAS_SEED,
+};
+use anchor_lang::prelude::*;
+use anchor_spl::token_interface::Mint;
+use pubkey_policy_interface::PubkeyPolicy;
+use spl_tlv_account_resolution::state::ExtraAccountMetaList;
+use spl_token_2022::processor::Processor;
+use spl_token_2022_interface::{
+    extension::{transfer_hook::TransferHook, BaseStateWithExtensions, StateWithExtensions},
+    state::Mint as MintState,
+};
+use spl_transfer_hook_interface::instruction::ExecuteInstruction;
+
+/// Only the mint's hook-update authority may bind or re-bind the policy, proven exactly as
+/// Token-2022 would: a plain signer, a CPI-signing PDA, or a native multisig whose member
+/// signatures are the remaining accounts (a multisig's own key never counts). The mint need not
+/// name this hook yet: the manifest is inert until it does, so it can be staged before a switch.
+/// The policy must be for this mint: the hook refuses any other on every transfer, which would
+/// stop the mint's transfers until the binding is fixed, and for good once the hook authority is
+/// renounced.
+#[event_cpi]
+#[derive(Accounts)]
+pub struct InitTransferHook<'info> {
+    #[account(mut)]
+    pub payer: Signer<'info>,
+
+    /// CHECK: The mint's hook-update authority, authenticated in the handler. Pass it as a signer
+    /// for a plain key or CPI-signing PDA, and as a non-signer for a native multisig, whose member
+    /// signers are the remaining accounts.
+    pub authority: UncheckedAccount<'info>,
+
+    #[account(owner = spl_token_2022_interface::ID)]
+    pub mint: InterfaceAccount<'info, Mint>,
+
+    /// CHECK: The pubkey policy the hook authority binds, under whichever program owns it; both
+    /// are written into the manifest. It must already exist (checked in `apply`), since its owner
+    /// is recorded as the program its records live under.
+    pub pubkey_policy: UncheckedAccount<'info>,
+
+    /// CHECK: The mint's hook manifest; written only after `authority` is authenticated.
+    #[account(
+        init_if_needed,
+        payer = payer,
+        space = ExtraAccountMetaList::size_of(EXTRA_COUNT).unwrap(),
+        seeds = [EXTRA_METAS_SEED, mint.key().as_ref()],
+        bump,
+    )]
+    pub extra_account_metas: UncheckedAccount<'info>,
+
+    pub system_program: Program<'info, System>,
+}
+
+impl InitTransferHook<'_> {
+    pub fn apply(ctx: &mut Context<Self>) -> Result<()> {
+        {
+            let mint_info = ctx.accounts.mint.to_account_info();
+            let mint_data = mint_info.try_borrow_data()?;
+            let mint = StateWithExtensions::<MintState>::unpack(&mint_data)?;
+            let hook = mint.get_extension::<TransferHook>()?;
+            let expected =
+                Option::<Pubkey>::from(hook.authority).ok_or(error!(HookError::Unauthorized))?;
+            // Pass Token-2022 as program_id, never this program: validate_owner treats any account
+            // owned by program_id with multisig length as a multisig.
+            let authority = ctx.accounts.authority.to_account_info();
+            Processor::validate_owner(
+                &spl_token_2022_interface::ID,
+                &expected,
+                &authority,
+                authority.data_len(),
+                ctx.remaining_accounts,
+            )
+            .map_err(|_| error!(HookError::Unauthorized))?;
+        }
+        // A policy not created yet is owned by the System Program, which would be recorded as the
+        // policy program.
+        let policy =
+            PubkeyPolicy::try_deserialize(&mut &ctx.accounts.pubkey_policy.try_borrow_data()?[..])?;
+        require_keys_eq!(policy.mint, ctx.accounts.mint.key(), HookError::WrongPolicyMint);
+        {
+            let mut manifest = ctx.accounts.extra_account_metas.try_borrow_mut_data()?;
+            manifest.fill(0);
+            ExtraAccountMetaList::init::<ExecuteInstruction>(
+                &mut manifest,
+                &account_metas(
+                    &ctx.accounts.pubkey_policy.key(),
+                    ctx.accounts.pubkey_policy.owner,
+                )?,
+            )?;
+        }
+
+        emit_cpi!(TransferHookInitialized {
+            mint: ctx.accounts.mint.key(),
+            pubkey_policy: ctx.accounts.pubkey_policy.key(),
+            authority: ctx.accounts.authority.key(),
+        });
+        Ok(())
+    }
+}

package/programs/pubkey_policy_hook/src/instructions/mod.rs

@@ -0,0 +1,5 @@
+pub mod init_transfer_hook;
+pub mod transfer_hook;
+
+pub use init_transfer_hook::*;
+pub use transfer_hook::*;

package/programs/pubkey_policy_hook/src/instructions/transfer_hook.rs

@@ -0,0 +1,103 @@
+use crate::errors::HookError;
+use anchor_lang::prelude::*;
+use anchor_spl::token_interface::{Mint, TokenAccount};
+use pubkey_policy_interface::{PolicyError, ValidatedPubkeyPolicy};
+use spl_token_2022_interface::{
+    extension::{
+        permanent_delegate::get_permanent_delegate, transfer_hook::TransferHookAccount,
+        BaseStateWithExtensions, StateWithExtensions,
+    },
+    state::{Account as AccountState, Mint as MintState},
+};
+
+#[derive(Clone, AnchorSerialize, AnchorDeserialize)]
+pub struct TransferHookParams {
+    /// SPL `Execute` payload; unused, since the policy does not depend on the amount.
+    pub amount: u64,
+}
+
+/// Token-2022 invokes this during a transfer with the accounts it resolved from this mint's
+/// manifest, which only `init_transfer_hook` writes (first extra: the bound pubkey policy). The
+/// hook writes nothing and makes no CPI. It requires Token-2022's `transferring` flag on both token
+/// accounts, so a direct `Execute` call fails instead of looking like a transfer; it does not
+/// re-check the manifest.
+#[derive(Accounts)]
+pub struct TransferHook<'info> {
+    pub source: InterfaceAccount<'info, TokenAccount>,
+
+    pub mint: InterfaceAccount<'info, Mint>,
+
+    pub destination: InterfaceAccount<'info, TokenAccount>,
+
+    /// CHECK: Token-2022 validated the owner, delegate or permanent delegate.
+    pub authority: UncheckedAccount<'info>,
+
+    /// CHECK: The canonical manifest Token-2022 resolved the extras from.
+    pub extra_account_metas: UncheckedAccount<'info>,
+
+    /// CHECK: The policy the manifest binds; decoded in the handler.
+    pub pubkey_policy: UncheckedAccount<'info>,
+
+    /// CHECK: The program that owns the policy and its records, named by the manifest for the
+    /// records' derivation; never invoked. The reader takes the program from the policy's owner,
+    /// so a manifest naming another program fails the record check.
+    pub policy_program: UncheckedAccount<'info>,
+
+    /// CHECK: Owner's subject record; `ValidatedPubkeyPolicy::read` checks its address and owner.
+    pub source_record: UncheckedAccount<'info>,
+
+    /// CHECK: Owner's subject record; `ValidatedPubkeyPolicy::read` checks its address and owner.
+    pub destination_record: UncheckedAccount<'info>,
+
+    /// CHECK: Authority's subject record; `ValidatedPubkeyPolicy::read` checks its address and
+    /// owner.
+    pub authority_record: UncheckedAccount<'info>,
+}
+
+impl TransferHook<'_> {
+    pub fn apply(ctx: &Context<Self>, _params: &TransferHookParams) -> Result<()> {
+        let accounts = &ctx.accounts;
+        require!(
+            is_transferring(&accounts.source)? && is_transferring(&accounts.destination)?,
+            HookError::NotTransferring
+        );
+
+        // The mint's Permanent Delegate is exempt, matching EVM `recoverFunds`' unchecked
+        // `_transfer`. Token-2022 has authenticated it and already rejects frozen accounts.
+        if accounts.authority_is_permanent_delegate()? {
+            return Ok(());
+        }
+
+        // Check source, destination and the actual executing authority, not source.delegate:
+        // Token-2022 clears an exhausted delegate allowance before invoking us.
+        for (record, subject) in [
+            (&accounts.source_record, accounts.source.owner),
+            (&accounts.destination_record, accounts.destination.owner),
+            (&accounts.authority_record, accounts.authority.key()),
+        ] {
+            let validated = ValidatedPubkeyPolicy::read(&accounts.pubkey_policy, record, &subject)?;
+            // `init_transfer_hook` already refuses another mint's policy; checked again so the hook
+            // stays correct on its own.
+            require_keys_eq!(validated.mint(), accounts.mint.key(), HookError::WrongPolicyMint);
+            require!(!validated.is_blocked(), PolicyError::Blocked);
+        }
+        Ok(())
+    }
+
+    fn authority_is_permanent_delegate(&self) -> Result<bool> {
+        let mint_info = self.mint.to_account_info();
+        let mint_data = mint_info.try_borrow_data()?;
+        let mint = StateWithExtensions::<MintState>::unpack(&mint_data)?;
+        Ok(get_permanent_delegate(&mint) == Some(self.authority.key()))
+    }
+}
+
+/// Token-2022 sets `transferring` on both accounts only for the duration of the hook call.
+fn is_transferring(account: &InterfaceAccount<TokenAccount>) -> Result<bool> {
+    let info = account.to_account_info();
+    let data = info.try_borrow_data()?;
+    let state = StateWithExtensions::<AccountState>::unpack(&data)?;
+    Ok(state
+        .get_extension::<TransferHookAccount>()
+        .is_ok_and(|ext| bool::from(ext.transferring)))
+}

package/programs/pubkey_policy_hook/src/lib.rs

@@ -0,0 +1,33 @@
+//! Optional transfer-time enforcement of a bound pubkey policy.
+
+use anchor_lang::prelude::*;
+use program_id::declare_program_id;
+use spl_discriminator::SplDiscriminate;
+use spl_transfer_hook_interface::instruction::ExecuteInstruction;
+
+pub mod errors;
+pub mod events;
+pub mod instructions;
+pub mod state;
+
+pub use events::*;
+pub use instructions::*;
+pub use state::*;
+
+declare_program_id!("PUBKEY_POLICY_HOOK_ID", "7HTVK1Jwzjd4yRGCZnLT4QmwhmZidurFxwz2RMAiUyzk");
+
+#[program]
+pub mod pubkey_policy_hook {
+    use super::*;
+
+    /// Create or rewrite the mint's hook manifest to bind `pubkey_policy`. Requires the mint's
+    /// hook-update authority; changes neither the policy nor the mint.
+    pub fn init_transfer_hook(mut ctx: Context<InitTransferHook>) -> Result<()> {
+        InitTransferHook::apply(&mut ctx)
+    }
+
+    #[instruction(discriminator = ExecuteInstruction::SPL_DISCRIMINATOR_SLICE)]
+    pub fn transfer_hook(ctx: Context<TransferHook>, params: TransferHookParams) -> Result<()> {
+        TransferHook::apply(&ctx, &params)
+    }
+}

package/programs/pubkey_policy_hook/src/state.rs

@@ -0,0 +1,51 @@
+//! The canonical SPL manifest is the hook's only persistent state.
+
+use anchor_lang::prelude::*;
+use pubkey_policy_interface::SUBJECT_SEED;
+use spl_tlv_account_resolution::{account::ExtraAccountMeta, seeds::Seed};
+
+pub const EXTRA_METAS_SEED: &[u8] = b"extra-account-metas";
+pub const EXTRA_COUNT: usize = 5;
+const SOURCE_ACCOUNT_INDEX: u8 = 0;
+const PUBKEY_POLICY_ACCOUNT_INDEX: u8 = 5;
+const DESTINATION_ACCOUNT_INDEX: u8 = 2;
+const AUTHORITY_ACCOUNT_INDEX: u8 = 3;
+const POLICY_PROGRAM_ACCOUNT_INDEX: u8 = 6;
+// SPL account base layout: mint (32 bytes), then owner (32 bytes).
+const TOKEN_ACCOUNT_OWNER_OFFSET: u8 = 32;
+const PUBKEY_LENGTH: u8 = 32;
+
+/// Execute accounts: source, mint, destination, authority, manifest, pubkey policy (5), the
+/// program that owns it (6), and the source/destination/authority records under it (7-9).
+pub fn account_metas(
+    pubkey_policy: &Pubkey,
+    policy_program: &Pubkey,
+) -> Result<Vec<ExtraAccountMeta>> {
+    let record = |subject_seed: Seed| {
+        ExtraAccountMeta::new_external_pda_with_seeds(
+            POLICY_PROGRAM_ACCOUNT_INDEX,
+            &[
+                Seed::Literal { bytes: SUBJECT_SEED.to_vec() },
+                Seed::AccountKey { index: PUBKEY_POLICY_ACCOUNT_INDEX },
+                subject_seed,
+            ],
+            false,
+            false,
+        )
+    };
+    Ok(vec![
+        ExtraAccountMeta::new_with_pubkey(pubkey_policy, false, false)?,
+        ExtraAccountMeta::new_with_pubkey(policy_program, false, false)?,
+        record(Seed::AccountData {
+            account_index: SOURCE_ACCOUNT_INDEX,
+            data_index: TOKEN_ACCOUNT_OWNER_OFFSET,
+            length: PUBKEY_LENGTH,
+        })?,
+        record(Seed::AccountData {
+            account_index: DESTINATION_ACCOUNT_INDEX,
+            data_index: TOKEN_ACCOUNT_OWNER_OFFSET,
+            length: PUBKEY_LENGTH,
+        })?,
+        record(Seed::AccountKey { index: AUTHORITY_ACCOUNT_INDEX })?,
+    ])
+}

package/programs/pubkey_policy_hook/tests/transfer_hook_policy.rs

@@ -0,0 +1,276 @@
+//! Handler-level policy tests, including Anchor account validation. These do not
+//! replace runtime tests of Token-2022 authority checks or transaction rollback.
+
+use anchor_lang::{prelude::*, solana_program::program_option::COption};
+use pubkey_policy_hook::{
+    account_metas,
+    errors::HookError,
+    instructions::transfer_hook::{TransferHook, TransferHookBumps, TransferHookParams},
+    EXTRA_COUNT, EXTRA_METAS_SEED, ID,
+};
+use pubkey_policy_interface::{
+    pubkey_policy_address, subject_address, Membership, PolicyError, PubkeyPolicy,
+    PubkeyPolicyMode, SubjectRecord,
+};
+use spl_tlv_account_resolution::state::ExtraAccountMetaList;
+use spl_token_2022::{
+    extension::{
+        permanent_delegate::PermanentDelegate,
+        transfer_hook::{TransferHook as HookExtension, TransferHookAccount},
+        BaseStateWithExtensionsMut, ExtensionType, StateWithExtensionsMut,
+    },
+    state::{Account as AccountState, Mint as MintState},
+};
+use spl_transfer_hook_interface::instruction::ExecuteInstruction;
+use std::collections::BTreeSet;
+
+// Positions in the Execute account list (see `account_metas`).
+const PUBKEY_POLICY: usize = 5;
+const POLICY_PROGRAM: usize = 6;
+const SOURCE_RECORD: usize = 7;
+const DESTINATION_RECORD: usize = 8;
+const AUTHORITY_RECORD: usize = 9;
+
+struct TestAccount {
+    key: Pubkey,
+    owner: Pubkey,
+    data: Vec<u8>,
+    lamports: u64,
+    executable: bool,
+}
+
+impl TestAccount {
+    fn new(key: Pubkey, owner: Pubkey, data: Vec<u8>) -> Self {
+        Self { key, owner, data, lamports: 1_000_000, executable: false }
+    }
+
+    fn info(&mut self) -> AccountInfo<'_> {
+        AccountInfo::new(
+            &self.key,
+            false,
+            false,
+            &mut self.lamports,
+            &mut self.data,
+            &self.owner,
+            self.executable,
+        )
+    }
+}
+
+fn record(policy: &Pubkey, subject: &Pubkey, blocked: bool) -> TestAccount {
+    let mut data = Vec::new();
+    SubjectRecord {
+        policy: *policy,
+        subject: *subject,
+        membership: Membership { blacklisted: blocked, whitelisted: false },
+    }
+    .try_serialize(&mut data)
+    .unwrap();
+    TestAccount::new(subject_address(policy, subject).0, pubkey_policy_interface::ID, data)
+}
+
+fn token_data(
+    mint: Pubkey,
+    owner: Pubkey,
+    delegate: Option<Pubkey>,
+    transferring: bool,
+) -> Vec<u8> {
+    let mut data = vec![
+        0;
+        ExtensionType::try_calculate_account_len::<AccountState>(&[
+            ExtensionType::TransferHookAccount
+        ],)
+        .unwrap()
+    ];
+    let mut state =
+        StateWithExtensionsMut::<AccountState>::unpack_uninitialized(&mut data).unwrap();
+    state.base = AccountState {
+        mint,
+        owner,
+        amount: 100,
+        delegate: delegate.into(),
+        state: spl_token_2022::state::AccountState::Initialized,
+        is_native: COption::None,
+        delegated_amount: if delegate.is_some() { 100 } else { 0 },
+        close_authority: COption::None,
+    };
+    state.init_extension::<TransferHookAccount>(false).unwrap().transferring = transferring.into();
+    state.init_account_type().unwrap();
+    state.pack_base();
+    data
+}
+
+/// When Some(true), the authority is the PD but is deliberately neither owner
+/// nor approved delegate. Some(false) configures a different PD. None omits PD.
+fn run_hook(
+    source_blocked: bool,
+    destination_blocked: bool,
+    authority_blocked: bool,
+    authority_is_pd: Option<bool>,
+    transferring: [bool; 2],
+    manifest_binds_other_policy: bool,
+) -> Result<()> {
+    run_hook_with_accounts(
+        source_blocked,
+        destination_blocked,
+        authority_blocked,
+        authority_is_pd,
+        transferring,
+        manifest_binds_other_policy,
+        |_| {},
+    )
+}
+
+fn run_hook_with_accounts(
+    source_blocked: bool,
+    destination_blocked: bool,
+    authority_blocked: bool,
+    authority_is_pd: Option<bool>,
+    transferring: [bool; 2],
+    manifest_binds_other_policy: bool,
+    mutate: impl FnOnce(&mut [TestAccount]),
+) -> Result<()> {
+    let mint = Pubkey::new_unique();
+    let admin = Pubkey::new_unique();
+    let authority = Pubkey::new_unique();
+    let source_owner = Pubkey::new_unique();
+    let destination_owner = Pubkey::new_unique();
+    let policy_key = pubkey_policy_address(&mint, &admin).0;
+    let policy = PubkeyPolicy {
+        mint,
+        current_default_admin: admin,
+        pending_default_admin: Pubkey::default(),
+        mode: PubkeyPolicyMode::Blacklist,
+    };
+    let mut policy_data = Vec::new();
+    policy.try_serialize(&mut policy_data).unwrap();
+
+    let mut extensions = vec![ExtensionType::TransferHook];
+    if authority_is_pd.is_some() {
+        extensions.push(ExtensionType::PermanentDelegate);
+    }
+    let mut mint_data =
+        vec![0; ExtensionType::try_calculate_account_len::<MintState>(&extensions).unwrap()];
+    let mut mint_state =
+        StateWithExtensionsMut::<MintState>::unpack_uninitialized(&mut mint_data).unwrap();
+    mint_state.base.is_initialized = true;
+    mint_state.base.decimals = 9;
+    mint_state.init_extension::<HookExtension>(false).unwrap().program_id =
+        Some(ID).try_into().unwrap();
+    if let Some(is_pd) = authority_is_pd {
+        let pd = if is_pd { authority } else { Pubkey::new_unique() };
+        mint_state.init_extension::<PermanentDelegate>(false).unwrap().delegate =
+            Some(pd).try_into().unwrap();
+    }
+    mint_state.init_account_type().unwrap();
+    mint_state.pack_base();
+
+    let manifest_key = Pubkey::find_program_address(&[EXTRA_METAS_SEED, mint.as_ref()], &ID).0;
+    let mut manifest_data = vec![0; ExtraAccountMetaList::size_of(EXTRA_COUNT).unwrap()];
+    ExtraAccountMetaList::init::<ExecuteInstruction>(
+        &mut manifest_data,
+        &account_metas(
+            &if manifest_binds_other_policy {
+                pubkey_policy_address(&mint, &Pubkey::new_unique()).0
+            } else {
+                policy_key
+            },
+            &pubkey_policy_interface::ID,
+        )
+        .unwrap(),
+    )
+    .unwrap();
+    let source_delegate = (authority_is_pd != Some(true)).then_some(authority);
+    let mut accounts = [
+        TestAccount::new(
+            Pubkey::new_unique(),
+            spl_token_2022::ID,
+            token_data(mint, source_owner, source_delegate, transferring[0]),
+        ),
+        TestAccount::new(mint, spl_token_2022::ID, mint_data),
+        TestAccount::new(
+            Pubkey::new_unique(),
+            spl_token_2022::ID,
+            token_data(mint, destination_owner, None, transferring[1]),
+        ),
+        TestAccount::new(authority, System::id(), vec![]),
+        TestAccount::new(manifest_key, ID, manifest_data),
+        TestAccount::new(policy_key, pubkey_policy_interface::ID, policy_data),
+        TestAccount {
+            executable: true,
+            ..TestAccount::new(
+                pubkey_policy_interface::ID,
+                anchor_lang::solana_program::bpf_loader_upgradeable::ID,
+                vec![],
+            )
+        },
+        record(&policy_key, &source_owner, source_blocked),
+        record(&policy_key, &destination_owner, destination_blocked),
+        record(&policy_key, &authority, authority_blocked),
+    ];
+    mutate(&mut accounts);
+    let infos: Vec<_> = accounts.iter_mut().map(TestAccount::info).collect();
+    let mut remaining = infos.as_slice();
+    let mut bumps = TransferHookBumps::default();
+    let mut validated =
+        TransferHook::try_accounts(&ID, &mut remaining, &[], &mut bumps, &mut BTreeSet::new())?;
+    let context = Context::new(&ID, &mut validated, remaining, bumps);
+    TransferHook::apply(&context, &TransferHookParams { amount: 1 })
+}
+
+fn assert_error(result: Result<()>, code: impl Into<u32>) {
+    let anchor_lang::error::Error::AnchorError(error) = result.unwrap_err() else {
+        panic!("expected an Anchor error");
+    };
+    assert_eq!(error.error_code_number, code.into());
+}
+
+/// The mint's actual permanent delegate is exempt from every check; anyone else is checked on
+/// source, destination and authority.
+#[test]
+fn actual_pd_is_exempt_and_everyone_else_is_fully_checked() {
+    for is_pd in [None, Some(false), Some(true)] {
+        for source in [false, true] {
+            for destination in [false, true] {
+                for authority in [false, true] {
+                    let result =
+                        run_hook(source, destination, authority, is_pd, [true, true], false);
+                    let allowed = is_pd == Some(true) || (!source && !destination && !authority);
+                    if allowed {
+                        result.unwrap();
+                    } else {
+                        assert_error(result, PolicyError::Blocked);
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn typed_policy_and_subject_record_boundaries_remain_enforced() {
+    use anchor_lang::error::ErrorCode;
+    type Substitute = fn(&mut [TestAccount]);
+    let substitutions: [(Substitute, u32); 5] = [
+        (|a| a[PUBKEY_POLICY].data[..8].fill(0), ErrorCode::AccountDiscriminatorMismatch.into()),
+        // The policy's mint follows its discriminator.
+        (|a| a[PUBKEY_POLICY].data[8..40].fill(7), HookError::WrongPolicyMint.into()),
+        (|a| a[SOURCE_RECORD].key = Pubkey::new_unique(), PolicyError::WrongRecord.into()),
+        (|a| a[DESTINATION_RECORD].key = Pubkey::new_unique(), PolicyError::WrongRecord.into()),
+        (|a| a[AUTHORITY_RECORD].key = Pubkey::new_unique(), PolicyError::WrongRecord.into()),
+    ];
+    for (substitute, code) in substitutions {
+        assert_error(
+            run_hook_with_accounts(false, false, false, None, [true, true], false, substitute),
+            code,
+        );
+    }
+}
+
+#[test]
+fn policy_program_key_is_a_pda_namespace_not_an_invocation_target() {
+    run_hook_with_accounts(false, false, false, None, [true, true], false, |accounts| {
+        accounts[POLICY_PROGRAM].executable = false;
+    })
+    .unwrap();
+}

package/rust-toolchain.toml

@@ -0,0 +1,3 @@
+[toolchain]
+channel = "1.97.1"
+components = ["rustfmt", "clippy"]

package/rustfmt.toml

@@ -0,0 +1,19 @@
+# Matches console-oft-app/contracts/solana.
+hard_tabs = false
+max_width = 100
+use_small_heuristics = "Max"
+imports_granularity = "Crate"
+reorder_imports = true
+newline_style = "Unix"
+comment_width = 100
+wrap_comments = true
+chain_width = 80
+spaces_around_ranges = false
+binop_separator = "Front"
+reorder_impl_items = false
+match_arm_leading_pipes = "Preserve"
+match_arm_blocks = true
+match_block_trailing_comma = true
+trailing_comma = "Vertical"
+trailing_semicolon = true
+use_field_init_shorthand = true

package/scripts/build.sh

@@ -0,0 +1,8 @@
+#!/bin/sh
+# Runs inside the Anchor VM. Macro-derived addresses need repairing in JSON
+# before generating the TypeScript types, otherwise their address literals differ.
+set -eu
+
+anchor build --ignore-keys
+add_address_to_idl.py
+anchor idl type target/idl/pubkey_policy_hook.json --out target/types/pubkey_policy_hook.ts

package/scripts/check-build-outputs.sh

@@ -0,0 +1,11 @@
+#!/bin/sh
+# The generic snapshot tool can succeed with a partially populated output tree.
+# Require every production artifact; ignore unrelated or stale local artifacts.
+set -eu
+
+for artifact in target/deploy/pubkey_policy_hook.so target/idl/pubkey_policy_hook.json target/types/pubkey_policy_hook.ts; do
+    if [ ! -s "$artifact" ]; then
+        echo "Missing or empty build artifact: $artifact (run pnpm build first)" >&2
+        exit 1
+    fi
+done

package/turbo-snapshot.lock.json

@@ -0,0 +1,218 @@
+{
+  "dependencies/framework-solana-anchor-trait/Cargo.toml": {
+    "hash": "0b7f948a88e45d146c6d2e7398cb8bed5c6f9055efbeb304f4dc0fb6b8886a2e",
+    "size": 953
+  },
+  "dependencies/framework-solana-anchor-trait/src/assembly.rs": {
+    "hash": "94d17961365f4ad90ecc7e5f6490032f4bf88887ded949d44a816841ece37884",
+    "size": 4451
+  },
+  "dependencies/framework-solana-anchor-trait/src/generation.rs": {
+    "hash": "13cc38f6473f8629f4a2acfdcc64f0d5e328a63ea44ada2b80386f10ea4b35b9",
+    "size": 8385
+  },
+  "dependencies/framework-solana-anchor-trait/src/lib.rs": {
+    "hash": "7fd1a01908e0da13281f55106ee97191a3fcca9ba9d56dbd67f351b22bd9de76",
+    "size": 5525
+  },
+  "dependencies/framework-solana-anchor-trait/src/overrides.rs": {
+    "hash": "0a2c9dc934266b3d0da955592a5d5cb140a65d31558d8b0a0c474cfd4d9a25b4",
+    "size": 10546
+  },
+  "dependencies/program-id-solana-contracts/Cargo.toml": {
+    "hash": "80b65002644e7d4dee9c1817b4e601771389cde3999ad07c4c78b985731eb8cf",
+    "size": 89
+  },
+  "dependencies/program-id-solana-contracts/lib/Cargo.toml": {
+    "hash": "72a806d6fd7b3ff3205bb0c187313d5b4e72e9bdd4394713bd8d44b054404d85",
+    "size": 306
+  },
+  "dependencies/program-id-solana-contracts/lib/src/lib.rs": {
+    "hash": "418ce6414b5aac485677d046e3a5f73f2f82002f7a7fe161c7c44edae15c2fb4",
+    "size": 2226
+  },
+  "dependencies/pubkey-policy-solana-contracts/Cargo.toml": {
+    "hash": "5cb0ffec9e21293faa338723ac505853da1fcbb5ddb6c99f9d8ad40c5fca7828",
+    "size": 1186
+  },
+  "dependencies/pubkey-policy-solana-contracts/interface/Cargo.toml": {
+    "hash": "afa7632da897d1e2c3f347ad530795c578f4f3ff050ff1117007f44b19b0a9a0",
+    "size": 296
+  },
+  "dependencies/pubkey-policy-solana-contracts/interface/src/error.rs": {
+    "hash": "df8a87d7d773ff2070faba2cb7cc6dcbb4199c22966ea988da8a560d3f0ec693",
+    "size": 1342
+  },
+  "dependencies/pubkey-policy-solana-contracts/interface/src/lib.rs": {
+    "hash": "d2f68529deea1483337a8bae664ee07e38ed7ffd0e763189a3e20d882161c6e7",
+    "size": 503
+  },
+  "dependencies/pubkey-policy-solana-contracts/interface/src/pubkey_policy.rs": {
+    "hash": "327a0e805d1c87aed14a6368fe8471853d961d5c0ed30eec1e5b31a8da084ee0",
+    "size": 10828
+  },
+  "dependencies/pubkey-policy-solana-contracts/interface/src/seeds.rs": {
+    "hash": "5cf8967100a547fbed373f7bc5935c7306fe2b59771ff2f64a9ea2e9213fa8c8",
+    "size": 895
+  },
+  "dependencies/pubkey-policy-solana-contracts/interface/src/state.rs": {
+    "hash": "f796e40fbb13f25d66f57663b6fe9804b2cf46722ca99d7ea92a04b06cf889ed",
+    "size": 2344
+  },
+  "dependencies/pubkey-policy-solana-contracts/interface/src/version.rs": {
+    "hash": "cc1e1e22dbaaf0e5888990caa3aa361b0e3534bde4a625b701efd3b0381a6d6c",
+    "size": 846
+  },
+  "dependencies/pubkey-policy-solana-contracts/programs/pubkey_policy/Cargo.toml": {
+    "hash": "3d1caa746fb84ad5721a4c8013f5d079fc1336acca12d3ad9611f273b7d67dea",
+    "size": 727
+  },
+  "dependencies/pubkey-policy-solana-contracts/programs/pubkey_policy/src/errors.rs": {
+    "hash": "19219a369dba7886701ec1c9bb05a9e37845e2a0b363c4616c3cb0602431f74f",
+    "size": 392
+  },
+  "dependencies/pubkey-policy-solana-contracts/programs/pubkey_policy/src/events.rs": {
+    "hash": "3e46edfe3bce2ca16954b08438ff97133bae42ab3dd23c05cc79f1da98e6c7d1",
+    "size": 583
+  },
+  "dependencies/pubkey-policy-solana-contracts/programs/pubkey_policy/src/instructions/get_version.rs": {
+    "hash": "ae16bc35b0fda5507e2b932b621993ec1368f7cada2273df63821ece25c75405",
+    "size": 321
+  },
+  "dependencies/pubkey-policy-solana-contracts/programs/pubkey_policy/src/instructions/init_pubkey_policy.rs": {
+    "hash": "87d6cf6f9ae5578ff4aebe8db7781f3cdc004afedaf0c79be278b65981a35fca",
+    "size": 1940
+  },
+  "dependencies/pubkey-policy-solana-contracts/programs/pubkey_policy/src/instructions/membership.rs": {
+    "hash": "96df73837f8b7e5562902ff58f1ea2a365fafa7e4c3cd04c449f5d742e4b1304",
+    "size": 1070
+  },
+  "dependencies/pubkey-policy-solana-contracts/programs/pubkey_policy/src/instructions/mod.rs": {
+    "hash": "dd7d6750234b2a69311349f638a76cbb5e3a251ff54293f358c157c3da246f35",
+    "size": 266
+  },
+  "dependencies/pubkey-policy-solana-contracts/programs/pubkey_policy/src/instructions/set_blacklisted.rs": {
+    "hash": "276324d4aca0bea3c90cafc09a81e410a675a5a0e1f392054bc7bb602a3be8e6",
+    "size": 1652
+  },
+  "dependencies/pubkey-policy-solana-contracts/programs/pubkey_policy/src/instructions/set_mode.rs": {
+    "hash": "adaa9f3a43ae021d8ef7761c4313038faaa770ac018d0841faa34f3d848c75fc",
+    "size": 820
+  },
+  "dependencies/pubkey-policy-solana-contracts/programs/pubkey_policy/src/instructions/set_whitelisted.rs": {
+    "hash": "26d64868cad2acb05d6bbcf0bba6b304a15f8b14ea17b6a7ea0181d9d36cb975",
+    "size": 1652
+  },
+  "dependencies/pubkey-policy-solana-contracts/programs/pubkey_policy/src/lib.rs": {
+    "hash": "574dec75e6cb37a45b96e02a6dc0cbe60dbb88095e477ed150c9227f7f53af75",
+    "size": 1848
+  },
+  "dependencies/pubkey-policy-solana-contracts/programs/pubkey_policy/src/types.rs": {
+    "hash": "22bbf4d42a1b7dad95554565a879a7c12c9cbcd8e8fad869dc7158cc390cc323",
+    "size": 650
+  },
+  "dependencies/rbac-solana-contracts/Cargo.toml": {
+    "hash": "5952cecde0045443aeb270137acc3a1c4d082c9bc294521e5d7f62381cb4d98c",
+    "size": 739
+  },
+  "dependencies/rbac-solana-contracts/macros/Cargo.toml": {
+    "hash": "f60b1cd9b00fe183904ad5f9b1353ba168afee15f0189392b2cd66d9203e125a",
+    "size": 410
+  },
+  "dependencies/rbac-solana-contracts/macros/src/init_default_admin.rs": {
+    "hash": "231520848042bba179fb73aa969ca5b65854941635508ba7b404202f5746f81e",
+    "size": 2830
+  },
+  "dependencies/rbac-solana-contracts/macros/src/instructions/accept_default_admin_transfer.rs": {
+    "hash": "b93649e17ad83dd06b7b514d78e69c24326e03b68108ccc014a0d4fe441098f6",
+    "size": 4610
+  },
+  "dependencies/rbac-solana-contracts/macros/src/instructions/begin_default_admin_transfer.rs": {
+    "hash": "b23e1b6f3cc315b965ca443484d00e9b15e3fd40dbdb6ce50d7d2e85435a851f",
+    "size": 2209
+  },
+  "dependencies/rbac-solana-contracts/macros/src/instructions/get_default_admin.rs": {
+    "hash": "fa6c69183befaa5edf5545174c473a854c1dee7a26a3d77c803f3b876361f9f6",
+    "size": 1534
+  },
+  "dependencies/rbac-solana-contracts/macros/src/instructions/grant_role.rs": {
+    "hash": "1ae6fb336a1649f931da42ef3450357e55a6a438fa06a10a428a61be7c034084",
+    "size": 4210
+  },
+  "dependencies/rbac-solana-contracts/macros/src/instructions/mod.rs": {
+    "hash": "768f50e7d5750770cc79b81f639f765cf202af28808afbe6e801be448eb16ca0",
+    "size": 882
+  },
+  "dependencies/rbac-solana-contracts/macros/src/instructions/renounce_role.rs": {
+    "hash": "3a443beef4bd6eb3cac0ef89c5ef941d9c05fe4d256604aa301d530701d89568",
+    "size": 3285
+  },
+  "dependencies/rbac-solana-contracts/macros/src/instructions/revoke_role.rs": {
+    "hash": "9b37dca9843fb49f854666216cca3a4731bed63949fdc5ec4340ffcf2665d1ee",
+    "size": 4015
+  },
+  "dependencies/rbac-solana-contracts/macros/src/lib.rs": {
+    "hash": "736aed9a41b41fc494ce83823e72bcce43aac891f2cb8cf4fd30c9e95fd57cbc",
+    "size": 6081
+  },
+  "dependencies/rbac-solana-contracts/macros/src/only_role.rs": {
+    "hash": "57e96f7a7642c12442122221dbd70e78b9391f1478785a875ecaa3b3f3962b3a",
+    "size": 1933
+  },
+  "dependencies/rbac-solana-contracts/macros/src/rbac.rs": {
+    "hash": "64ef4430c489db3dc1a1448924c501d184e8e71705c814be3546ed1f725c7026",
+    "size": 2248
+  },
+  "dependencies/rbac-solana-contracts/macros/src/role_type.rs": {
+    "hash": "d721b4b7c4a7874bde4eb9288405448adf93bef4bcd65ff58a3a6a02555871c0",
+    "size": 1946
+  },
+  "dependencies/rbac-solana-contracts/macros/src/setup_default_admin.rs": {
+    "hash": "f57017eec0d662d9eb940b46b9f6447b97b7c2bf9323c05c789c32de04981be1",
+    "size": 4204
+  },
+  "dependencies/rbac-solana-contracts/macros/src/state_types.rs": {
+    "hash": "7a8eb86ef0d1551e2b4cf8e6b6d07cfdc90efd85a69a9ef84ffc910a4a6ee4f8",
+    "size": 3764
+  },
+  "dependencies/rbac-solana-contracts/macros/src/utils.rs": {
+    "hash": "c0853f52de9ff03c456987700eb19ffd2759361e4930b2fa0d4e43b095df11bb",
+    "size": 2093
+  },
+  "dependencies/rbac-solana-contracts/src/errors.rs": {
+    "hash": "4cb21ae9175155c5d8192db1f7d9e5841c0a6a8dbb06e05173794a655ff71c79",
+    "size": 1737
+  },
+  "dependencies/rbac-solana-contracts/src/events.rs": {
+    "hash": "748a6421feac3decd612b83b0e4431040b3d4d760c3dfb285fe06528d538177b",
+    "size": 1497
+  },
+  "dependencies/rbac-solana-contracts/src/lib.rs": {
+    "hash": "66ddc73dc314a30d5083795653acefc6a4d3ae9277933dd428f573393c024a1d",
+    "size": 3122
+  },
+  "dependencies/rbac-solana-contracts/src/traits.rs": {
+    "hash": "5261d024f8eec774c09f673dbc738e3f7f7c3c528c365f7ef40d3b49014b4292",
+    "size": 2980
+  },
+  "dependencies/rbac-solana-contracts/src/types.rs": {
+    "hash": "cda8f74904eb546f4d9fc8ded80900e2b33b550ec9cdba800216f92972ab1295",
+    "size": 966
+  },
+  "target/deploy/pubkey_policy_hook.so": {
+    "hash": "36066e41bc94ada17546993db302943713f65c0db5d8cfc60ec15fa4e702382a",
+    "size": 180848
+  },
+  "target/idl/pubkey_policy_hook.json": {
+    "hash": "d9101eb70c8dcf4a8a9c3cea7040df09c78b8cf76f0e54cce750c2e794650b37",
+    "size": 4719
+  },
+  "target/types/pubkey_policy_hook.ts": {
+    "hash": "0449cf898a7be975338e82dca086476e7c4fde71dcce28f7255ee9321e27186e",
+    "size": 4951
+  },
+  "target/types/pubkey_policy_hook_errors.ts": {
+    "hash": "6fc6fae620c6ee9f4256593877ba1804d4dda58e35f3a6ac1185a53dd30672a6",
+    "size": 300
+  }
+}

package/turbo.json

@@ -0,0 +1,19 @@
+{
+    "extends": ["//"],
+    "tasks": {
+        "build": {
+            "inputs": [
+                "$TURBO_DEFAULT$",
+                "!**/*.md",
+                "!**/LICENSE",
+                "!programs/**/tests/**",
+                "!tests/**/*.rs",
+                "!turbo-snapshot.lock.json"
+            ],
+            "outputs": ["dependencies/**", "target/deploy/*.so", "target/idl/**", "target/types/**"]
+        },
+        "test": {
+            "dependsOn": ["build", "lint"]
+        }
+    }
+}