@heyanon-arp/sdk 0.0.8 → 0.0.10

package/dist/index.js

@@ -190,56 +190,6 @@ var SETTLEMENT_PURPOSES = [
   Purpose.SOLANA_RESOLVE_DISPUTE
 ];
 
-// src/cosignature/cosign.ts
-var COSIGN_ALLOWED = [Purpose.RECEIPT, Purpose.DISPUTE_RESPONSE];
-function signCosignature(input) {
-  const purpose = input.payload.purpose;
-  if (!COSIGN_ALLOWED.includes(purpose)) {
-    throw new Error(`signCosignature: purpose "${purpose}" is not allowed for co_signature`);
-  }
-  const digest = sha2.sha256(canonicalBytes(input.payload));
-  const sigBytes = sign2(digest, input.identitySecretKey);
-  const payload_hash = `sha256:${bytesToHex2(digest)}`;
-  const sig = `ed25519:${base.base64.encode(sigBytes)}`;
-  return {
-    agent_did: input.signerDid,
-    purpose,
-    payload_hash,
-    sig
-  };
-}
-function verifyCosignature(input) {
-  if (input.cosignature.purpose !== input.payload.purpose) {
-    return { ok: false, reason: "purpose_mismatch" };
-  }
-  const digest = sha2.sha256(canonicalBytes(input.payload));
-  const expectedHash = `sha256:${bytesToHex2(digest)}`;
-  if (expectedHash !== input.cosignature.payload_hash) {
-    return { ok: false, reason: "payload_hash_mismatch" };
-  }
-  const sigPrefix = "ed25519:";
-  if (!input.cosignature.sig.startsWith(sigPrefix)) {
-    return { ok: false, reason: "signature_malformed", detail: "sig missing ed25519: prefix" };
-  }
-  let sigBytes;
-  try {
-    sigBytes = base.base64.decode(input.cosignature.sig.slice(sigPrefix.length));
-  } catch {
-    return { ok: false, reason: "signature_malformed", detail: "sig base64 decode failed" };
-  }
-  if (sigBytes.length !== 64) {
-    return { ok: false, reason: "signature_malformed", detail: `expected 64-byte signature, got ${sigBytes.length}` };
-  }
-  return verify2(sigBytes, digest, input.signerIdentityPubkey) ? { ok: true } : { ok: false, reason: "signature_invalid" };
-}
-function bytesToHex2(b) {
-  let s = "";
-  for (let i = 0; i < b.length; i++) {
-    s += b[i].toString(16).padStart(2, "0");
-  }
-  return s;
-}
-
 // src/challenge/challenge.ts
 var CHALLENGE_PURPOSE_BYTES = new TextEncoder().encode(Purpose.CHALLENGE);
 function buildSigningInput(challengeBytes) {
@@ -333,7 +283,7 @@ function verifyKeyLinkAttestation(attestation, scryptKey) {
 function signedMessageHash(envelope) {
   const input = envelope.attachments === void 0 ? { protected: envelope.protected, body: envelope.body } : { protected: envelope.protected, body: envelope.body, attachments: envelope.attachments };
   const digest = sha2.sha256(canonicalBytes(input));
-  return `sha256:${bytesToHex3(digest)}`;
+  return `sha256:${bytesToHex2(digest)}`;
 }
 function serverEventHash(input) {
   const canonicalInput = {
@@ -344,7 +294,7 @@ function serverEventHash(input) {
     sender_signature: input.senderSignature
   };
   const digest = sha2.sha256(canonicalBytes(canonicalInput));
-  return `sha256:${bytesToHex3(digest)}`;
+  return `sha256:${bytesToHex2(digest)}`;
 }
 function findFirstChainDivergence(events) {
   for (let i = 0; i < events.length; i++) {
@@ -361,185 +311,13 @@ function findFirstChainDivergence(events) {
   }
   return null;
 }
-function bytesToHex3(b) {
+function bytesToHex2(b) {
   let s = "";
   for (let i = 0; i < b.length; i++) {
     s += b[i].toString(16).padStart(2, "0");
   }
   return s;
 }
-function deriveLockId(delegationId) {
-  const bytes16 = delegationIdToBytes16(delegationId);
-  const prefix = new TextEncoder().encode("arp-lock-v1");
-  const input = new Uint8Array(prefix.length + 16);
-  input.set(prefix, 0);
-  input.set(bytes16, prefix.length);
-  return sha2.sha256(input);
-}
-var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-function delegationIdToBytes16(delegationId) {
-  const uuid = delegationId.startsWith("del_") ? delegationId.slice(4) : delegationId;
-  if (!UUID_RE.test(uuid)) {
-    if (delegationId.startsWith("del_")) {
-      throw new Error(`Invalid delegation_id UUID (must be canonical lowercase): ${JSON.stringify(uuid)}`);
-    }
-    throw new Error(`Invalid delegation_id format: expected "del_<uuid>" or bare canonical-lowercase UUID, got ${JSON.stringify(delegationId)}`);
-  }
-  const hex = uuid.replace(/-/g, "");
-  const out = new Uint8Array(16);
-  for (let i = 0; i < 16; i++) {
-    out[i] = Number.parseInt(hex.substring(i * 2, i * 2 + 2), 16);
-  }
-  return out;
-}
-function bytes16ToDelegationId(bytes) {
-  if (bytes.length !== 16) {
-    throw new Error(`bytes16ToDelegationId: expected 16 bytes, got ${bytes.length}`);
-  }
-  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
-  return `del_${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
-}
-
-// src/settlement/settlement.ts
-var PURPOSE_RELEASE_STRING = "ARP-SOLANA-RELEASE-v1.5";
-var PURPOSE_PARTIAL_RELEASE_STRING = "ARP-SOLANA-PARTIAL-RELEASE-v1.5";
-var PURPOSE_REFUND_STRING = "ARP-SOLANA-REFUND-v1";
-var PURPOSE_RELEASE = new TextEncoder().encode(PURPOSE_RELEASE_STRING);
-var PURPOSE_PARTIAL_RELEASE = new TextEncoder().encode(PURPOSE_PARTIAL_RELEASE_STRING);
-var PURPOSE_REFUND = new TextEncoder().encode(PURPOSE_REFUND_STRING);
-var ZERO_PUBKEY = new Uint8Array(32);
-function buildReleaseDigest(input) {
-  requireLen(input.programId, 32, "programId");
-  requireLen(input.lockId, 32, "lockId");
-  requireLen(input.payerSettlementPubkey, 32, "payerSettlementPubkey");
-  requireLen(input.payeeSettlementPubkey, 32, "payeeSettlementPubkey");
-  requireLen(input.mint, 32, "mint");
-  requireLen(input.conditionHash, 32, "conditionHash");
-  requireLen(input.receiptEventHash, 32, "receiptEventHash");
-  requireLen(input.deliverableHash, 32, "deliverableHash");
-  const feeBps = input.feeBpsAtLock ?? 0;
-  requireFeeBps(feeBps);
-  const feeRecipient = input.feeRecipientAtLock ?? ZERO_PUBKEY;
-  requireLen(feeRecipient, 32, "feeRecipientAtLock");
-  const delegationBytes = delegationIdToBytes16(input.delegationId);
-  const buf = concatBytes(
-    PURPOSE_RELEASE,
-    new Uint8Array([input.clusterTag]),
-    input.programId,
-    input.lockId,
-    input.payerSettlementPubkey,
-    input.payeeSettlementPubkey,
-    input.mint,
-    u64LE(input.amount),
-    input.conditionHash,
-    delegationBytes,
-    input.receiptEventHash,
-    input.deliverableHash,
-    u64LE(input.expiresAt),
-    u16LE(feeBps),
-    feeRecipient
-  );
-  return sha2.sha256(buf);
-}
-function buildPartialReleaseDigest(input) {
-  requireLen(input.programId, 32, "programId");
-  requireLen(input.lockId, 32, "lockId");
-  requireLen(input.payerSettlementPubkey, 32, "payerSettlementPubkey");
-  requireLen(input.payeeSettlementPubkey, 32, "payeeSettlementPubkey");
-  requireLen(input.mint, 32, "mint");
-  requireLen(input.conditionHash, 32, "conditionHash");
-  requireLen(input.receiptEventHash, 32, "receiptEventHash");
-  requireLen(input.deliverableHash, 32, "deliverableHash");
-  const feeBps = input.feeBpsAtLock ?? 0;
-  requireFeeBps(feeBps);
-  const feeRecipient = input.feeRecipientAtLock ?? ZERO_PUBKEY;
-  requireLen(feeRecipient, 32, "feeRecipientAtLock");
-  const delegationBytes = delegationIdToBytes16(input.delegationId);
-  const buf = concatBytes(
-    PURPOSE_PARTIAL_RELEASE,
-    new Uint8Array([input.clusterTag]),
-    input.programId,
-    input.lockId,
-    input.payerSettlementPubkey,
-    input.payeeSettlementPubkey,
-    input.mint,
-    u64LE(input.amount),
-    u64LE(input.payeeAmount),
-    input.conditionHash,
-    delegationBytes,
-    input.receiptEventHash,
-    input.deliverableHash,
-    u64LE(input.expiresAt),
-    u16LE(feeBps),
-    feeRecipient
-  );
-  return sha2.sha256(buf);
-}
-var REFUND_REASON_BYTES = {
-  expired: 0,
-  dispute_resolution: 1,
-  payer_cancellation: 2,
-  both_parties_agreed: 3
-};
-function buildRefundDigest(input) {
-  requireLen(input.programId, 32, "programId");
-  requireLen(input.lockId, 32, "lockId");
-  requireLen(input.payerSettlementPubkey, 32, "payerSettlementPubkey");
-  requireLen(input.payeeSettlementPubkey, 32, "payeeSettlementPubkey");
-  requireLen(input.mint, 32, "mint");
-  const buf = concatBytes(
-    PURPOSE_REFUND,
-    new Uint8Array([input.clusterTag]),
-    input.programId,
-    input.lockId,
-    input.payerSettlementPubkey,
-    input.payeeSettlementPubkey,
-    input.mint,
-    u64LE(input.amount),
-    new Uint8Array([input.reasonByte]),
-    u64LE(input.expiresAt)
-  );
-  return sha2.sha256(buf);
-}
-function requireLen(bytes, expected, name) {
-  if (bytes.length !== expected) {
-    throw new Error(`settlement digest: ${name} must be ${expected} bytes, got ${bytes.length}`);
-  }
-}
-function requireFeeBps(bps) {
-  if (!Number.isInteger(bps) || bps < 0 || bps > 65535) {
-    throw new Error(`settlement digest: feeBpsAtLock must be a u16 (0..65535), got ${bps}`);
-  }
-}
-function concatBytes(...parts) {
-  let total = 0;
-  for (const p of parts) total += p.length;
-  const out = new Uint8Array(total);
-  let off = 0;
-  for (const p of parts) {
-    out.set(p, off);
-    off += p.length;
-  }
-  return out;
-}
-function u64LE(value) {
-  if (value < 0n || value > 0xffffffffffffffffn) {
-    throw new Error(`settlement digest: u64 value out of range: ${value}`);
-  }
-  const out = new Uint8Array(8);
-  let v = value;
-  for (let i = 0; i < 8; i++) {
-    out[i] = Number(v & 0xffn);
-    v >>= 8n;
-  }
-  return out;
-}
-function u16LE(value) {
-  const out = new Uint8Array(2);
-  out[0] = value & 255;
-  out[1] = value >> 8 & 255;
-  return out;
-}
 
 // src/settlement/token-program.ts
 var SPL_TOKEN_PROGRAM_ID_BASE58 = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
@@ -658,32 +436,65 @@ var SOLANA_CLUSTER_IDS = {
   "solana-devnet": "EtWTRABZaYq6iMfeYKouRu166VU2xqa1"
 };
 var SLIP44_SOLANA = 501;
+var MAINNET_MINTS = {
+  USDC: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+  USDT: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
+  ANON: "9McvH6w97oewLmPxqQEoHUAv3u5iYMyQ9AeZZhguYf1T"
+};
 var USDC_MINTS = {
-  "solana-mainnet": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+  "solana-mainnet": MAINNET_MINTS.USDC,
   "solana-devnet": "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU"
 };
-var WELL_KNOWN_ASSETS = {
-  "USDC:solana-mainnet": {
-    asset_id: `solana:${SOLANA_CLUSTER_IDS["solana-mainnet"]}/spl:${USDC_MINTS["solana-mainnet"]}`,
-    decimals: 6,
-    symbol: "USDC"
-  },
-  "USDC:solana-devnet": {
-    asset_id: `solana:${SOLANA_CLUSTER_IDS["solana-devnet"]}/spl:${USDC_MINTS["solana-devnet"]}`,
-    decimals: 6,
-    symbol: "USDC"
-  },
-  "SOL:solana-mainnet": {
-    asset_id: `solana:${SOLANA_CLUSTER_IDS["solana-mainnet"]}/slip44:${SLIP44_SOLANA}`,
-    decimals: 9,
-    symbol: "SOL"
-  },
-  "SOL:solana-devnet": {
-    asset_id: `solana:${SOLANA_CLUSTER_IDS["solana-devnet"]}/slip44:${SLIP44_SOLANA}`,
-    decimals: 9,
-    symbol: "SOL"
-  }
+var SOL_MAINNET = {
+  asset_id: `solana:${SOLANA_CLUSTER_IDS["solana-mainnet"]}/slip44:${SLIP44_SOLANA}`,
+  decimals: 9,
+  symbol: "SOL"
 };
+var SOL_DEVNET = {
+  asset_id: `solana:${SOLANA_CLUSTER_IDS["solana-devnet"]}/slip44:${SLIP44_SOLANA}`,
+  decimals: 9,
+  symbol: "SOL"
+};
+var ASSET_WHITELIST = {
+  "solana-mainnet": [
+    SOL_MAINNET,
+    {
+      asset_id: `solana:${SOLANA_CLUSTER_IDS["solana-mainnet"]}/spl:${MAINNET_MINTS.USDC}`,
+      decimals: 6,
+      symbol: "USDC"
+    },
+    {
+      asset_id: `solana:${SOLANA_CLUSTER_IDS["solana-mainnet"]}/spl:${MAINNET_MINTS.USDT}`,
+      decimals: 6,
+      symbol: "USDT"
+    },
+    {
+      asset_id: `solana:${SOLANA_CLUSTER_IDS["solana-mainnet"]}/spl:${MAINNET_MINTS.ANON}`,
+      decimals: 9,
+      symbol: "ANON"
+    }
+  ],
+  "solana-devnet": [SOL_DEVNET]
+};
+var WELL_KNOWN_ASSETS = Object.fromEntries(
+  Object.entries(ASSET_WHITELIST).flatMap(([cluster, assets]) => assets.map((asset) => [`${asset.symbol}:${cluster}`, asset]))
+);
+var WELL_KNOWN_ASSET_KEYS = Object.keys(WELL_KNOWN_ASSETS);
+function listWhitelistedAssets(cluster) {
+  return ASSET_WHITELIST[cluster].map((a) => ({ ...a }));
+}
+function findAssetByAssetId(assetId) {
+  for (const [cluster, assets] of Object.entries(ASSET_WHITELIST)) {
+    const asset = assets.find((a) => a.asset_id === assetId);
+    if (asset) return { asset: { ...asset }, cluster, key: `${asset.symbol}:${cluster}` };
+  }
+  return null;
+}
+function isWhitelistedAssetId(assetId, cluster) {
+  const hit = findAssetByAssetId(assetId);
+  if (!hit) return false;
+  return cluster === void 0 || hit.cluster === cluster;
+}
 var CAIP19_REGEX = /^[-a-z0-9]{3,8}:[-_a-zA-Z0-9]{1,32}\/[-a-z0-9]{3,8}:[-.%a-zA-Z0-9]{1,128}$/;
 function isAssetIdentifier(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
@@ -697,22 +508,54 @@ function resolveAsset(input) {
   const hit = WELL_KNOWN_ASSETS[input];
   if (hit) return { ...hit };
   if (CAIP19_REGEX.test(input)) {
+    const whitelisted = findAssetByAssetId(input);
+    if (whitelisted) return whitelisted.asset;
     return { asset_id: input, decimals: NaN };
   }
   return null;
 }
-var WELL_KNOWN_ASSET_KEYS = Object.keys(WELL_KNOWN_ASSETS);
+function deriveLockId(delegationId) {
+  const bytes16 = delegationIdToBytes16(delegationId);
+  const prefix = new TextEncoder().encode("arp-lock-v1");
+  const input = new Uint8Array(prefix.length + 16);
+  input.set(prefix, 0);
+  input.set(bytes16, prefix.length);
+  return sha2.sha256(input);
+}
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+function delegationIdToBytes16(delegationId) {
+  const uuid = delegationId.startsWith("del_") ? delegationId.slice(4) : delegationId;
+  if (!UUID_RE.test(uuid)) {
+    if (delegationId.startsWith("del_")) {
+      throw new Error(`Invalid delegation_id UUID (must be canonical lowercase): ${JSON.stringify(uuid)}`);
+    }
+    throw new Error(`Invalid delegation_id format: expected "del_<uuid>" or bare canonical-lowercase UUID, got ${JSON.stringify(delegationId)}`);
+  }
+  const hex = uuid.replace(/-/g, "");
+  const out = new Uint8Array(16);
+  for (let i = 0; i < 16; i++) {
+    out[i] = Number.parseInt(hex.substring(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
+function bytes16ToDelegationId(bytes) {
+  if (bytes.length !== 16) {
+    throw new Error(`bytes16ToDelegationId: expected 16 bytes, got ${bytes.length}`);
+  }
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `del_${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
 function deriveDelegationConditionHash(delegation) {
-  const required = ["delegationId", "scopeSummary", "pricingModel"];
+  const required = ["delegationId", "scopeSummary"];
   for (const field of required) {
     if (delegation[field] === void 0) {
       throw new Error(`deriveDelegationConditionHash: required field '${String(field)}' is missing from the delegation input`);
     }
   }
   const subset = {
+    v: "arp-condition-v2",
     delegationId: delegation.delegationId,
-    scopeSummary: delegation.scopeSummary,
-    pricingModel: delegation.pricingModel
+    scopeSummary: delegation.scopeSummary
   };
   if (delegation.currency !== void 0) subset.currency = delegation.currency;
   const bytes = canonicalBytes(subset);
@@ -741,15 +584,16 @@ function parseCaip19SolanaAssetId(assetId) {
   throw new Error(`Unsupported CAIP-19 namespace: ${JSON.stringify(namespaceRaw)} (only 'spl' and 'slip44' are supported on Solana)`);
 }
 var CREATE_LOCK_DISCRIMINATOR = new Uint8Array([171, 216, 92, 167, 165, 8, 153, 90]);
-function buildCreateLockIxData(args) {
+var CREATE_LOCK_NATIVE_DISCRIMINATOR = new Uint8Array([234, 19, 218, 36, 23, 74, 218, 108]);
+function buildCreateLockIxData(args, opts = {}) {
   if (args.lockId.length !== 32) throw new Error("create_lock: lockId must be 32 bytes");
   if (args.conditionHash.length !== 32) throw new Error("create_lock: conditionHash must be 32 bytes");
   requireU64(args.amount, "amount");
-  requireU64(args.expiry, "expiry");
-  const total = 8 + 32 + 8 + 32 + 8;
+  const disc = opts.native ? CREATE_LOCK_NATIVE_DISCRIMINATOR : CREATE_LOCK_DISCRIMINATOR;
+  const total = 8 + 32 + 8 + 32;
   const out = new Uint8Array(total);
   let off = 0;
-  out.set(CREATE_LOCK_DISCRIMINATOR, off);
+  out.set(disc, off);
   off += 8;
   out.set(args.lockId, off);
   off += 32;
@@ -757,8 +601,6 @@ function buildCreateLockIxData(args) {
   off += 8;
   out.set(args.conditionHash, off);
   off += 32;
-  writeU64LE(out, off, args.expiry);
-  off += 8;
   if (off !== total) throw new Error(`create_lock ix data layout drift: ${off} != ${total}`);
   return out;
 }
@@ -778,17 +620,122 @@ function computeCreateLockDiscriminator() {
   const h = sha2.sha256(new TextEncoder().encode("global:create_lock"));
   return h.slice(0, 8);
 }
+var ESCROW_PDA_SEEDS = {
+  LOCK: "lock",
+  ESCROW: "escrow",
+  CONFIG: "config",
+  STAKE_VAULT: "stake_vault",
+  COLLATERAL: "collateral",
+  DISPUTE_RESOLUTION: "dispute_resolution",
+  OPERATOR_AUTH: "operator_auth",
+  EVENT_AUTHORITY: "__event_authority"
+};
+var NO_ARG_LIFECYCLE_INSTRUCTIONS = [
+  "accept_lock",
+  "submit_work",
+  "claim_work_payment",
+  "claim_work_payment_native",
+  "cancel_lock",
+  "cancel_lock_native",
+  "claim_expired_work",
+  "claim_expired_work_native",
+  "open_dispute",
+  "close_dispute",
+  "close_dispute_native"
+];
+function instructionDiscriminator(ixName) {
+  return sha2.sha256(new TextEncoder().encode(`global:${ixName}`)).slice(0, 8);
+}
+function buildLifecycleIxData(ixName) {
+  if (!NO_ARG_LIFECYCLE_INSTRUCTIONS.includes(ixName)) {
+    throw new Error(`buildLifecycleIxData: '${ixName}' is not a no-arg lifecycle instruction`);
+  }
+  return instructionDiscriminator(ixName);
+}
+function buildResolveDisputeIxData(args, opts = {}) {
+  if (args.reasonHash.length !== 32) throw new Error("resolve_dispute: reasonHash must be 32 bytes");
+  if (args.disputeId.length !== 16) throw new Error("resolve_dispute: disputeId must be 16 bytes");
+  const disc = instructionDiscriminator(opts.native ? "resolve_dispute_native" : "resolve_dispute");
+  const total = 8 + 1 + 32 + 16;
+  const out = new Uint8Array(total);
+  out.set(disc, 0);
+  out[8] = args.isPayerWinner ? 1 : 0;
+  out.set(args.reasonHash, 9);
+  out.set(args.disputeId, 41);
+  return out;
+}
+var LOCK_ACCOUNT_SIZE = 269;
+var LOCK_ACCOUNT_DISCRIMINATOR = new Uint8Array([8, 255, 36, 202, 210, 22, 57, 137]);
+var LOCK_STATE_NAMES = ["created", "canceled", "in_progress", "submitted", "paid", "revoked", "disputing", "dispute_resolved", "dispute_closed"];
+var LOCK_TERMINAL_STATES = ["canceled", "paid", "revoked", "dispute_resolved", "dispute_closed"];
+var NATIVE_SOL_MINT_BASE58 = "11111111111111111111111111111111";
+function decodeLockAccount(data) {
+  if (data.length !== LOCK_ACCOUNT_SIZE) {
+    throw new Error(`decodeLockAccount: expected ${LOCK_ACCOUNT_SIZE} bytes, got ${data.length}`);
+  }
+  for (let i = 0; i < 8; i++) {
+    if (data[i] !== LOCK_ACCOUNT_DISCRIMINATOR[i]) {
+      throw new Error("decodeLockAccount: account discriminator is not Lock");
+    }
+  }
+  const stateByte = data[185];
+  const state = LOCK_STATE_NAMES[stateByte];
+  if (state === void 0) {
+    throw new Error(`decodeLockAccount: unknown LockState discriminant ${stateByte}`);
+  }
+  const mint = base.base58.encode(data.slice(113, 145));
+  return {
+    lockId: toHex(data.subarray(8, 40)),
+    version: data[40],
+    payer: base.base58.encode(data.slice(41, 73)),
+    payee: base.base58.encode(data.slice(73, 105)),
+    amount: readU64LE(data, 105),
+    mint,
+    isNative: mint === NATIVE_SOL_MINT_BASE58,
+    conditionHash: toHex(data.subarray(145, 177)),
+    expiry: readU64LE(data, 177),
+    state,
+    stateByte,
+    feeBpsAtLock: data[186] | data[187] << 8,
+    feeRecipientAtLock: base.base58.encode(data.slice(188, 220)),
+    workerStakeAtLock: readU64LE(data, 220),
+    operatorDisputeFeeAtLock: readU64LE(data, 228),
+    treasuryAtLock: base.base58.encode(data.slice(236, 268)),
+    bump: data[268]
+  };
+}
+function computeLockAccountDiscriminator() {
+  return sha2.sha256(new TextEncoder().encode("account:Lock")).slice(0, 8);
+}
+function toHex(bytes) {
+  let hex = "";
+  for (const b of bytes) hex += b.toString(16).padStart(2, "0");
+  return hex;
+}
+function readU64LE(buf, off) {
+  let v = 0n;
+  for (let i = 0; i < 8; i++) {
+    v |= BigInt(buf[off + i]) << BigInt(8 * i);
+  }
+  return v;
+}
 
+exports.ASSET_WHITELIST = ASSET_WHITELIST;
 exports.CAIP19_REGEX = CAIP19_REGEX;
 exports.COSIGNATURE_PURPOSES = COSIGNATURE_PURPOSES;
 exports.CREATE_LOCK_DISCRIMINATOR = CREATE_LOCK_DISCRIMINATOR;
+exports.CREATE_LOCK_NATIVE_DISCRIMINATOR = CREATE_LOCK_NATIVE_DISCRIMINATOR;
 exports.DECLINE_REASONS = DECLINE_REASONS;
+exports.ESCROW_PDA_SEEDS = ESCROW_PDA_SEEDS;
+exports.LOCK_ACCOUNT_DISCRIMINATOR = LOCK_ACCOUNT_DISCRIMINATOR;
+exports.LOCK_ACCOUNT_SIZE = LOCK_ACCOUNT_SIZE;
+exports.LOCK_STATE_NAMES = LOCK_STATE_NAMES;
+exports.LOCK_TERMINAL_STATES = LOCK_TERMINAL_STATES;
+exports.MAINNET_MINTS = MAINNET_MINTS;
+exports.NATIVE_SOL_MINT_BASE58 = NATIVE_SOL_MINT_BASE58;
+exports.NO_ARG_LIFECYCLE_INSTRUCTIONS = NO_ARG_LIFECYCLE_INSTRUCTIONS;
 exports.PROTECTED_PURPOSES = PROTECTED_PURPOSES;
-exports.PURPOSE_PARTIAL_RELEASE_STRING = PURPOSE_PARTIAL_RELEASE_STRING;
-exports.PURPOSE_REFUND_STRING = PURPOSE_REFUND_STRING;
-exports.PURPOSE_RELEASE_STRING = PURPOSE_RELEASE_STRING;
 exports.Purpose = Purpose;
-exports.REFUND_REASON_BYTES = REFUND_REASON_BYTES;
 exports.SCRYPT_PARAMS = SCRYPT_PARAMS;
 exports.SETTLEMENT_PURPOSES = SETTLEMENT_PURPOSES;
 exports.SLIP44_SOLANA = SLIP44_SOLANA;
@@ -800,14 +747,15 @@ exports.WELL_KNOWN_ASSET_KEYS = WELL_KNOWN_ASSET_KEYS;
 exports.base58btcDecode = base58btcDecode;
 exports.base58btcEncode = base58btcEncode;
 exports.buildCreateLockIxData = buildCreateLockIxData;
-exports.buildPartialReleaseDigest = buildPartialReleaseDigest;
-exports.buildRefundDigest = buildRefundDigest;
-exports.buildReleaseDigest = buildReleaseDigest;
+exports.buildLifecycleIxData = buildLifecycleIxData;
+exports.buildResolveDisputeIxData = buildResolveDisputeIxData;
 exports.bytes16ToDelegationId = bytes16ToDelegationId;
 exports.canonicalBytes = canonicalBytes;
 exports.canonicalJson = canonicalJson;
 exports.canonicalSha256Hex = canonicalSha256Hex;
 exports.computeCreateLockDiscriminator = computeCreateLockDiscriminator;
+exports.computeLockAccountDiscriminator = computeLockAccountDiscriminator;
+exports.decodeLockAccount = decodeLockAccount;
 exports.delegationIdToBytes16 = delegationIdToBytes16;
 exports.deriveDelegationConditionHash = deriveDelegationConditionHash;
 exports.deriveLockId = deriveLockId;
@@ -815,13 +763,17 @@ exports.deriveScryptKey = deriveScryptKey;
 exports.detectTokenProgramFromOwner = detectTokenProgramFromOwner;
 exports.detectTokenProgramFromOwnerBytes = detectTokenProgramFromOwnerBytes;
 exports.expiresAt = expiresAt;
+exports.findAssetByAssetId = findAssetByAssetId;
 exports.findFirstChainDivergence = findFirstChainDivergence;
 exports.formatDid = formatDid;
 exports.generateKeyPair = generateKeyPair;
 exports.getPublicKey = getPublicKey2;
+exports.instructionDiscriminator = instructionDiscriminator;
 exports.isAssetIdentifier = isAssetIdentifier;
 exports.isDeclineReason = isDeclineReason;
 exports.isValidDid = isValidDid;
+exports.isWhitelistedAssetId = isWhitelistedAssetId;
+exports.listWhitelistedAssets = listWhitelistedAssets;
 exports.parseCaip19SolanaAssetId = parseCaip19SolanaAssetId;
 exports.parseDid = parseDid;
 exports.pollUntil = pollUntil;
@@ -833,13 +785,11 @@ exports.senderNonce = senderNonce;
 exports.serverEventHash = serverEventHash;
 exports.sign = sign2;
 exports.signChallenge = signChallenge;
-exports.signCosignature = signCosignature;
 exports.signEnvelope = signEnvelope;
 exports.signKeyLinkAttestation = signKeyLinkAttestation;
 exports.signedMessageHash = signedMessageHash;
 exports.uuidV4 = uuidV4;
 exports.verify = verify2;
 exports.verifyChallenge = verifyChallenge;
-exports.verifyCosignature = verifyCosignature;
 exports.verifyEnvelope = verifyEnvelope;
 exports.verifyKeyLinkAttestation = verifyKeyLinkAttestation;