@trinaryex/sdk 3.9.0 → 4.0.0

package/dist/armature/create.d.ts

@@ -0,0 +1,27 @@
+import { Transaction } from '@mysten/sui/transactions';
+import { ProposalConfigInput } from './transactions';
+export interface TypeInitInput {
+    moveType: string;
+    displayKey: string;
+    config: ProposalConfigInput;
+}
+export interface CreateTribeParams {
+    armature: string;
+    armatureProposals: string;
+    tribeBoard: string[];
+    officers: string[];
+    members: string[];
+    tribeName: string;
+    officerName: string;
+    memberName: string;
+    tribeMetadataUri: string;
+    officerMetadataUri: string;
+    memberMetadataUri: string;
+    officerFreezeAdmin: string;
+    memberFreezeAdmin: string;
+    tribeOverrides?: TypeInitInput[];
+    officerOverrides?: TypeInitInput[];
+    memberOverrides?: TypeInitInput[];
+}
+export declare function createTribeTx(p: CreateTribeParams): Transaction;
+export declare function tradingTypeInits(armatureTrading: string, quoteType: string): TypeInitInput[];

package/dist/armature/currency.d.ts

@@ -0,0 +1,64 @@
+import { Transaction } from '@mysten/sui/transactions';
+import { ArmaturePkgs } from './actions';
+import { OuProposalAction } from './harness';
+import { ProposalConfigInput } from './transactions';
+export declare function treasuryCapType(coinType: string): string;
+export interface CurrencyTypeEntry {
+    typeKey: string;
+    moveType: string;
+    config: ProposalConfigInput;
+}
+export declare function currencyTypeEntries(armatureProposals: string, coinType: string, base: ProposalConfigInput): CurrencyTypeEntry[];
+export declare function adoptCurrencyAction(pkgs: ArmaturePkgs, params: {
+    coinType: string;
+    treasuryCapId: string;
+    capabilityVaultId: string;
+}): OuProposalAction;
+export declare function mintCoinAction(pkgs: ArmaturePkgs, params: {
+    coinType: string;
+    treasuryCapId: string;
+    amount: bigint;
+    recipient?: string;
+    capabilityVaultId: string;
+    treasuryVaultId: string;
+}): OuProposalAction;
+export declare function mintAllowanceAction(pkgs: ArmaturePkgs, params: {
+    coinType: string;
+    treasuryCapId: string;
+    amount: bigint;
+    recipient?: string;
+    capabilityVaultId: string;
+    treasuryVaultId: string;
+}): OuProposalAction;
+export declare function burnCoinAction(pkgs: ArmaturePkgs, params: {
+    coinType: string;
+    treasuryCapId: string;
+    amount: bigint;
+    capabilityVaultId: string;
+    treasuryVaultId: string;
+}): OuProposalAction;
+export declare function returnCurrencyCapAction(pkgs: ArmaturePkgs, params: {
+    coinType: string;
+    treasuryCapId: string;
+    recipient: string;
+    capabilityVaultId: string;
+}): OuProposalAction;
+export declare function configureMintAllowanceAction(pkgs: ArmaturePkgs, params: {
+    coinType: string;
+    addMinters?: string[];
+    removeMinters?: string[];
+    maxPerCall?: bigint;
+    enabled?: boolean;
+}): OuProposalAction;
+export declare function mintAllowanceBypassTx(args: {
+    armatureProposals: string;
+    coinType: string;
+    ouId: string;
+    capabilityVaultId: string;
+    treasuryVaultId: string;
+    emergencyFreezeId: string;
+    bypassCapId: string;
+    treasuryCapId: string;
+    amount: bigint;
+    recipient?: string;
+}): Transaction;

package/dist/armature/executors.d.ts

