@trinaryex/sdk 3.9.0 → 5.0.0

package/dist/armature/transactions.d.ts

@@ -0,0 +1,160 @@
+import { Argument, Transaction } from '@mysten/sui/transactions';
+type TxArg = ReturnType<Transaction['moveCall']>;
+export interface ProposalConfigInput {
+    quorum: number;
+    approvalThreshold: number;
+    proposeThreshold: number;
+    expiryMs: number;
+    executionDelayMs: number;
+    cooldownMs: number;
+    composableAllowed?: boolean;
+    permissions?: number;
+    borrowScope?: string[];
+}
+export declare function typeNameOf(tx: Transaction, armature: string, moveType: string): TxArg;
+export declare function typeNameVec(tx: Transaction, armature: string, moveTypes: string[]): TxArg;
+export declare function newConfig(tx: Transaction, armature: string, c: ProposalConfigInput): TxArg;
+export declare function withComposableAllowed(tx: Transaction, armature: string, config: TxArg, allowed?: boolean): TxArg;
+export declare function newTypeInit(tx: Transaction, armature: string, init: {
+    moveType: string;
+    displayKey: string;
+    config: ProposalConfigInput;
+}): TxArg;
+export declare function typeInitVec(tx: Transaction, armature: string, inits: {
+    moveType: string;
+    displayKey: string;
+    config: ProposalConfigInput;
+}[]): TxArg;
+export declare function initBoard(tx: Transaction, armature: string, members: string[]): TxArg;
+export declare function submitVoteExecute(tx: Transaction, args: {
+    armature: string;
+    daoId: string;
+    payloadMoveType: string;
+    payload: TxArg;
+    emergencyFreezeId: string;
+    readonly?: boolean;
+    metadataIpfs?: string | null;
+}): TxArg;
+export declare function submitProposal(tx: Transaction, args: {
+    armature: string;
+    daoId: string;
+    payloadMoveType: string;
+    payload: TxArg;
+    metadataIpfs?: string | null;
+}): void;
+export declare function ticketFromVote(tx: Transaction, args: {
+    armature: string;
+    daoId: string;
+    proposalId: string;
+    payloadMoveType: string;
+    emergencyFreezeId: string;
+    readonly?: boolean;
+}): TxArg;
+export declare function voteTx(args: {
+    armature: string;
+    proposalId: string;
+    ouId: string;
+    payloadMoveType: string;
+    approve: boolean;
+}): Transaction;
+export declare function appendDeleteExpiredProposal(tx: Transaction, args: {
+    armature: string;
+    proposalId: string;
+    payloadMoveType: string;
+}): void;
+export declare function deleteExpiredProposalTx(args: {
+    armature: string;
+    proposals: {
+        proposalId: string;
+        payloadMoveType: string;
+    }[];
+}): Transaction;
+export declare function newFrame(tx: Transaction, armature: string, daoId: string): TxArg;
+export declare function typedStepFunction(payloadMoveType: string): string | null;
+export declare function addStep(tx: Transaction, args: {
+    armature: string;
+    frame: TxArg;
+    daoId: string;
+    payloadMoveType: string;
+    payload: TxArg;
+}): void;
+export declare function submitComposite(tx: Transaction, args: {
+    armature: string;
+    daoId: string;
+    frame: TxArg;
+    metadataIpfs?: string | null;
+}): void;
+export declare function beginPipeline(tx: Transaction, args: {
+    armature: string;
+    daoId: string;
+    frameId: string;
+    ticket: TxArg;
+}): Argument;
+export declare function advanceStep(tx: Transaction, args: {
+    armature: string;
+    daoId: string;
+    frameId: string;
+    pipeline: Argument;
+    emergencyFreezeId: string;
+    payloadMoveType: string;
+}): [TxArg, Argument];
+export declare function finalizePipeline(tx: Transaction, armature: string, pipeline: Argument): void;
+export declare function appendDeleteExhaustedFrame(tx: Transaction, armature: string, frameId: string): void;
+export declare function deleteExhaustedFrameTx(args: {
+    armature: string;
+    frameId: string;
+}): Transaction;
+export declare function freezeTypeTx(args: {
+    armature: string;
+    emergencyFreezeId: string;
+    freezeAdminCapId: string;
+    moveType: string;
+}): Transaction;
+export declare function unfreezeTypeTx(args: {
+    armature: string;
+    emergencyFreezeId: string;
+    freezeAdminCapId: string;
+    moveType: string;
+}): Transaction;
+export declare function publishEntryTx(args: {
+    armature: string;
+    ouId: string;
+    location: string;
+    description: string;
+}): Transaction;
+export declare function updateEntryTx(args: {
+    armature: string;
+    ouId: string;
+    entryId: string;
+    location: string;
+}): Transaction;
+export declare function editEntryTx(args: {
+    armature: string;
+    ouId: string;
+    entryId: string;
+    location: string;
+}): Transaction;
+export declare function rotateEncryptionEpochTx(args: {
+    armature: string;
+    ouId: string;
+}): Transaction;
+export declare function removeEntryTx(args: {
+    armature: string;
+    ouId: string;
+    entryId: string;
+}): Transaction;
+export declare function createOuTx(args: {
+    armature: string;
+    board: string[];
+    name: string;
+    metadataUri: string;
+}): Transaction;
+export declare function destroyOuTx(args: {
+    armature: string;
+    ouId: string;
+    treasuryId: string;
+    capabilityVaultId: string;
+    charterId: string;
+    emergencyFreezeId: string;
+}): Transaction;
+export {};

