@misofm/sdk 0.15.10 → 0.15.11

package/src/read/wallet.ts

@@ -406,7 +406,7 @@ async function resolveVaultedReleaseCaps(
       const vault = vaultContract.Vault(networkContracts.release.ReleaseAdminCap).parse(
         object.content,
       );
-      const releaseId = vault.cap.value?.release_id;
+      const releaseId = vault.cap?.value?.release_id;
       if (releaseId) releasesByVault.set(object.objectId, releaseId);
     } catch {
       // Batch catalog discovery is best-effort per authority, matching the
@@ -615,20 +615,54 @@ export async function getWorkByCap(client: MisoClient, capId: string): Promise<W
 
 // ── Balance ──────────────────────────────────────────────────────────────────
 
+const decimalsByClient = new WeakMap<MisoClient, Map<string, Promise<number>>>();
+
+/** Resolve once per client/type. Failed lookups are evicted so a transient
+ * fullnode error cannot poison a long-lived API worker. */
+async function coinDecimals(client: MisoClient, coinType: string): Promise<number> {
+  let cache = decimalsByClient.get(client);
+  if (!cache) {
+    cache = new Map();
+    decimalsByClient.set(client, cache);
+  }
+  const key = normalizeStructTag(coinType);
+  const cached = cache.get(key);
+  if (cached) return cached;
+
+  const pending = client.protocol.core.getCoinMetadata({ coinType: key }).then(({ coinMetadata }) => {
+    const decimals = coinMetadata?.decimals;
+    if (!Number.isSafeInteger(decimals) || decimals! < 0 || decimals! > 18) {
+      throw new Error(`Coin metadata for ${key} has no supported decimal precision`);
+    }
+    return decimals!;
+  });
+  cache.set(key, pending);
+  try {
+    return await pending;
+  } catch (error) {
+    if (cache.get(key) === pending) cache.delete(key);
+    throw error;
+  }
+}
+
 /**
- * A wallet's spendable balance in one currency. `core.getBalance` totals coin
- * OBJECTS and the address balance, so funds that arrived either way are counted —
- * which matters because `balance::send_funds` (how the app transfers dollars)
- * credits the address balance, not a coin.
+ * A wallet's balance in one currency. Keep the aggregate and both Sui storage
+ * classes: callers using a `FundsWithdrawal` must never mistake coin-object
+ * value for immediately withdrawable address balance.
  */
 export async function getBalance(client: MisoClient, address: string, coinType?: string): Promise<Balance> {
   const type = coinType ?? client.config.money.usdCoinType;
-  const res = await client.protocol.core.getBalance({ owner: address, coinType: type });
+  const [res, decimals] = await Promise.all([
+    client.protocol.core.getBalance({ owner: address, coinType: type }),
+    coinDecimals(client, type),
+  ]);
   return {
     address: normalizeSuiAddress(address),
     coinType: type,
     balance: u64(res.balance.balance),
-    decimals: type === client.config.money.usdCoinType ? client.config.money.usdDecimals : 9,
+    coinBalance: u64(res.balance.coinBalance),
+    addressBalance: u64(res.balance.addressBalance),
+    decimals,
   };
 }
 

package/src/vault.ts

@@ -17,7 +17,7 @@ import type {
   TransactionArgument,
   TransactionObjectArgument,
 } from "@mysten/sui/transactions";
-import { normalizeStructTag } from "@mysten/sui/utils";
+import { deriveObjectID, normalizeStructTag } from "@mysten/sui/utils";
 import * as vault from "./contracts/vault/vault.ts";
 import * as compositionRoyaltyPool from "./contracts/composition_royalty_pool/composition_royalty_pool.ts";
 import * as recordingRoyaltyPool from "./contracts/recording_royalty_pool/recording_royalty_pool.ts";
@@ -145,6 +145,8 @@ export function invokeWithAdminCap(
 export interface CustodyNewAdminCapParams {
   /** The freshly-created raw protocol cap, consumed into the Vault. */
   readonly adminCap: TransactionObjectArgument;
+  /** Shared singleton from which canonical Vault IDs are derived. */
+  readonly vaultRegistry: ObjectInput;
   readonly capType: string;
   readonly vaultPackageId: string;
   /** Recipient of the only owner-held authority: VaultAdminCap. */
@@ -162,6 +164,7 @@ export type AdminCapCustody =
   | {
       readonly kind: "vault";
       readonly owner: string | TransactionArgument;
+      readonly vaultRegistry: ObjectInput;
       readonly capType: string;
       readonly vaultPackageId: string;
       readonly configure?: CustodyNewAdminCapParams["configure"];
@@ -179,6 +182,7 @@ export function disposeNewAdminCap(
   }
   custodyNewAdminCap(tx, {
     adminCap,
+    vaultRegistry: custody.vaultRegistry,
     capType: custody.capType,
     vaultPackageId: custody.vaultPackageId,
     owner: custody.owner,
@@ -186,23 +190,60 @@ export function disposeNewAdminCap(
   });
 }
 
-/** Destroy a vault only while deliberately disposing of its returned raw cap. */
-export function destroyVault(
+/** Withdraw the raw capability while leaving its canonical Vault shell intact. */
+export function withdrawVaultCapability(
   tx: Transaction,
   params: {
     readonly vault: ObjectInput;
     readonly vaultAdminCap: ObjectInput;
     readonly capType: string;
     readonly vaultPackageId: string;
-    readonly disposition: AdminCapCustody;
   },
-): void {
-  const cap = tx.add(vault.destroy({
+): TransactionObjectArgument {
+  return tx.add(vault.withdrawCap({
     package: params.vaultPackageId,
     typeArguments: [params.capType],
     arguments: [object(tx, params.vault), object(tx, params.vaultAdminCap)],
   }));
-  disposeNewAdminCap(tx, cap, params.disposition);
+}
+
+/** Restore the one exact capability permanently assigned to a Vault. */
+export function restoreVaultCapability(
+  tx: Transaction,
+  params: {
+    readonly vault: ObjectInput;
+    readonly vaultAdminCap: ObjectInput;
+    readonly adminCap: ObjectInput;
+    readonly capType: string;
+    readonly vaultPackageId: string;
+  },
+): void {
+  tx.add(vault.restoreCap({
+    package: params.vaultPackageId,
+    typeArguments: [params.capType],
+    arguments: [
+      object(tx, params.vault),
+      object(tx, params.vaultAdminCap),
+      object(tx, params.adminCap),
+    ],
+  }));
+}
+
+/** Transfer the key-only VaultAdminCap through the Vault module. */
+export function transferVaultAdminCap(
+  tx: Transaction,
+  params: {
+    readonly vaultAdminCap: ObjectInput;
+    readonly owner: string | TransactionArgument;
+    readonly capType: string;
+    readonly vaultPackageId: string;
+  },
+): void {
+  tx.add(vault.transferAdminCap({
+    package: params.vaultPackageId,
+    typeArguments: [params.capType],
+    arguments: [object(tx, params.vaultAdminCap), params.owner],
+  }));
 }
 
 /**
@@ -217,7 +258,7 @@ export function custodyNewAdminCap(
     vault._new({
       package: params.vaultPackageId,
       typeArguments: [params.capType],
-      arguments: [params.adminCap],
+      arguments: [object(tx, params.vaultRegistry), params.adminCap],
     }),
   );
   const vaultObject = requiredVaultResult(created, 0, "vault::_new");
@@ -230,7 +271,43 @@ export function custodyNewAdminCap(
       arguments: [vaultObject],
     }),
   );
-  tx.transferObjects([vaultAdminCap], params.owner);
+  transferVaultAdminCap(tx, {
+    vaultAdminCap,
+    owner: params.owner,
+    capType: params.capType,
+    vaultPackageId: params.vaultPackageId,
+  });
+}
+
+export interface VaultIdParams {
+  readonly vaultRegistryId: string;
+  readonly capId: string;
+  readonly capType: string;
+  readonly vaultPackageId: string;
+}
+
+/** Derive the canonical Vault ID without an RPC lookup. */
+export function deriveVaultId(params: VaultIdParams): string {
+  const keyType = normalizeStructTag(
+    `${params.vaultPackageId}::vault::VaultKey<${params.capType}>`,
+  );
+  return deriveObjectID(
+    params.vaultRegistryId,
+    keyType,
+    vault.VaultKey.serialize([params.capId]).toBytes(),
+  );
+}
+
+/** Derive the canonical VaultAdminCap ID from its Vault ID. */
+export function deriveVaultAdminCapId(
+  vaultId: string,
+  vaultPackageId: string,
+): string {
+  return deriveObjectID(
+    vaultId,
+    `${vaultPackageId}::vault::VaultAdminCapKey`,
+    vault.VaultAdminCapKey.serialize([false]).toBytes(),
+  );
 }
 
 export interface CompositionRoyaltyPoolPluginParams {