@@ -0,0 +1,44 @@
+import { Transaction } from '@mysten/sui/transactions';
+import { ArmaturePkgs } from './actions';
+import { OuProposalAction } from './harness';
+import { CompositeStep } from './plan';
+import { OrgNode } from './types';
+import { UpgradeBuild } from './upgrade';
+type TxArg = ReturnType<Transaction['moveCall']>;
+export interface PassedExecutionContext {
+    pkgs: ArmaturePkgs;
+    unit: {
+        daoId: string;
+        charterId?: string | null;
+        treasuryId?: string | null;
+        capabilityVaultId?: string | null;
+        emergencyFreezeId?: string | null;
+    };
+    nodes?: readonly OrgNode[];
+    payload?: Record<string, unknown>;
+    typeForDisplayKey?: (displayKey: string) => string | undefined;
+    capTypeOf?: (capId: string) => string | undefined;
+    freezeAdminCapId?: string;
+    treasuryCapId?: string;
+    upgrade?: UpgradeBuild;
+}
+export type PassedExecutor = {
+    execute: (tx: Transaction, ticket: TxArg, ownDaoId: string) => void;
+} | {
+    missing: string;
+};
+export declare function splitMoveType(type: string): {
+    pkg: string;
+    path: string;
+    args: string[];
+};
+export declare function executorForPayload(payloadMoveType: string, c: PassedExecutionContext): PassedExecutor;
+export declare function defaultSlotType(pkgs: ArmaturePkgs, displayKey: string): string | null;
+export declare function passedProposalAction(pkgs: ArmaturePkgs, args: {
+    typeKey: string;
+    payloadType?: string;
+    payload?: Record<string, unknown>;
+    charterId?: string;
+} & Partial<Omit<PassedExecutionContext, 'pkgs' | 'payload'>>): OuProposalAction | null;
+export declare function compositeStepExecutor(pkgs: ArmaturePkgs, typeKey: string, stepMoveType?: string, ctx?: Partial<Omit<PassedExecutionContext, 'pkgs'>>): CompositeStep | null;
+export {};

package/dist/armature/governance.d.ts

