@bondedhq/solana 0.0.0-stage → 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,183 @@
+import { type Commitment, type Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { bondedCoverIdl, bondedRegistryIdl, bondedVaultIdl } from "./idls.js";
+/**
+ * TypeScript client for the Bonded Solana programs (docs/decisions/011-solana-programs.md).
+ * Accounts are decoded and instructions encoded from the programs' own IDLs (src/idls.ts,
+ * generated from the Anchor build), so layouts can't drift from the Rust. The Rust twin is
+ * contracts/solana/crates/bonded_client; both derive the same addresses.
+ */
+export { bondedCoverIdl, bondedRegistryIdl, bondedVaultIdl };
+export declare const PROGRAM_IDS: {
+    readonly registry: PublicKey;
+    readonly vault: PublicKey;
+    readonly cover: PublicKey;
+};
+export declare const TOKEN_PROGRAM: PublicKey;
+/** Program-derived addresses, with the same seeds as the programs and bonded_client. */
+export declare const address: {
+    registryConfig: () => PublicKey;
+    agent: (agentId: bigint) => PublicKey;
+    vaultConfig: () => PublicKey;
+    vault: (guardian: PublicKey, agentId: bigint) => PublicKey;
+    vaultBase: (vault: PublicKey) => PublicKey;
+    coverConfig: () => PublicKey;
+    poolVault: () => PublicKey;
+    claimsAuthority: () => PublicKey;
+    bond: (agentId: bigint) => PublicKey;
+    bondVault: (agentId: bigint) => PublicKey;
+    policy: (policyId: bigint) => PublicKey;
+};
+export interface Breach {
+    /** The breach's index in the vault's log: what a claim names. */
+    id: number;
+    type: string;
+    blocked: boolean;
+    claimed: boolean;
+    target: PublicKey;
+    timestamp: number;
+    /** Base-asset units that left the vault. */
+    loss: bigint;
+}
+export interface Vault {
+    address: PublicKey;
+    guardian: PublicKey;
+    agent: PublicKey;
+    agentId: bigint;
+    baseMint: PublicKey;
+    frozen: boolean;
+    breaches: Breach[];
+}
+/** Everything a vault account holds: what `execute` checks an action against. */
+export interface VaultAccount extends Vault {
+    baseAccount: PublicKey;
+    mandateHash: Uint8Array;
+    /** Enforce mode: a breaching action is stopped (Monitor lets it through and records it). */
+    enforce: boolean;
+    freezeOnBreach: boolean;
+    /** Programs the agent may call through the vault. */
+    allowedPrograms: PublicKey[];
+    /** Largest net base-asset outflow of one call, in base units (the T2 limit). */
+    maxOutflowPerCall: bigint;
+}
+export interface Policy {
+    address: PublicKey;
+    policyId: bigint;
+    agentId: bigint;
+    vault: PublicKey;
+    coverAmount: bigint;
+    remainingCover: bigint;
+    startedAt: number;
+    endsAt: number;
+    active: boolean;
+}
+export interface CoverConfig {
+    baseMint: PublicKey;
+    claimWindow: number;
+    nextPolicyId: bigint;
+}
+export declare function decodeVault(address: PublicKey, data: Buffer): VaultAccount;
+export declare function decodePolicy(address: PublicKey, data: Buffer): Policy;
+export declare function decodeCoverConfig(data: Buffer): CoverConfig;
+export declare function fetchVaults(connection: Connection): Promise<VaultAccount[]>;
+export declare function fetchPolicies(connection: Connection): Promise<Policy[]>;
+export declare function fetchCoverConfig(connection: Connection): Promise<CoverConfig>;
+/** One vault, or null if there is no account at `vault`. */
+export declare function fetchVault(connection: Connection, vault: PublicKey, commitment?: Commitment): Promise<VaultAccount | null>;
+export interface VaultParams {
+    agentId: bigint;
+    /** The agent's session key: the only key that can call `execute`. */
+    agent: PublicKey;
+    mandateHash: Uint8Array;
+    enforce: boolean;
+    freezeOnBreach: boolean;
+    allowedPrograms: PublicKey[];
+    /** Largest net base-asset outflow of one call, in base units. */
+    maxOutflowPerCall: bigint;
+}
+/** Create a vault for one agent; `guardian` signs and pays. The vault's address is `address.vault`. */
+export declare function createVaultInstruction(guardian: PublicKey, baseMint: PublicKey, params: VaultParams): TransactionInstruction;
+/** Add `amount` base units to the vault from `from`, a token account `depositor` controls. */
+export declare function depositInstruction(vault: Pick<Vault, "address" | "baseMint">, from: PublicKey, depositor: PublicKey, amount: bigint): TransactionInstruction;
+/**
+ * Wrap `inner`, an instruction the vault should perform (the vault as its signer, e.g. as a
+ * token account's owner), in the vault's `execute`, signed by the agent's key. The program
+ * checks it against the mandate before running it.
+ */
+export declare function executeInstruction(vault: Pick<Vault, "address" | "agent">, inner: TransactionInstruction): TransactionInstruction;
+/** A breach the vault recorded, from its `BreachRecorded` event. */
+export interface BreachEvent {
+    breachId: number;
+    type: string;
+    target: PublicKey;
+    /** Base-asset units that left the vault (0 when blocked). */
+    loss: bigint;
+    /** Enforce mode stopped the call: nothing moved. */
+    blocked: boolean;
+}
+/**
+ * The `BreachRecorded` events in a transaction's logs. Only events the vault program itself
+ * emitted count: a program the vault calls can print anything, so lines logged while another
+ * program is running are ignored.
+ */
+export declare function breachEventsFromLogs(logs: readonly string[]): BreachEvent[];
+/** The vault program's error for a custom error code (e.g. 6000 is `Frozen`), if it is one. */
+export declare function vaultError(code: number): {
+    name: string;
+    message: string;
+} | undefined;
+export interface ClaimPlan {
+    vault: Vault;
+    policy: Policy;
+    breachIds: number[];
+    loss: bigint;
+}
+/**
+ * The claims the cover program would accept now, applying its own rules: the policy is active
+ * and its claim window open, and each breach is unclaimed, not blocked, lost something and
+ * happened within the policy's term. One plan per vault and policy.
+ */
+export declare function claimable(vaults: readonly Vault[], policies: readonly Policy[], now: number, claimWindow: number): ClaimPlan[];
+/** File a claim for `plan`. Anyone can send it; the payout goes to the vault. */
+export declare function fileClaimInstruction(plan: ClaimPlan): TransactionInstruction;
+/** A score as the Solana registry stores it: the EVM `BondedTypes.Attestation` fields. */
+export interface SolanaAttestation {
+    agentId: bigint;
+    score: number;
+    expectedLossBps: number;
+    reportHash: Uint8Array;
+    mandateHash: Uint8Array;
+    codeHash: Uint8Array;
+    teeMeasurement: Uint8Array;
+    modelFamily: number;
+    issuedAt: number;
+    expiresAt: number;
+}
+export interface RegistryAgent {
+    agentId: bigint;
+    owner: PublicKey;
+    uri: string;
+    score: SolanaAttestation | null;
+}
+/** Domain tag the registry prefixes to every signed attestation (bonded_registry). */
+export declare const ATTESTATION_DOMAIN: Buffer<ArrayBuffer>;
+/**
+ * The exact bytes the attester signs: the domain tag, the registry's program id, then the
+ * Borsh-encoded attestation (bonded_registry::attestation_message).
+ */
+export declare function attestationMessage(attestation: SolanaAttestation): Buffer;
+export declare function fetchRegistryConfig(connection: Connection): Promise<{
+    attester: PublicKey;
+    agentCount: bigint;
+}>;
+export declare function fetchAgent(connection: Connection, agentId: bigint): Promise<RegistryAgent | null>;
+/** Register the next agent (id = agent count + 1), owned by `owner`, who signs and pays. */
+export declare function registerInstruction(owner: PublicKey, nextAgentId: bigint, uri: string): TransactionInstruction;
+/**
+ * Post a score: the Ed25519 check of the attester's signature over `attestationMessage`, then
+ * the registry instruction, which looks for that check just before it.
+ */
+export declare function postScoreInstructions(attestation: SolanaAttestation, attester: {
+    publicKey: PublicKey;
+    secretKey: Uint8Array;
+}): TransactionInstruction[];
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,389 @@
+import { BorshCoder } from "@anchor-lang/core";
+import { Ed25519Program, PublicKey, SystemProgram, SYSVAR_INSTRUCTIONS_PUBKEY, TransactionInstruction, } from "@solana/web3.js";
+import BN from "bn.js";
+import { bondedCoverIdl, bondedRegistryIdl, bondedVaultIdl } from "./idls.js";
+/**
+ * TypeScript client for the Bonded Solana programs (docs/decisions/011-solana-programs.md).
+ * Accounts are decoded and instructions encoded from the programs' own IDLs (src/idls.ts,
+ * generated from the Anchor build), so layouts can't drift from the Rust. The Rust twin is
+ * contracts/solana/crates/bonded_client; both derive the same addresses.
+ */
+export { bondedCoverIdl, bondedRegistryIdl, bondedVaultIdl };
+export const PROGRAM_IDS = {
+    registry: new PublicKey(bondedRegistryIdl.address),
+    vault: new PublicKey(bondedVaultIdl.address),
+    cover: new PublicKey(bondedCoverIdl.address),
+};
+export const TOKEN_PROGRAM = new PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+const SYSTEM_PROGRAM = SystemProgram.programId;
+const coders = {
+    vault: new BorshCoder(bondedVaultIdl),
+    cover: new BorshCoder(bondedCoverIdl),
+    registry: new BorshCoder(bondedRegistryIdl),
+};
+const u64 = (n) => new BN(n.toString()).toArrayLike(Buffer, "le", 8);
+const pda = (seeds, program) => PublicKey.findProgramAddressSync(seeds, program)[0];
+/** Program-derived addresses, with the same seeds as the programs and bonded_client. */
+export const address = {
+    registryConfig: () => pda([Buffer.from("config")], PROGRAM_IDS.registry),
+    agent: (agentId) => pda([Buffer.from("agent"), u64(agentId)], PROGRAM_IDS.registry),
+    vaultConfig: () => pda([Buffer.from("config")], PROGRAM_IDS.vault),
+    vault: (guardian, agentId) => pda([Buffer.from("vault"), guardian.toBuffer(), u64(agentId)], PROGRAM_IDS.vault),
+    vaultBase: (vault) => pda([Buffer.from("base"), vault.toBuffer()], PROGRAM_IDS.vault),
+    coverConfig: () => pda([Buffer.from("config")], PROGRAM_IDS.cover),
+    poolVault: () => pda([Buffer.from("pool_vault")], PROGRAM_IDS.cover),
+    claimsAuthority: () => pda([Buffer.from("claims")], PROGRAM_IDS.cover),
+    bond: (agentId) => pda([Buffer.from("bond"), u64(agentId)], PROGRAM_IDS.cover),
+    bondVault: (agentId) => pda([Buffer.from("bond_vault"), u64(agentId)], PROGRAM_IDS.cover),
+    policy: (policyId) => pda([Buffer.from("policy"), u64(policyId)], PROGRAM_IDS.cover),
+};
+const big = (v) => BigInt(v.toString());
+const num = (v) => Number(v.toString());
+export function decodeVault(address, data) {
+    const v = coders.vault.accounts.decode("Vault", data);
+    return {
+        address,
+        guardian: v.guardian,
+        agent: v.agent,
+        agentId: big(v.agent_id),
+        baseMint: v.base_mint,
+        baseAccount: v.base_account,
+        mandateHash: Uint8Array.from(v.mandate_hash),
+        enforce: v.enforce,
+        freezeOnBreach: v.freeze_on_breach,
+        allowedPrograms: v.allowed_programs,
+        maxOutflowPerCall: big(v.max_outflow_per_call),
+        frozen: v.frozen,
+        breaches: v.breaches.map((b, id) => ({
+            id,
+            type: Object.keys(b.breach_type)[0],
+            blocked: b.blocked,
+            claimed: b.claimed,
+            target: b.target,
+            timestamp: num(b.timestamp),
+            loss: big(b.loss),
+        })),
+    };
+}
+export function decodePolicy(address, data) {
+    const p = coders.cover.accounts.decode("Policy", data);
+    return {
+        address,
+        policyId: big(p.policy_id),
+        agentId: big(p.agent_id),
+        vault: p.vault,
+        coverAmount: big(p.cover_amount),
+        remainingCover: big(p.remaining_cover),
+        startedAt: num(p.started_at),
+        endsAt: num(p.ends_at),
+        active: p.active,
+    };
+}
+export function decodeCoverConfig(data) {
+    const c = coders.cover.accounts.decode("Config", data);
+    return {
+        baseMint: c.base_mint,
+        claimWindow: num(c.claim_window),
+        nextPolicyId: big(c.next_policy_id),
+    };
+}
+// ---------------------------------------------------------------- reading the chain
+/** Every account of one type a program owns, found by its Anchor discriminator. */
+async function accountsOf(connection, idl, program, name) {
+    const discriminator = idl.accounts.find((a) => a.name === name).discriminator;
+    return connection.getProgramAccounts(program, {
+        filters: [{ memcmp: { offset: 0, bytes: bs58(Buffer.from(discriminator)) } }],
+    });
+}
+function bs58(bytes) {
+    const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    let n = BigInt(`0x${bytes.toString("hex") || "0"}`);
+    let out = "";
+    while (n > 0n) {
+        out = ALPHABET[Number(n % 58n)] + out;
+        n /= 58n;
+    }
+    for (const b of bytes) {
+        if (b !== 0)
+            break;
+        out = `1${out}`;
+    }
+    return out;
+}
+export async function fetchVaults(connection) {
+    const accounts = await accountsOf(connection, bondedVaultIdl, PROGRAM_IDS.vault, "Vault");
+    return accounts.map((a) => decodeVault(a.pubkey, a.account.data));
+}
+export async function fetchPolicies(connection) {
+    const accounts = await accountsOf(connection, bondedCoverIdl, PROGRAM_IDS.cover, "Policy");
+    return accounts.map((a) => decodePolicy(a.pubkey, a.account.data));
+}
+export async function fetchCoverConfig(connection) {
+    const info = await connection.getAccountInfo(address.coverConfig());
+    if (!info)
+        throw new Error("the cover program isn't initialized on this cluster");
+    return decodeCoverConfig(info.data);
+}
+/** One vault, or null if there is no account at `vault`. */
+export async function fetchVault(connection, vault, commitment) {
+    const info = await connection.getAccountInfo(vault, commitment);
+    return info ? decodeVault(vault, info.data) : null;
+}
+/** Create a vault for one agent; `guardian` signs and pays. The vault's address is `address.vault`. */
+export function createVaultInstruction(guardian, baseMint, params) {
+    const vault = address.vault(guardian, params.agentId);
+    return new TransactionInstruction({
+        programId: PROGRAM_IDS.vault,
+        data: coders.vault.instruction.encode("create_vault", {
+            params: {
+                agent_id: new BN(params.agentId.toString()),
+                agent: params.agent,
+                mandate_hash: [...params.mandateHash],
+                enforce: params.enforce,
+                freeze_on_breach: params.freezeOnBreach,
+                allowed_programs: params.allowedPrograms,
+                max_outflow_per_call: new BN(params.maxOutflowPerCall.toString()),
+            },
+        }),
+        keys: metas(bondedVaultIdl, "create_vault", {
+            vault,
+            base_account: address.vaultBase(vault),
+            base_mint: baseMint,
+            guardian,
+            token_program: TOKEN_PROGRAM,
+            system_program: SYSTEM_PROGRAM,
+        }),
+    });
+}
+/** Add `amount` base units to the vault from `from`, a token account `depositor` controls. */
+export function depositInstruction(vault, from, depositor, amount) {
+    return new TransactionInstruction({
+        programId: PROGRAM_IDS.vault,
+        data: coders.vault.instruction.encode("deposit", { amount: new BN(amount.toString()) }),
+        keys: metas(bondedVaultIdl, "deposit", {
+            vault: vault.address,
+            base_account: address.vaultBase(vault.address),
+            base_mint: vault.baseMint,
+            from,
+            depositor,
+            token_program: TOKEN_PROGRAM,
+        }),
+    });
+}
+/**
+ * Wrap `inner`, an instruction the vault should perform (the vault as its signer, e.g. as a
+ * token account's owner), in the vault's `execute`, signed by the agent's key. The program
+ * checks it against the mandate before running it.
+ */
+export function executeInstruction(vault, inner) {
+    // The vault signs the inner call by PDA seeds, never as a transaction signer.
+    const remaining = inner.keys.map((key) => key.pubkey.equals(vault.address) ? { ...key, isSigner: false } : key);
+    return new TransactionInstruction({
+        programId: PROGRAM_IDS.vault,
+        data: coders.vault.instruction.encode("execute", { data: inner.data }),
+        keys: [
+            ...metas(bondedVaultIdl, "execute", {
+                vault: vault.address,
+                agent: vault.agent,
+                base_account: address.vaultBase(vault.address),
+                target_program: inner.programId,
+            }),
+            ...remaining,
+        ],
+    });
+}
+/**
+ * The `BreachRecorded` events in a transaction's logs. Only events the vault program itself
+ * emitted count: a program the vault calls can print anything, so lines logged while another
+ * program is running are ignored.
+ */
+export function breachEventsFromLogs(logs) {
+    const vault = PROGRAM_IDS.vault.toBase58();
+    const stack = [];
+    const events = [];
+    for (const line of logs) {
+        const invoke = /^Program (\w+) invoke \[\d+\]$/.exec(line);
+        if (invoke) {
+            stack.push(invoke[1]);
+            continue;
+        }
+        if (/^Program \w+ (success|failed)/.test(line)) {
+            stack.pop();
+            continue;
+        }
+        if (stack.at(-1) !== vault || !line.startsWith("Program data: "))
+            continue;
+        const event = coders.vault.events.decode(line.slice("Program data: ".length));
+        if (event?.name !== "BreachRecorded")
+            continue;
+        const e = event.data;
+        events.push({
+            breachId: e.breach_id,
+            type: Object.keys(e.breach_type)[0],
+            target: e.target,
+            loss: big(e.loss),
+            blocked: e.blocked,
+        });
+    }
+    return events;
+}
+/** The vault program's error for a custom error code (e.g. 6000 is `Frozen`), if it is one. */
+export function vaultError(code) {
+    const error = bondedVaultIdl.errors?.find((e) => e.code === code);
+    return error ? { name: error.name, message: error.msg ?? error.name } : undefined;
+}
+/**
+ * The claims the cover program would accept now, applying its own rules: the policy is active
+ * and its claim window open, and each breach is unclaimed, not blocked, lost something and
+ * happened within the policy's term. One plan per vault and policy.
+ */
+export function claimable(vaults, policies, now, claimWindow) {
+    const plans = [];
+    for (const policy of policies) {
+        if (!policy.active || now > policy.endsAt + claimWindow)
+            continue;
+        const vault = vaults.find((v) => v.address.equals(policy.vault));
+        if (!vault)
+            continue;
+        const breaches = vault.breaches.filter((b) => !b.claimed &&
+            !b.blocked &&
+            b.loss > 0n &&
+            b.timestamp >= policy.startedAt &&
+            b.timestamp <= policy.endsAt);
+        if (breaches.length === 0)
+            continue;
+        plans.push({
+            vault,
+            policy,
+            breachIds: breaches.map((b) => b.id),
+            loss: breaches.reduce((s, b) => s + b.loss, 0n),
+        });
+    }
+    return plans;
+}
+/** The accounts an instruction takes, in the IDL's order, with its writable and signer flags. */
+function metas(idl, instruction, accounts) {
+    const ix = idl.instructions.find((i) => i.name === instruction);
+    return ix.accounts.map((a) => {
+        const account = a;
+        const pubkey = accounts[account.name];
+        if (!pubkey)
+            throw new Error(`${instruction}: no address for account ${account.name}`);
+        return { pubkey, isWritable: !!account.writable, isSigner: !!account.signer };
+    });
+}
+/** File a claim for `plan`. Anyone can send it; the payout goes to the vault. */
+export function fileClaimInstruction(plan) {
+    const { vault, policy } = plan;
+    const data = coders.cover.instruction.encode("file_claim", {
+        breach_ids: Buffer.from(plan.breachIds),
+    });
+    return new TransactionInstruction({
+        programId: PROGRAM_IDS.cover,
+        data,
+        keys: metas(bondedCoverIdl, "file_claim", {
+            config: address.coverConfig(),
+            policy: policy.address,
+            vault: vault.address,
+            vault_base: address.vaultBase(vault.address),
+            bond: address.bond(policy.agentId),
+            bond_vault: address.bondVault(policy.agentId),
+            pool_vault: address.poolVault(),
+            base_mint: vault.baseMint,
+            claims_authority: address.claimsAuthority(),
+            vault_config: address.vaultConfig(),
+            vault_program: PROGRAM_IDS.vault,
+            token_program: TOKEN_PROGRAM,
+        }),
+    });
+}
+/** Domain tag the registry prefixes to every signed attestation (bonded_registry). */
+export const ATTESTATION_DOMAIN = Buffer.from("bonded-attestation-v1");
+const toRaw = (a) => ({
+    agent_id: new BN(a.agentId.toString()),
+    score: a.score,
+    expected_loss_bps: a.expectedLossBps,
+    report_hash: [...a.reportHash],
+    mandate_hash: [...a.mandateHash],
+    code_hash: [...a.codeHash],
+    tee_measurement: [...a.teeMeasurement],
+    model_family: a.modelFamily,
+    issued_at: new BN(a.issuedAt),
+    expires_at: new BN(a.expiresAt),
+});
+const fromRaw = (r) => ({
+    agentId: big(r.agent_id),
+    score: r.score,
+    expectedLossBps: r.expected_loss_bps,
+    reportHash: Uint8Array.from(r.report_hash),
+    mandateHash: Uint8Array.from(r.mandate_hash),
+    codeHash: Uint8Array.from(r.code_hash),
+    teeMeasurement: Uint8Array.from(r.tee_measurement),
+    modelFamily: r.model_family,
+    issuedAt: num(r.issued_at),
+    expiresAt: num(r.expires_at),
+});
+/**
+ * The exact bytes the attester signs: the domain tag, the registry's program id, then the
+ * Borsh-encoded attestation (bonded_registry::attestation_message).
+ */
+export function attestationMessage(attestation) {
+    return Buffer.concat([
+        ATTESTATION_DOMAIN,
+        PROGRAM_IDS.registry.toBuffer(),
+        coders.registry.types.encode("Attestation", toRaw(attestation)),
+    ]);
+}
+export async function fetchRegistryConfig(connection) {
+    const info = await connection.getAccountInfo(address.registryConfig());
+    if (!info)
+        throw new Error("the registry isn't initialized on this cluster");
+    const c = coders.registry.accounts.decode("Config", info.data);
+    return { attester: c.attester, agentCount: big(c.agent_count) };
+}
+export async function fetchAgent(connection, agentId) {
+    const info = await connection.getAccountInfo(address.agent(agentId));
+    if (!info)
+        return null;
+    const a = coders.registry.accounts.decode("Agent", info.data);
+    return {
+        agentId: big(a.agent_id),
+        owner: a.owner,
+        uri: a.uri,
+        score: a.score ? fromRaw(a.score) : null,
+    };
+}
+/** Register the next agent (id = agent count + 1), owned by `owner`, who signs and pays. */
+export function registerInstruction(owner, nextAgentId, uri) {
+    return new TransactionInstruction({
+        programId: PROGRAM_IDS.registry,
+        data: coders.registry.instruction.encode("register", { uri }),
+        keys: metas(bondedRegistryIdl, "register", {
+            config: address.registryConfig(),
+            agent: address.agent(nextAgentId),
+            owner,
+            system_program: SYSTEM_PROGRAM,
+        }),
+    });
+}
+/**
+ * Post a score: the Ed25519 check of the attester's signature over `attestationMessage`, then
+ * the registry instruction, which looks for that check just before it.
+ */
+export function postScoreInstructions(attestation, attester) {
+    const verify = Ed25519Program.createInstructionWithPrivateKey({
+        privateKey: attester.secretKey,
+        message: attestationMessage(attestation),
+    });
+    const post = new TransactionInstruction({
+        programId: PROGRAM_IDS.registry,
+        data: coders.registry.instruction.encode("post_score", { attestation: toRaw(attestation) }),
+        keys: metas(bondedRegistryIdl, "post_score", {
+            config: address.registryConfig(),
+            agent: address.agent(attestation.agentId),
+            instructions: SYSVAR_INSTRUCTIONS_PUBKEY,
+        }),
+    });
+    return [verify, post];
+}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "@bondedhq/solana",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "TypeScript client for the Bonded Solana programs: IDLs, addresses, account decoding and instructions.",
+  "license": "MIT",
+  "keywords": [
+    "bonded",
+    "solana",
+    "anchor",
+    "mandate-vault"
+  ],
+  "homepage": "https://github.com/ddboy19912/bonded/tree/main/packages/solana#readme",
+  "bugs": {
+    "url": "https://github.com/ddboy19912/bonded/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ddboy19912/bonded.git",
+    "directory": "packages/solana"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@anchor-lang/core": "^1.2.0",
+    "@solana/web3.js": "^1.98.4",
+    "bn.js": "^5.2.3"
+  },
+  "devDependencies": {
+    "@types/bn.js": "^5.2.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "eslint src test",
+    "test": "vitest run",
+    "idls": "node scripts/gen-idls.mjs",
+    "idls:check": "node scripts/gen-idls.mjs --check"
+  }
 }