package/dist/armature/treasury.d.ts

@@ -0,0 +1,41 @@
+import { ClientWithCoreApi } from '@mysten/sui/client';
+import { Transaction } from '@mysten/sui/transactions';
+import { ArmaturePkgs } from './actions';
+import { OuProposalAction } from './harness';
+export interface TreasuryCoinBalance {
+    coinType: string;
+    amount: bigint;
+}
+export declare function toTypeNameKey(coinType: string): string;
+export declare function fetchTreasuryCoinBalances(suiClient: ClientWithCoreApi, treasuryVaultId: string): Promise<TreasuryCoinBalance[]>;
+export declare function fetchTreasuryCoinBalance(suiClient: ClientWithCoreApi, treasuryVaultId: string, coinType: string): Promise<bigint>;
+export declare function depositToTreasuryTx(args: {
+    armature: string;
+    treasuryVaultId: string;
+    coinType: string;
+    amount: bigint;
+}): Transaction;
+export declare function claimTreasuryCoinsTx(args: {
+    armature: string;
+    treasuryVaultId: string;
+    coinType: string;
+    coinObjectIds: string[];
+}): Transaction;
+export declare function sendCoinAction(pkgs: ArmaturePkgs, params: {
+    coinType: string;
+    recipient: string;
+    amount: bigint;
+    treasuryVaultId: string;
+}): OuProposalAction;
+export declare function sendCoinToOuAction(pkgs: ArmaturePkgs, params: {
+    coinType: string;
+    recipientTreasuryId: string;
+    amount: bigint;
+    treasuryVaultId: string;
+}): OuProposalAction;
+export declare function sendSmallPaymentAction(pkgs: ArmaturePkgs, params: {
+    coinType: string;
+    recipient: string;
+    amount: bigint;
+    treasuryVaultId: string;
+}): OuProposalAction;

package/dist/armature/tree.d.ts

@@ -0,0 +1,13 @@
+import { Org, OrgNode, OrgSeat, OuExecContext } from './types';
+export declare function roleForDepth(depth: number): {
+    key: string;
+    label: string;
+};
+export declare function flattenOrg(org: Org): OrgNode[];
+export declare function nodeById(nodes: readonly OrgNode[], daoId: string | null | undefined): OrgNode | null;
+export declare function rootNode(nodes: readonly OrgNode[]): OrgNode | null;
+export declare function tradingNode(nodes: readonly OrgNode[]): OrgNode | null;
+export declare function seatsFor(nodes: readonly OrgNode[], address: string): OrgSeat[];
+export declare function resolveSeat(nodes: readonly OrgNode[], address: string, preferredDaoId?: string | null): OrgSeat | null;
+export declare function execContextFor(nodes: readonly OrgNode[], daoId: string): OuExecContext | null;
+export declare function findNodeAcross(orgs: readonly Org[], daoId: string | null | undefined): OrgNode | null;