@@ -0,0 +1,194 @@
+import { ClientWithCoreApi } from '@mysten/sui/client';
+export interface ProposalConfig {
+    quorum: number;
+    approvalThreshold: number;
+    proposeThreshold: number;
+    expiryMs: number;
+    executionDelayMs: number;
+    cooldownMs: number;
+    composableAllowed: boolean;
+    permissions?: number;
+    borrowScope?: string[];
+}
+export interface TypeSlot {
+    typeName: string;
+    displayKey: string;
+    config: ProposalConfig;
+    lastExecutedMs: number | null;
+}
+export interface OuState {
+    status: 'active' | 'migrating';
+    successorOuId: string | null;
+    executionPaused: boolean;
+    controllerPaused: boolean;
+    controllerCapId: string | null;
+    memberCount: number;
+    rosterVersion: number;
+    membersTableId: string;
+    treasuryId: string;
+    capabilityVaultId: string;
+    charterId: string;
+    emergencyFreezeId: string;
+    encryptEpoch: number;
+    entries: string[];
+}
+export interface FreezeState {
+    frozenTypes: Map<string, number>;
+    exemptTypes: string[];
+    maxFreezeDurationMs: number;
+}
+export interface DaoGovernance {
+    enabledTypes: Set<string>;
+    configs: Map<string, ProposalConfig>;
+    typeBindings: Map<string, string>;
+    slots?: TypeSlot[];
+    state?: OuState;
+    freeze?: FreezeState;
+}
+export declare const PERMISSIONS: {
+    readonly BOARD_ADD: number;
+    readonly BOARD_REMOVE: number;
+    readonly BOARD_SET: number;
+    readonly TYPE_ADMIN: number;
+    readonly PAUSE: number;
+    readonly MIGRATE: number;
+    readonly METADATA: number;
+    readonly TREASURY_WITHDRAW: number;
+    readonly VAULT_STORE: number;
+    readonly VAULT_BORROW: number;
+    readonly VAULT_EXTRACT: number;
+    readonly FREEZE: number;
+};
+export declare const HIGH_IMPACT_PERMISSIONS: number;
+export declare const BYPASS_FORBIDDEN_PERMISSIONS: number;
+export declare function permissionFloor(bits: number): number;
+export declare function hasPermissions(mask: number, bits: number): boolean;
+export declare function normalizeMoveType(type: string): string;
+export declare function remapPackages(type: string, aliases: ReadonlyMap<string, string> | undefined): string;
+export declare function slotForType(gov: DaoGovernance | undefined, moveType: string, opts?: {
+    displayKey?: string;
+    aliases?: ReadonlyMap<string, string>;
+}): TypeSlot | undefined;
+export declare function packageAliases(pairs: [current: string | undefined, original: string | undefined][]): Map<string, string>;
+export declare const ProposalConfigBcs: import('@mysten/bcs').BcsStruct<{
+    quorum: import('@mysten/bcs').BcsType<number, number, "u16">;
+    approval_threshold: import('@mysten/bcs').BcsType<number, number, "u16">;
+    propose_threshold: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+    expiry_ms: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+    execution_delay_ms: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+    cooldown_ms: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+    composable_allowed: import('@mysten/bcs').BcsType<boolean, boolean, "bool">;
+    permissions: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+    borrow_scope: import('@mysten/bcs').BcsType<{
+        name: string;
+    }[], Iterable<{
+        name: string;
+    }> & {
+        length: number;
+    }, string>;
+}, string>;
+export declare const TypeSlotFieldBcs: import('@mysten/bcs').BcsStruct<{
+    id: import('@mysten/bcs').BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    name: import('@mysten/bcs').BcsStruct<{
+        name: import('@mysten/bcs').BcsStruct<{
+            name: import('@mysten/bcs').BcsType<string, string, "string">;
+        }, string>;
+    }, string>;
+    value: import('@mysten/bcs').BcsStruct<{
+        display_key: import('@mysten/bcs').BcsType<string, string, "string">;
+        config: import('@mysten/bcs').BcsStruct<{
+            quorum: import('@mysten/bcs').BcsType<number, number, "u16">;
+            approval_threshold: import('@mysten/bcs').BcsType<number, number, "u16">;
+            propose_threshold: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+            expiry_ms: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+            execution_delay_ms: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+            cooldown_ms: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+            composable_allowed: import('@mysten/bcs').BcsType<boolean, boolean, "bool">;
+            permissions: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+            borrow_scope: import('@mysten/bcs').BcsType<{
+                name: string;
+            }[], Iterable<{
+                name: string;
+            }> & {
+                length: number;
+            }, string>;
+        }, string>;
+        last_executed_ms: import('@mysten/bcs').BcsType<string | null, string | number | bigint | null | undefined, "Option<u64>">;
+    }, string>;
+}, string>;
+export declare const OuBcs: import('@mysten/bcs').BcsStruct<{
+    id: import('@mysten/bcs').BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    status: import('@mysten/bcs').BcsEnum<{
+        Active: null;
+        Migrating: import('@mysten/bcs').BcsStruct<{
+            successor_ou_id: import('@mysten/bcs').BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        }, string>;
+    }, "OUStatus">;
+    governance: import('@mysten/bcs').BcsStruct<{
+        members: import('@mysten/bcs').BcsStruct<{
+            id: import('@mysten/bcs').BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+            size: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+        }, string>;
+        member_count: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+        roster_version: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+    }, string>;
+    treasury_id: import('@mysten/bcs').BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    capability_vault_id: import('@mysten/bcs').BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    charter_id: import('@mysten/bcs').BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    emergency_freeze_id: import('@mysten/bcs').BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    execution_paused: import('@mysten/bcs').BcsType<boolean, boolean, "bool">;
+    controller_cap_id: import('@mysten/bcs').BcsType<string | null, string | Uint8Array<ArrayBufferLike> | null | undefined, "Option<bytes[32]>">;
+    controller_paused: import('@mysten/bcs').BcsType<boolean, boolean, "bool">;
+    encrypt_epoch: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+    entries: import('@mysten/bcs').BcsType<string[], Iterable<string | Uint8Array<ArrayBufferLike>> & {
+        length: number;
+    }, string>;
+}, string>;
+export declare const EmergencyFreezeBcs: import('@mysten/bcs').BcsStruct<{
+    id: import('@mysten/bcs').BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    ou_id: import('@mysten/bcs').BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    frozen_types: import('@mysten/bcs').BcsStruct<{
+        contents: import('@mysten/bcs').BcsType<{
+            key: {
+                name: string;
+            };
+            value: string;
+        }[], Iterable<{
+            key: {
+                name: string;
+            };
+            value: string | number | bigint;
+        }> & {
+            length: number;
+        }, string>;
+    }, string>;
+    max_freeze_duration_ms: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+    freeze_exempt_types: import('@mysten/bcs').BcsStruct<{
+        contents: import('@mysten/bcs').BcsType<{
+            name: string;
+        }[], Iterable<{
+            name: string;
+        }> & {
+            length: number;
+        }, string>;
+    }, string>;
+}, string>;
+export declare function configFromBcs(c: ReturnType<typeof ProposalConfigBcs.parse>): ProposalConfig;
+export declare function parseTypeSlot(content: Uint8Array): TypeSlot;
+export declare function parseOuState(content: Uint8Array): OuState;
+export declare function parseFreezeState(content: Uint8Array): FreezeState;
+export declare function governanceFromSlots(slots: TypeSlot[], extra?: {
+    state?: OuState;
+    freeze?: FreezeState;
+}): DaoGovernance;
+export declare function singleVoteExecutable(boardSize: number, config: ProposalConfig): boolean;
+export declare function cooldownEndsAt(slot: {
+    config: ProposalConfig;
+    lastExecutedMs: number | null;
+}): number | null;
+export declare function fetchTypeSlots(suiClient: ClientWithCoreApi, ouId: string): Promise<TypeSlot[]>;
+export declare function fetchOuState(suiClient: ClientWithCoreApi, ouId: string): Promise<OuState>;
+export declare function fetchFreezeState(suiClient: ClientWithCoreApi, emergencyFreezeId: string): Promise<FreezeState>;
+export declare function fetchDaoGovernance(suiClient: ClientWithCoreApi, daoId: string): Promise<DaoGovernance>;
+export declare function fetchProposalConfig(suiClient: ClientWithCoreApi, daoId: string, typeKey: string): Promise<ProposalConfig | null>;
+export declare function fetchIsBoardMember(suiClient: ClientWithCoreApi, membersTableId: string, address: string): Promise<boolean>;

package/dist/armature/harness.d.ts

@@ -0,0 +1,96 @@
+import { Transaction } from '@mysten/sui/transactions';
+import { DaoGovernance, OuState, ProposalConfig } from './governance';
+import { OuExecContext } from './types';
+type TxArg = ReturnType<Transaction['moveCall']>;
+export type Strategy = 'own-execute' | 'control-execute' | 'own-propose' | 'control-propose';
+export type BlockCode = 'not-member' | 'needs-slow-tier' | 'not-permitted' | 'missing-permissions' | 'paused' | 'frozen' | 'cooldown';
+export interface OuCapabilities {
+    ownConfig: ProposalConfig | null;
+    controlConfig: ProposalConfig | null;
+    ownLastExecutedMs?: number | null;
+    controlLastExecutedMs?: number | null;
+    ownState?: OuState;
+    parentState?: OuState;
+    ownFrozenUntil?: number | null;
+    controlFrozenUntil?: number | null;
+    callerOnOwnBoard?: boolean;
+    callerOnParentBoard?: boolean;
+    nowMs?: number;
+}
+export interface OuOwnAdapter {
+    typeKey: string;
+    payloadMoveType: string;
+    buildPayload: (tx: Transaction) => TxArg;
+    buildExecute: (tx: Transaction, ticket: TxArg, ownDaoId: string) => void;
+    requiredPermissions?: number;
+    requiredBorrowScope?: string[];
+}
+export interface OuControlAdapter {
+    typeKey: string;
+    payloadMoveType: string;
+    buildPayload: (tx: Transaction, controlCapId: string) => TxArg;
+    buildExecute: (tx: Transaction, ticket: TxArg, capVaultId: string, childDaoId: string) => void;
+    requiredPermissions?: number;
+    requiredBorrowScope?: string[];
+}
+export interface OuProposalAction {
+    kind: string;
+    own?: OuOwnAdapter;
+    control?: OuControlAdapter;
+    fallbackPolicy?: 'fall-back-to-proposal' | 'single-vote-only';
+    grantsPermissions?: boolean;
+}
+export interface ExecutionPlan {
+    blocked: false;
+    strategy: Strategy;
+    immediate: boolean;
+    voterBoardSize: number;
+    readonly?: boolean;
+    reason: string;
+    buildTx: () => Transaction;
+}
+export interface BlockedPlan {
+    blocked: true;
+    code: BlockCode;
+    reason: string;
+}
+export type ResolvedPlan = ExecutionPlan | BlockedPlan;
+export type StrategyDecision = {
+    blocked: false;
+    strategy: Strategy;
+    immediate: boolean;
+    voterBoardSize: number;
+    readonly?: boolean;
+    reason: string;
+} | {
+    blocked: true;
+    code: BlockCode;
+    reason: string;
+};
+export type PathTier = 'immediate' | 'slow';
+export interface PathCandidate {
+    strategy: Strategy;
+    tier: PathTier;
+    voterBoardSize: number;
+    viable: boolean;
+    applicable: boolean;
+    detail: string;
+    blocker?: BlockCode;
+}
+export declare function evaluatePaths(action: OuProposalAction, ctx: OuExecContext, caps: OuCapabilities, caller: string | undefined): PathCandidate[];
+export declare function selectStrategy(action: OuProposalAction, ctx: OuExecContext, caps: OuCapabilities, caller: string | undefined): StrategyDecision;
+export declare function capabilitiesFor(action: OuProposalAction, own: DaoGovernance | undefined, parent: DaoGovernance | undefined, opts?: {
+    aliases?: ReadonlyMap<string, string>;
+    nowMs?: number;
+    callerOnOwnBoard?: boolean;
+    callerOnParentBoard?: boolean;
+}): OuCapabilities;
+export declare const MAX_COMPOSITE_STEPS = 16;
+export declare const COMPOSITE_TYPE_KEY = "Composite";
+export type CompositeIneligibility = 'single-action' | 'too-many-steps' | 'composite-disabled' | 'step-not-composable' | 'grant-in-composite';
+export interface CompositeEligibility {
+    eligible: boolean;
+    reason?: CompositeIneligibility;
+}
+export declare function canComposite(actions: OuProposalAction[], gov: DaoGovernance | undefined, aliases?: ReadonlyMap<string, string>): CompositeEligibility;
+export {};