package/dist/armature/types.d.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+import { AccessibleKeyspaceSchema, HubDaoVaultSchema, OrgDirectoryPageSchema, ProposalCompositeStepSchema, ProposalSummarySchema, VaultAclEntrySchema } from './schemas';
+export type { Org, OrgActor, OrgDirectoryEntry, OrgMetadata, OrgSearchResult, } from './schemas';
+export type OrgDirectoryPage = z.output<typeof OrgDirectoryPageSchema>;
+export type ProposalSummary = z.output<typeof ProposalSummarySchema>;
+export type ProposalCompositeStep = z.output<typeof ProposalCompositeStepSchema>;
+export type ProposalStatus = ProposalSummary['status'];
+export type AccessibleKeyspace = z.output<typeof AccessibleKeyspaceSchema>;
+export type KeyspaceRole = AccessibleKeyspace['roles'][number];
+export type KeyspaceMatchVia = AccessibleKeyspace['matchVia'];
+export type HubDaoVault = z.output<typeof HubDaoVaultSchema>;
+export type VaultAclEntry = z.output<typeof VaultAclEntrySchema>;
+export type VaultRole = VaultAclEntry['role'];
+export interface VaultPrincipal {
+    kind: 'player' | 'machine' | 'ou';
+    value: string;
+}
+export interface OrgDirectoryParams {
+    limit?: number;
+    cursor?: string;
+    sort?: 'members' | 'name';
+}
+export interface OrgSearchParams {
+    limit?: number;
+    enrich?: boolean;
+}
+export interface OrgNode {
+    daoId: string;
+    parentDaoId: string | null;
+    depth: number;
+    childDaoIds: string[];
+    name: string | null;
+    charterId: string | null;
+    treasuryId: string | null;
+    capabilityVaultId: string | null;
+    emergencyFreezeId: string | null;
+    members: string[];
+    tradingAccountId: string | null;
+    subdaoControlCapId: string | null;
+    roleKey: string;
+    roleLabel: string;
+    rank: number;
+}
+export interface OrgSeat extends OrgNode {
+    address: string;
+}
+export interface OuParent {
+    daoId: string;
+    board: string[];
+    emergencyFreezeId: string;
+    capVaultId: string;
+    controlCapId: string;
+}
+export interface OuExecContext {
+    daoId: string;
+    board: string[];
+    emergencyFreezeId: string;
+    parent?: OuParent;
+}

package/dist/armature/upgrade.d.ts

@@ -0,0 +1,27 @@
+import { Transaction } from '@mysten/sui/transactions';
+import { ArmaturePkgs } from './actions';
+import { OuProposalAction } from './harness';
+export interface UpgradeBuild {
+    modules: (string | number[] | Uint8Array)[];
+    dependencies: string[];
+}
+export declare const UPGRADE_POLICY: {
+    readonly COMPATIBLE: 0;
+    readonly ADDITIVE: 128;
+    readonly DEP_ONLY: 192;
+};
+export declare function appendUpgradeExecution(tx: Transaction, args: {
+    armatureProposals: string;
+    capabilityVaultId: string;
+    packageId: string;
+    ticket: ReturnType<Transaction['moveCall']>;
+    build: UpgradeBuild;
+}): void;
+export declare function proposeUpgradeAction(pkgs: ArmaturePkgs, params: {
+    capId: string;
+    packageId: string;
+    digest: number[] | Uint8Array;
+    policy?: number;
+    capabilityVaultId: string;
+    build?: UpgradeBuild;
+}): OuProposalAction;

package/dist/armature/vault.d.ts