package/dist/armature/lifecycle.d.ts

@@ -0,0 +1,84 @@
+import { Transaction } from '@mysten/sui/transactions';
+import { ArmaturePkgs } from './actions';
+import { OuProposalAction } from './harness';
+import { ProposalConfigInput } from './transactions';
+type TxArg = ReturnType<Transaction['moveCall']>;
+export declare function pauseSubOuAction(pkgs: ArmaturePkgs): OuProposalAction;
+export declare function unpauseSubOuAction(pkgs: ArmaturePkgs): OuProposalAction;
+export declare function transferCapToSubOuAction(pkgs: ArmaturePkgs, params: {
+    subOuId: string;
+    subOuCapabilityVaultId: string;
+    capId: string;
+    capType: string;
+}): OuProposalAction;
+export declare function reclaimCapFromSubOuAction(pkgs: ArmaturePkgs, params: {
+    subOuId: string;
+    subOuCapabilityVaultId: string;
+    capId: string;
+    capType: string;
+}): OuProposalAction;
+export interface SpinOutConfigs {
+    spawnOu: ProposalConfigInput;
+    spinOutSubOu: ProposalConfigInput;
+    createSubOu: ProposalConfigInput;
+}
+export declare const HIERARCHY_TYPE_CONFIG: ProposalConfigInput;
+export declare function spinOutSubOuAction(pkgs: ArmaturePkgs, params: {
+    subOuId: string;
+    subOuCapabilityVaultId: string;
+    freezeAdminCapId: string;
+    configs?: Partial<SpinOutConfigs>;
+}): OuProposalAction;
+export declare function createSubOuAction(pkgs: ArmaturePkgs, params: {
+    name: string;
+    board: string[];
+    metadataUri: string;
+    capabilityVaultId: string;
+}): OuProposalAction;
+export declare function spawnOuAction(pkgs: ArmaturePkgs, params: {
+    board: string[];
+    name: string;
+    metadataUri: string;
+}): OuProposalAction;
+export declare function transferAssetsAction(pkgs: ArmaturePkgs, params: {
+    targetOuId: string;
+    targetTreasuryId: string;
+    targetCapabilityVaultId: string;
+    coinTypes: string[];
+    caps: {
+        id: string;
+        type: string;
+    }[];
+    treasuryVaultId: string;
+    capabilityVaultId: string;
+}): OuProposalAction;
+export declare function appendTransferAssets(tx: Transaction, armature: string, ticket: TxArg, params: {
+    targetTreasuryId: string;
+    targetCapabilityVaultId: string;
+    coinTypes: string[];
+    caps: {
+        id: string;
+        type: string;
+    }[];
+    treasuryVaultId: string;
+    capabilityVaultId: string;
+}): void;
+export declare function transferFreezeAdminAction(pkgs: ArmaturePkgs, params: {
+    newAdmin: string;
+    freezeAdminCapId: string;
+    emergencyFreezeId: string;
+}): OuProposalAction;
+export declare function unfreezeProposalTypeAction(pkgs: ArmaturePkgs, params: {
+    moveType: string;
+    emergencyFreezeId: string;
+}): OuProposalAction;
+export declare function updateFreezeConfigAction(pkgs: ArmaturePkgs, params: {
+    maxFreezeDurationMs: number;
+    emergencyFreezeId: string;
+}): OuProposalAction;
+export declare function updateFreezeExemptTypesAction(pkgs: ArmaturePkgs, params: {
+    add?: string[];
+    remove?: string[];
+    emergencyFreezeId: string;
+}): OuProposalAction;
+export {};

package/dist/armature/plan.d.ts

@@ -0,0 +1,39 @@
+import { Transaction } from '@mysten/sui/transactions';
+import { NormalizedExecution } from '../execute';
+import { OuCapabilities, OuProposalAction, ResolvedPlan, Strategy } from './harness';
+import { OuExecContext } from './types';
+type TxArg = ReturnType<Transaction['moveCall']>;
+export interface PlanOptions {
+    readonly?: boolean;
+    metadataIpfs?: string | null;
+}
+export declare function appendPlanActions(tx: Transaction, strategy: Strategy, actions: OuProposalAction[], ctx: OuExecContext, armature: string, opts?: PlanOptions): void;
+export declare function buildPlanTx(strategy: Strategy, action: OuProposalAction, ctx: OuExecContext, armature: string, opts?: PlanOptions): Transaction;
+export declare function buildBatchPlanTx(strategy: Strategy, actions: OuProposalAction[], ctx: OuExecContext, armature: string, opts?: PlanOptions): Transaction;
+export declare function buildCompositeSubmitTx(actions: OuProposalAction[], ctx: OuExecContext, armature: string, opts?: PlanOptions): Transaction;
+export declare function buildExecutePassedTx(args: {
+    action: OuProposalAction;
+    armature: string;
+    daoId: string;
+    proposalId: string;
+    emergencyFreezeId: string;
+    readonly?: boolean;
+}): Transaction;
+export interface CompositeStep {
+    payloadMoveType: string;
+    buildExecute: (tx: Transaction, ticket: TxArg, ownDaoId: string) => void;
+}
+export declare function buildExecuteCompositeTx(args: {
+    armature: string;
+    daoId: string;
+    proposalId: string;
+    emergencyFreezeId: string;
+    frameId: string;
+    steps: CompositeStep[];
+    deleteFrame?: boolean;
+}): Transaction;
+export declare function extractCreatedProposalId(res: NormalizedExecution): string | undefined;
+export declare function resolveExecutionPlan(action: OuProposalAction, ctx: OuExecContext, caps: OuCapabilities, caller: string | undefined, armature: string, opts?: {
+    metadataIpfs?: string | null;
+}): ResolvedPlan;
+export {};