@@ -0,0 +1,94 @@
+import { ClientWithCoreApi } from '@mysten/sui/client';
+import { Transaction, TransactionObjectArgument } from '@mysten/sui/transactions';
+import { PackageIds } from '../types';
+import { VaultPrincipal, VaultRole } from './types';
+export declare const VaultKeyBcs: import('@mysten/bcs').BcsStruct<{
+    storage_unit_id: import('@mysten/bcs').BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    registrant_ou_id: import('@mysten/bcs').BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, string>;
+export declare function toStorageUnitId(value: string): string;
+export declare function resolveOuVaultId(suiClient: ClientWithCoreApi, ids: PackageIds, params: {
+    storageUnitId: string;
+    registrantOrgId: string;
+}): Promise<string | null>;
+export interface OuVaultInfo {
+    vaultId: string;
+    storageUnitId: string;
+    collectionId: string;
+    registrantOrgId: string;
+    nonEmptyAssets: number;
+    acl: {
+        role: VaultRole;
+        principal: VaultPrincipal;
+    }[];
+}
+export declare function fetchOuVaultInfo(suiClient: ClientWithCoreApi, vaultId: string): Promise<OuVaultInfo | null>;
+export declare function fetchVaultBalance(suiClient: ClientWithCoreApi, vaultId: string, assetId: bigint): Promise<bigint>;
+export declare function principalVec(tx: Transaction, armatureVault: string, principals: VaultPrincipal[]): TransactionObjectArgument;
+export declare function roleVec(tx: Transaction, armatureVault: string, roles: VaultRole[]): TransactionObjectArgument;
+export declare function initializeOuVaultTx(tx: Transaction, args: {
+    armatureVault: string;
+    registryId: string;
+    storageUnitId: string;
+    registrantOrgId: string;
+    vaultConfigId: string;
+    depositPrincipals: VaultPrincipal[];
+    withdrawPrincipals: VaultPrincipal[];
+    editPrincipals: VaultPrincipal[];
+}): void;
+export declare function depositReceiptTx(tx: Transaction, args: {
+    armatureVault: string;
+    vaultId: string;
+    ouId: string;
+    balance: TransactionObjectArgument;
+}): void;
+export declare function withdrawReceiptTx(tx: Transaction, args: {
+    armatureVault: string;
+    vaultId: string;
+    ouId: string;
+    assetId: bigint;
+    amount: bigint;
+}): TransactionObjectArgument;
+export declare function grantTx(tx: Transaction, args: {
+    armatureVault: string;
+    vaultId: string;
+    editorOuId: string;
+    grants: {
+        role: VaultRole;
+        principal: VaultPrincipal;
+    }[];
+}): void;
+export declare function grantEditOuTx(tx: Transaction, args: {
+    armatureVault: string;
+    vaultId: string;
+    editorOuId: string;
+    targetOuId: string;
+}): void;
+export declare function revokeTx(tx: Transaction, args: {
+    armatureVault: string;
+    vaultId: string;
+    editorOuId: string;
+    revocations: {
+        role: VaultRole;
+        principal: VaultPrincipal;
+    }[];
+}): void;
+export declare function updateRegistryKeyTx(tx: Transaction, args: {
+    armatureVault: string;
+    registryId: string;
+    vaultId: string;
+    editorOuId: string;
+    newRegistrantOrgId: string;
+}): void;
+export declare function deinitializeOuVaultTx(tx: Transaction, args: {
+    armatureVault: string;
+    registryId: string;
+    vaultId: string;
+    editorOuId: string;
+}): void;
+export declare function sourceWalletReceipts(suiClient: ClientWithCoreApi, tx: Transaction, ids: PackageIds, params: {
+    owner: string;
+    assetId: bigint;
+    amount: bigint;
+    collectionId: string;
+}): Promise<TransactionObjectArgument>;

package/dist/coins/CoinsApi.d.ts

@@ -0,0 +1,53 @@
+import { ClientWithCoreApi } from '@mysten/sui/client';
+import { IndexerClient } from '../queries';
+import { TriexClient } from '../TriexClient';
+import { PackageIds, TxResult } from '../types';
+import { CoinMarketEstimate } from './money';
+import { CoinBookOrder, CoinPoolAccount, CoinTradeParams } from './onchain';
+import { CoinAccountParams, CoinBalances, CoinBalancesParams, CoinCancelOrderParams, CoinCancelOrdersParams, CoinClaimSettledParams, CoinDepositParams, CoinInfo, CoinLimitOrderParams, CoinMarketEstimateParams, CoinMarketOrderParams, CoinModifyOrderParams, CoinOrderbook, CoinOrderbookParams, CoinPool, CoinPoolSelector, CoinSwapParams, CoinSwapQuote, CoinSwapQuoteParams, CoinSwapResult, CoinTradeParamsParams, CoinWithdrawParams, CreateCoinPoolParams, CreateCoinPoolResult } from './types';
+export declare const DEFAULT_SWAP_SLIPPAGE_BPS = 50;
+export interface CoinsReadDeps {
+    indexer: IndexerClient;
+    ids: PackageIds;
+    suiClient?: ClientWithCoreApi;
+    requireAddress: (override?: string) => string;
+    resolveTradingAccountId?: (address: string) => Promise<string | null>;
+    defaultSender?: () => string | undefined;
+}
+export declare class CoinsReadApi {
+    protected readonly deps: CoinsReadDeps;
+    private readonly poolCache;
+    constructor(deps: CoinsReadDeps);
+    protected get ids(): PackageIds;
+    protected requireSui(): ClientWithCoreApi;
+    list(params?: {
+        coinTypes?: string[];
+    }): Promise<CoinInfo[]>;
+    resolvePool(selector: CoinPoolSelector): Promise<CoinPool>;
+    orderbook(params: CoinOrderbookParams): Promise<CoinOrderbook>;
+    tradeParams(params: CoinTradeParamsParams): Promise<CoinTradeParams>;
+    quote(params: CoinSwapQuoteParams): Promise<CoinSwapQuote>;
+    estimateMarket(params: CoinMarketEstimateParams): Promise<CoinMarketEstimate>;
+    openOrders(params: CoinAccountParams): Promise<CoinBookOrder[]>;
+    account(params: CoinAccountParams): Promise<CoinPoolAccount | null>;
+    balances(params: CoinBalancesParams): Promise<CoinBalances>;
+    protected lookupAccount(address: string): Promise<string | null>;
+    protected accountIdFor(explicit?: string): Promise<string | null>;
+    private remember;
+}
+export declare class CoinsApi extends CoinsReadApi {
+    private readonly c;
+    constructor(c: TriexClient);
+    deposit(params: CoinDepositParams): Promise<TxResult>;
+    withdraw(params: CoinWithdrawParams): Promise<TxResult>;
+    limit(params: CoinLimitOrderParams): Promise<TxResult>;
+    market(params: CoinMarketOrderParams): Promise<TxResult>;
+    swap(params: CoinSwapParams): Promise<CoinSwapResult>;
+    cancel(params: CoinCancelOrderParams): Promise<TxResult>;
+    cancelMany(params: CoinCancelOrdersParams): Promise<TxResult>;
+    cancelAll(params: CoinPoolSelector): Promise<TxResult>;
+    modify(params: CoinModifyOrderParams): Promise<TxResult>;
+    claimSettled(params: CoinClaimSettledParams): Promise<TxResult>;
+    createPool(params: CreateCoinPoolParams): Promise<CreateCoinPoolResult>;
+    private withAccountTx;
+}

package/dist/coins/funding.d.ts

@@ -0,0 +1,6 @@
+import { ClientWithCoreApi } from '@mysten/sui/client';
+import { Transaction, TransactionObjectArgument } from '@mysten/sui/transactions';
+import { PackageIds } from '../types';
+export declare function isSuiCoinType(coinType: string): boolean;
+export declare function prepareCoinInput(suiClient: ClientWithCoreApi, tx: Transaction, owner: string, coinType: string, amount: bigint, insufficientMessage?: string): Promise<TransactionObjectArgument>;
+export declare function depositCoinDeficit(suiClient: ClientWithCoreApi, tx: Transaction, ids: PackageIds, account: TransactionObjectArgument, existingAccountId: string | null, owner: string, coinType: string, target: bigint): Promise<bigint>;

package/dist/coins/money.d.ts

@@ -0,0 +1,36 @@
+export declare const COIN_PRICE_SCALING = 1000000000n;
+export declare const COIN_MIN_PRICE = 1n;
+export declare const COIN_MAX_PRICE: bigint;
+export declare const COIN_POOL_CREATION_FEE = 500000000n;
+export declare const COIN_MAX_FILLS = 100;
+export declare function coinQuoteForBase(price: bigint, quantity: bigint): bigint;
+export declare function coinQuoteFee(quote: bigint, feeRateScaled: bigint): bigint;
+export declare function coinMinOrderQuantity(price: bigint): bigint;
+export declare function computeCoinBidDeposit(price: bigint, quantity: bigint, feeRateScaled: bigint): bigint;
+export interface CoinFeeRates {
+    takerFee: bigint;
+    makerFee: bigint;
+}
+export declare function conservativeBidFeeRate(entry: CoinFeeRates, next?: CoinFeeRates | null, opts?: {
+    marketOrder?: boolean;
+}): bigint;
+export declare function coinSellNet(grossQuote: bigint, feeRateScaled: bigint): bigint;
+export interface CoinMakerOrder {
+    price: bigint;
+    remainingQuantity: bigint;
+}
+export interface CoinMarketEstimate {
+    side: 'buy' | 'sell';
+    requestedQuantity: bigint;
+    filledQuantity: bigint;
+    fillable: boolean;
+    grossQuote: bigint;
+    fee: bigint;
+    totalQuote: bigint;
+    avgPrice: bigint | null;
+    makersVisited: number;
+}
+export declare function estimateCoinMarketOrder(makers: ReadonlyArray<CoinMakerOrder>, side: 'buy' | 'sell', quantity: bigint, takerFeeRateScaled: bigint): CoinMarketEstimate;
+export declare function coinPriceDecimals(baseDecimals: number, quoteDecimals: number): number;
+export declare function coinPriceToRaw(human: string | number, baseDecimals: number, quoteDecimals: number): bigint;
+export declare function formatCoinPrice(raw: bigint, baseDecimals: number, quoteDecimals: number): string;

package/dist/coins/onchain.d.ts

@@ -0,0 +1,162 @@
+import { ClientWithCoreApi } from '@mysten/sui/client';
+import { Transaction } from '@mysten/sui/transactions';
+import { PackageIds } from '../types';
+import { CoinPoolTypes } from './transactions';
+import { CoinFeeRates } from './money';
+export declare const CoinOrderBcs: import('@mysten/bcs').BcsStruct<{
+    trading_account_id: import('@mysten/bcs').BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    order_id: import('@mysten/bcs').BcsType<string, string | number | bigint, "u128">;
+    price: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+    is_bid: import('@mysten/bcs').BcsType<boolean, boolean, "bool">;
+    quantity: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+    filled_quantity: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+    epoch: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+    maker_fee_rate: import('@mysten/bcs').BcsType<number, number, "u16">;
+    cancel_retention_bps: import('@mysten/bcs').BcsType<number, number, "u16">;
+    status: import('@mysten/bcs').BcsType<number, number, "u8">;
+    expire_timestamp: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+}, string>;
+export declare const CoinOrderPageBcs: import('@mysten/bcs').BcsStruct<{
+    orders: import('@mysten/bcs').BcsType<{
+        trading_account_id: string;
+        order_id: string;
+        price: string;
+        is_bid: boolean;
+        quantity: string;
+        filled_quantity: string;
+        epoch: string;
+        maker_fee_rate: number;
+        cancel_retention_bps: number;
+        status: number;
+        expire_timestamp: string;
+    }[], Iterable<{
+        trading_account_id: string | Uint8Array<ArrayBufferLike>;
+        order_id: string | number | bigint;
+        price: string | number | bigint;
+        is_bid: boolean;
+        quantity: string | number | bigint;
+        filled_quantity: string | number | bigint;
+        epoch: string | number | bigint;
+        maker_fee_rate: number;
+        cancel_retention_bps: number;
+        status: number;
+        expire_timestamp: string | number | bigint;
+    }> & {
+        length: number;
+    }, string>;
+    has_next_page: import('@mysten/bcs').BcsType<boolean, boolean, "bool">;
+}, string>;
+export declare const CoinBalancesBcs: import('@mysten/bcs').BcsStruct<{
+    base: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+    quote: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+    cred: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+}, string>;
+export declare const CoinPoolAccountBcs: import('@mysten/bcs').BcsStruct<{
+    open_orders: import('@mysten/bcs').BcsStruct<{
+        contents: import('@mysten/bcs').BcsType<string[], Iterable<string | number | bigint> & {
+            length: number;
+        }, string>;
+    }, string>;
+    taker_volume: import('@mysten/bcs').BcsType<string, string | number | bigint, "u128">;
+    maker_volume: import('@mysten/bcs').BcsType<string, string | number | bigint, "u128">;
+    settled_balances: import('@mysten/bcs').BcsStruct<{
+        base: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+        quote: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+        cred: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+    }, string>;
+    owed_balances: import('@mysten/bcs').BcsStruct<{
+        base: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+        quote: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+        cred: import('@mysten/bcs').BcsType<string, string | number | bigint, "u64">;
+    }, string>;
+    pending_turnover: import('@mysten/bcs').BcsType<{
+        epoch: string;
+        amount: string;
+    }[], Iterable<{
+        epoch: string | number | bigint;
+        amount: string | number | bigint;
+    }> & {
+        length: number;
+    }, string>;
+}, string>;
+export declare const CoinFeeScheduleBcs: import('@mysten/bcs').BcsStruct<{
+    tiers: import('@mysten/bcs').BcsType<{
+        min_turnover: string;
+        taker_fee: string;
+        maker_fee: string;
+    }[], Iterable<{
+        min_turnover: string | number | bigint;
+        taker_fee: string | number | bigint;
+        maker_fee: string | number | bigint;
+    }> & {
+        length: number;
+    }, string>;
+}, string>;
+export declare const COIN_ORDER_STATUS: readonly ["live", "partially_filled", "filled", "canceled", "expired"];
+export interface CoinBookOrder {
+    orderId: string;
+    tradingAccountId: string;
+    isBid: boolean;
+    price: bigint;
+    quantity: bigint;
+    filledQuantity: bigint;
+    remainingQuantity: bigint;
+    expireTimestamp: bigint;
+    makerFeeBps: number;
+    cancelRetentionBps: number;
+    status: (typeof COIN_ORDER_STATUS)[number] | 'unknown';
+    epoch: bigint;
+}
+export declare function toCoinBookOrder(o: ReturnType<typeof CoinOrderBcs.parse>): CoinBookOrder;
+export declare function simulateReturnValues(suiClient: ClientWithCoreApi, tx: Transaction, sender?: string): Promise<Uint8Array[][] | null>;
+export declare function resolveCoinPoolId(suiClient: ClientWithCoreApi, ids: PackageIds, pair: {
+    baseCoinType: string;
+    quoteCoinType: string;
+}): Promise<string | null>;
+export declare function fetchCoinPoolTypes(suiClient: ClientWithCoreApi, poolId: string): Promise<CoinPoolTypes>;
+export declare function getTradingAccountCoinBalance(suiClient: ClientWithCoreApi, ids: PackageIds, tradingAccountId: string, coinType: string): Promise<bigint>;
+export interface CoinBookSide {
+    orders: CoinBookOrder[];
+    hasMore: boolean;
+}
+export declare function fetchCoinBookSide(suiClient: ClientWithCoreApi, ids: PackageIds, pool: CoinPoolTypes, bids: boolean, opts?: {
+    depth?: number;
+    pageSize?: number;
+    now?: number;
+}): Promise<CoinBookSide>;
+export interface CoinPoolBalances {
+    base: bigint;
+    quote: bigint;
+    cred: bigint;
+}
+export interface CoinPoolAccount {
+    poolId: string;
+    tradingAccountId: string;
+    openOrderIds: string[];
+    takerVolume: bigint;
+    makerVolume: bigint;
+    settled: CoinPoolBalances;
+    owed: CoinPoolBalances;
+    lockedInOrders: CoinPoolBalances;
+}
+export declare function fetchCoinPoolAccount(suiClient: ClientWithCoreApi, ids: PackageIds, pool: CoinPoolTypes, tradingAccountId: string, sender?: string): Promise<CoinPoolAccount | null>;
+export declare function fetchCoinAccountOrders(suiClient: ClientWithCoreApi, ids: PackageIds, pool: CoinPoolTypes, tradingAccountId: string, sender?: string): Promise<CoinBookOrder[]>;
+export interface CoinTradeParams {
+    poolId: string;
+    feeClass: number;
+    entry: CoinFeeRates;
+    next: CoinFeeRates & {
+        effectiveEpoch: bigint;
+    };
+    cancelRetentionBps: bigint;
+    account: (CoinFeeRates & {
+        tier: bigint;
+        turnover: bigint;
+    }) | null;
+}
+export declare function fetchCoinTradeParams(suiClient: ClientWithCoreApi, ids: PackageIds, pool: CoinPoolTypes, tradingAccountId?: string | null, sender?: string): Promise<CoinTradeParams>;
+export declare function dryRunCoinQuantityOut(suiClient: ClientWithCoreApi, ids: PackageIds, pool: CoinPoolTypes, args: {
+    baseIn: bigint;
+    quoteIn: bigint;
+    tradingAccountId?: string | null;
+}, sender?: string): Promise<[bigint, bigint]>;