package/dist/armature/proposals.d.ts

@@ -0,0 +1,51 @@
+import { ClientWithCoreApi } from '@mysten/sui/client';
+import { ProposalConfig } from './governance';
+export declare function asRecord(v: unknown): Record<string, unknown> | undefined;
+export declare function readTypeName(v: unknown): string | undefined;
+export declare function parseProposalConfigJson(v: unknown): ProposalConfig | null;
+export declare function payloadTypeOf(objectType: string): string | undefined;
+export interface LiveProposal {
+    proposalId: string;
+    ouId: string;
+    payloadType: string;
+    typeKey: string;
+    proposer: string;
+    metadataIpfs: string | null;
+    payload: Record<string, unknown>;
+    snapshotVersion: number;
+    totalSnapshotWeight: number;
+    votesCast: Record<string, boolean>;
+    yesWeight: number;
+    noWeight: number;
+    config: ProposalConfig;
+    createdAtMs: number;
+    passedAtMs: number | null;
+    status: 'active' | 'passed';
+    votingDeadlineMs: number;
+    executableFromMs: number | null;
+    executionDeadlineMs: number | null;
+}
+export declare function parseLiveProposal(proposalId: string, objectType: string, json: Record<string, unknown>): LiveProposal;
+export declare function fetchProposal(suiClient: ClientWithCoreApi, proposalId: string): Promise<LiveProposal | null>;
+export declare function isDeletable(p: LiveProposal, nowMs?: number): boolean;
+export declare function isExecutable(p: LiveProposal, nowMs?: number): boolean;
+export interface CapabilityVaultContents {
+    vaultId: string;
+    ouId: string;
+    capIds: string[];
+    byType: Map<string, string[]>;
+}
+export declare function parseCapabilityVault(content: Uint8Array): CapabilityVaultContents;
+export declare function fetchCapabilityVault(suiClient: ClientWithCoreApi, vaultId: string): Promise<CapabilityVaultContents>;
+export declare function capTypeOf(vault: CapabilityVaultContents, capId: string): string | undefined;
+export interface EncryptedEntry {
+    entryId: string;
+    ouId: string;
+    location: string;
+    description: string;
+    createdBy: string;
+    encryptEpoch: number;
+    stale: boolean;
+}
+export declare function fetchEncryptedEntries(suiClient: ClientWithCoreApi, entryIds: string[], currentEpoch: number): Promise<EncryptedEntry[]>;
+export declare function fetchFrameStepPayload(suiClient: ClientWithCoreApi, frameId: string, index: number): Promise<Record<string, unknown> | undefined>;

package/dist/armature/queries.d.ts

@@ -0,0 +1,16 @@
+import { AccessibleKeyspace, HubDaoVault, Org, OrgDirectoryPage, OrgDirectoryParams, OrgSearchParams, OrgSearchResult, ProposalSummary } from './types';
+export declare const MAX_BATCH_IDS = 200;
+export declare class OrgQueries {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    private fetchJson;
+    get(orgId: string): Promise<Org>;
+    batch(orgIds: string[]): Promise<Org[]>;
+    directory(params?: OrgDirectoryParams): Promise<OrgDirectoryPage>;
+    forPlayer(address: string): Promise<Org[]>;
+    search(q: string, params?: OrgSearchParams): Promise<OrgSearchResult[]>;
+    proposals(orgId: string): Promise<ProposalSummary[]>;
+    accessibleKeyspaces(address: string, role?: 'grant' | 'read' | 'write'): Promise<AccessibleKeyspace[]>;
+    vaultsAtHub(hubId: string): Promise<HubDaoVault[]>;
+}