@forevermoney/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,311 @@
+import { AbstractProvider, TransactionRequest } from 'ethers';
+
+declare function normalizeEvmAddress(value: string): string;
+declare function evmToMirrorSS58(evmAddress: string): string;
+declare function normalizeSS58(value: string): string;
+declare function isBittensorSS58(value: string): boolean;
+declare function ss58ToPublicKey(value: string): string;
+
+declare const BASIS_POINTS = 10000n;
+declare const NETWORK_FEE_BUFFER_BPS = 200n;
+declare const GAS_LIMIT_BUFFER_BPS = 5000n;
+declare function parseTaoAmount(value: string): bigint;
+declare function assertWholeRao(amountWei: bigint): void;
+declare function formatTaoAmount(amountWei: bigint): string;
+declare function feeWithBuffer(fee: bigint): bigint;
+declare function gasLimitWithBuffer(gasLimit: bigint): bigint;
+
+declare const foreverMoneyAbis: Readonly<{
+    alphaGateway: readonly ["function ROUTER() view returns (address)", "function allowedLane(uint64 selector) view returns (bool)", "function quoteBridgeOut(uint64 destSelector,address token,address recipient,uint256 mintedAmount) view returns (uint256 fee)", "function bridgeOut(uint64 destSelector,address token,address recipient,uint256 taoAmount,uint256 stakedAlphaRao,uint256 minTokenOut) payable returns (bytes32 messageId)", "function claimLiquid(address token,uint256 minTaoOut,address to)", "function claimNative(address to)", "function claimStaked(address token,bytes32 destColdkey,address to)", "function claimToken(address token,address to)", "function claimableNative(address account) view returns (uint256)", "function claimableToken(address account,address token) view returns (uint256)", "event BridgedOut(uint64 destChainSelector,address indexed token,address indexed sender,address indexed recipient,uint256 minted,bytes32 messageId)", "event Claimable(address indexed token,address indexed user,uint256 native,uint256 wsn)", "event DeliveredLiquid(address indexed token,bytes32 indexed ss58,uint256 taoOut)", "event DeliveredStaked(address indexed token,bytes32 indexed ss58,uint256 alphaRao)"];
+    alphaVault: readonly ["function isPaused() view returns (bool)", "function pausedUntil() view returns (uint256)", "function isListed(address token) view returns (bool)", "function backing(address token) view returns (uint256 stakedAlpha)", "function positionOf(address token) view returns (bytes32 validator,uint256 netuid)"];
+    ccipExecution: readonly ["event ExecutionStateChanged(uint64 indexed sourceChainSelector,uint64 indexed sequenceNumber,bytes32 indexed messageId,bytes32 messageHash,uint8 state,bytes returnData,uint256 gasUsed)"];
+    ccipRouter: readonly ["function isOffRamp(uint64 sourceChainSelector,address offRamp) view returns (bool)"];
+    erc20: readonly ["function allowance(address owner,address spender) view returns (uint256)", "function approve(address spender,uint256 amount) returns (bool)", "function balanceOf(address account) view returns (uint256)"];
+    spokeGateway: readonly ["function ROUTER() view returns (address)", "function BITTENSOR_SELECTOR() view returns (uint64)", "function SUBTENSOR_GATEWAY() view returns (address)", "function quoteBridgeToFinney(address token,uint256 amount,(bytes32 ss58,address evmFallback,bool wantLiquid,uint256 minTaoOut) exit) view returns (uint256 fee)", "function bridgeToFinney(address token,uint256 amount,(bytes32 ss58,address evmFallback,bool wantLiquid,uint256 minTaoOut) exit) payable returns (bytes32 messageId)", "event BridgedToFinney(address indexed token,address indexed sender,bytes32 indexed ss58,uint256 amount,bytes32 messageId)"];
+    staking: readonly ["function allowance(address sourceAddress,address spenderAddress,uint256 netuid) view returns (uint256)", "function approve(address spenderAddress,uint256 netuid,uint256 absoluteAmount)", "function getStake(bytes32 hotkey,bytes32 coldkey,uint256 netuid) view returns (uint256)"];
+    vaultFactory: readonly ["function create(address owner,bytes32 associatedMiner,address akAddress,address poolManager,address poolAddress,address positionManagerImpl,(address token,uint256 amount)[] stashTokens) payable returns (address manager)", "event SnLiquidityManagerCreated(address indexed manager,address indexed owner,bytes32 associatedMiner,address akAddress,address poolAddress,address poolManager,address positionManager)"];
+    vaultManager: readonly ["function claimFees(address akAddress)", "function topUpAk(address akAddress,address token,uint256 amount) payable", "function withdrawFromAkAndPositions(address akAddress,uint256 amount0,uint256 amount1,uint256[] decreaseTokenIds,bool unwrapETH)", "function stake(address akAddress,bytes data)", "function unstake(address akAddress,bytes data)", "function owner() view returns (address)", "event AKStashTopUp(address akAddress,address token,uint256 amount)", "event AKStashWithdraw(address akAddress,address token,uint256 amount)"];
+}>;
+
+declare const BASE_CHAIN_ID = 8453;
+declare const ROBINHOOD_CHAIN_ID = 4663;
+declare const SUBTENSOR_CHAIN_ID = 964;
+declare const BASE_CCIP_SELECTOR = 15971525489660198786n;
+declare const ROBINHOOD_CCIP_SELECTOR = 6180753054346818345n;
+declare const SUBTENSOR_CCIP_SELECTOR = 2135107236357186872n;
+declare const RAO_PER_TAO = 1000000000n;
+declare const EVM_WEI_PER_RAO = 1000000000n;
+declare const FOREVERMONEY_DEPLOYMENT_VERSION: "1.1.0";
+declare const foreverMoneyDeployment: Readonly<{
+    version: "1.1.0";
+    base: Readonly<{
+        key: "base";
+        name: "Base";
+        chainId: 8453;
+        ccipSelector: 15971525489660198786n;
+        contracts: Readonly<{
+            gateway: string;
+            wrappedTao: string;
+            ccipRouter: string;
+            ccipOffRampFromSubtensor: string;
+            vaultFactory: string;
+            vaultManagerImplementation: string;
+            batchLiquidityManagerQuery: string;
+            weth: string;
+        }>;
+        deploymentBlock: 50098800;
+    }>;
+    robinhood: Readonly<{
+        key: "robinhood";
+        name: "Robinhood";
+        chainId: 4663;
+        ccipSelector: 6180753054346818345n;
+        contracts: Readonly<{
+            gateway: string;
+            wrappedTao: string;
+            ccipRouter: string;
+            ccipOffRampFromSubtensor: string;
+        }>;
+    }>;
+    subtensor: Readonly<{
+        chainId: 964;
+        ccipSelector: 2135107236357186872n;
+        contracts: Readonly<{
+            gateway: string;
+            alphaVault: string;
+            wrappedTao: string;
+            ccipRouter: string;
+            ccipOffRampFromBase: string;
+            ccipOffRampFromRobinhood: string;
+            stakingPrecompile: string;
+        }>;
+    }>;
+}>;
+type ForeverMoneyDeployment = typeof foreverMoneyDeployment;
+type ForeverMoneyEvmChain = 'base' | 'robinhood';
+declare function getForeverMoneyEvmDeployment(chain?: ForeverMoneyEvmChain): ForeverMoneyDeployment['base'] | ForeverMoneyDeployment['robinhood'];
+
+type TransactionStepKind = 'approval' | 'transaction';
+type TransactionAction = 'bridge.base-to-subtensor' | 'bridge.robinhood-to-subtensor' | 'bridge.subtensor-to-base' | 'bridge.subtensor-to-robinhood' | 'vault.claim-fees' | 'vault.create' | 'vault.deposit' | 'vault.stake' | 'vault.unstake' | 'vault.withdraw';
+interface PreparedTransaction {
+    readonly chainId: number;
+    readonly from: string;
+    readonly to: string;
+    readonly data: string;
+    readonly value: string;
+    readonly gasLimit?: string;
+}
+interface TransactionStep {
+    readonly kind: TransactionStepKind;
+    readonly label: string;
+    readonly transaction: PreparedTransaction;
+}
+interface TransactionPlan {
+    readonly version: '1';
+    readonly deploymentVersion: typeof FOREVERMONEY_DEPLOYMENT_VERSION;
+    readonly action: TransactionAction;
+    readonly summary: string;
+    readonly steps: readonly TransactionStep[];
+    readonly hash: string;
+}
+
+declare const MIN_LIQUID_EVM_TO_SUBTENSOR_WEI = 10000000000000000n;
+declare const MIN_LIQUID_BASE_TO_SUBTENSOR_WEI = 10000000000000000n;
+type SubtensorDelivery = 'liquid' | 'staked';
+type SubtensorSource = 'liquid' | 'staked';
+interface EvmToSubtensorRequest {
+    readonly evmChain: ForeverMoneyEvmChain;
+    readonly sender: string;
+    readonly amountWei: bigint;
+    readonly destination: string;
+    readonly delivery: SubtensorDelivery;
+}
+interface SubtensorToEvmRequest {
+    readonly evmChain: ForeverMoneyEvmChain;
+    readonly sender: string;
+    readonly recipient: string;
+    readonly amountWei: bigint;
+    readonly source: SubtensorSource;
+    readonly netuid?: bigint;
+}
+type BaseToSubtensorRequest = Omit<EvmToSubtensorRequest, 'evmChain'>;
+type SubtensorToBaseRequest = Omit<SubtensorToEvmRequest, 'evmChain'>;
+interface BridgePreparation {
+    readonly exactNetworkFeeWei: bigint;
+    readonly transactionValueWei: bigint;
+    readonly plan: TransactionPlan;
+}
+interface BuildEvmToSubtensorPlanRequest extends EvmToSubtensorRequest {
+    readonly allowanceWei: bigint;
+    readonly exactNetworkFeeWei: bigint;
+    readonly estimatedBridgeGas?: bigint;
+}
+interface BuildSubtensorToEvmPlanRequest extends SubtensorToEvmRequest {
+    readonly stakingAllowanceRao?: bigint;
+    readonly exactNetworkFeeWei: bigint;
+    readonly estimatedBridgeGas?: bigint;
+}
+type BuildBaseToSubtensorPlanRequest = Omit<BuildEvmToSubtensorPlanRequest, 'evmChain'>;
+type BuildSubtensorToBasePlanRequest = Omit<BuildSubtensorToEvmPlanRequest, 'evmChain'>;
+declare function buildEvmToSubtensorPlan(input: BuildEvmToSubtensorPlanRequest): TransactionPlan;
+declare function buildBaseToSubtensorPlan(input: BuildBaseToSubtensorPlanRequest): TransactionPlan;
+declare function buildSubtensorToEvmPlan(input: BuildSubtensorToEvmPlanRequest): TransactionPlan;
+declare function buildSubtensorToBasePlan(input: BuildSubtensorToBasePlanRequest): TransactionPlan;
+
+interface RpcRequest {
+    readonly method: string;
+    readonly params?: readonly unknown[] | Record<string, unknown>;
+}
+interface RpcTransport {
+    request(request: RpcRequest): Promise<unknown>;
+}
+interface HttpTransportOptions {
+    readonly timeoutMs?: number;
+    readonly fetch?: typeof globalThis.fetch;
+}
+declare function http(url: string, options?: HttpTransportOptions): RpcTransport;
+
+interface VaultStashToken {
+    readonly token: string;
+    readonly amount: bigint;
+}
+interface CreateVaultRequest {
+    readonly owner: string;
+    readonly associatedMiner?: string;
+    readonly akAddress: string;
+    readonly poolManager: string;
+    readonly poolAddress: string;
+    readonly positionManagerImplementation: string;
+    readonly stashTokens: readonly VaultStashToken[];
+}
+interface VaultTokenAllowance {
+    readonly token: string;
+    readonly allowance: bigint;
+}
+declare function buildCreateVaultPlan(input: CreateVaultRequest & {
+    readonly allowances: readonly VaultTokenAllowance[];
+}): TransactionPlan;
+interface DepositVaultRequest {
+    readonly owner: string;
+    readonly manager: string;
+    readonly akAddress: string;
+    readonly deposits: readonly VaultStashToken[];
+}
+declare function buildDepositVaultPlan(input: DepositVaultRequest & {
+    readonly allowances: readonly VaultTokenAllowance[];
+}): TransactionPlan;
+interface WithdrawVaultRequest {
+    readonly owner: string;
+    readonly manager: string;
+    readonly akAddress: string;
+    readonly amount0: bigint;
+    readonly amount1: bigint;
+    readonly decreaseTokenIds: readonly bigint[];
+    readonly unwrapWeth: boolean;
+}
+declare function buildWithdrawVaultPlan(input: WithdrawVaultRequest): TransactionPlan;
+declare function buildClaimVaultFeesPlan(input: {
+    readonly owner: string;
+    readonly manager: string;
+    readonly akAddress: string;
+}): TransactionPlan;
+declare function buildSetVaultStakingPlan(input: {
+    readonly owner: string;
+    readonly manager: string;
+    readonly akAddress: string;
+    readonly staking: boolean;
+}): TransactionPlan;
+
+interface ReceiptLog {
+    readonly address: string;
+    readonly data: string;
+    readonly topics: readonly string[];
+}
+interface TransactionReceiptLike {
+    readonly logs: readonly ReceiptLog[];
+}
+
+type BridgeDirection = 'base-to-subtensor' | 'robinhood-to-subtensor' | 'subtensor-to-base' | 'subtensor-to-robinhood';
+declare function evmChainFromBridgeDirection(direction: BridgeDirection): ForeverMoneyEvmChain;
+declare function isEvmToSubtensorDirection(direction: BridgeDirection): boolean;
+declare function bridgeMessageIdFromReceipt(direction: BridgeDirection, receipt: TransactionReceiptLike): string | null;
+
+type CcipDeliveryStatus = 'failure' | 'recovery' | 'success' | 'waiting';
+interface CcipDeliveryStatusRequest {
+    readonly direction: BridgeDirection;
+    readonly messageId: string;
+    readonly fromBlock: number;
+}
+interface CcipDeliveryCheckpoint {
+    readonly direction: BridgeDirection;
+    readonly destinationChainId: number;
+    readonly fromBlock: number;
+}
+type BridgeSourceTransactionStatus = 'confirmed' | 'failed' | 'pending';
+interface BridgeSourceStatusRequest {
+    readonly direction: BridgeDirection;
+    readonly transactionHash: string;
+}
+interface BridgeSourceStatusBase {
+    readonly direction: BridgeDirection;
+    readonly sourceChainId: number;
+    readonly transactionHash: string;
+}
+type BridgeSourceStatus = (BridgeSourceStatusBase & {
+    readonly status: 'confirmed';
+    readonly messageId: string;
+}) | (BridgeSourceStatusBase & {
+    readonly status: 'failed' | 'pending';
+    readonly messageId: null;
+});
+declare function destinationChainId(direction: BridgeDirection): number;
+declare function sourceChainId(direction: BridgeDirection): number;
+declare function getBridgeSourceStatus(provider: AbstractProvider, input: BridgeSourceStatusRequest): Promise<BridgeSourceStatus>;
+declare function getCcipDeliveryCheckpoint(provider: AbstractProvider, direction: BridgeDirection): Promise<CcipDeliveryCheckpoint>;
+declare function getCcipDeliveryStatus(provider: AbstractProvider, input: CcipDeliveryStatusRequest): Promise<CcipDeliveryStatus>;
+
+interface ForeverMoneyClientOptions {
+    readonly transports: {
+        readonly base: RpcTransport;
+        readonly robinhood?: RpcTransport;
+        readonly subtensor: RpcTransport;
+    };
+}
+interface ForeverMoneyClient {
+    readonly bridge: {
+        prepareEvmToSubtensor(input: EvmToSubtensorRequest): Promise<BridgePreparation>;
+        prepareBaseToSubtensor(input: BaseToSubtensorRequest): Promise<BridgePreparation>;
+        prepareSubtensorToEvm(input: SubtensorToEvmRequest): Promise<BridgePreparation>;
+        prepareSubtensorToBase(input: SubtensorToBaseRequest): Promise<BridgePreparation>;
+        getDeliveryCheckpoint(direction: BridgeDirection): Promise<CcipDeliveryCheckpoint>;
+        getDeliveryStatus(input: CcipDeliveryStatusRequest): Promise<CcipDeliveryStatus>;
+        getSourceStatus(input: BridgeSourceStatusRequest): Promise<BridgeSourceStatus>;
+    };
+    readonly vaults: {
+        prepareCreate(input: CreateVaultRequest): Promise<TransactionPlan>;
+        prepareDeposit(input: DepositVaultRequest): Promise<TransactionPlan>;
+    };
+    verifyConnections(): Promise<void>;
+}
+declare function createForeverMoneyClient(options: ForeverMoneyClientOptions): ForeverMoneyClient;
+
+type ForeverMoneyErrorCode = 'AMOUNT_BELOW_MINIMUM' | 'AMOUNT_NOT_WHOLE_RAO' | 'AMOUNT_ZERO' | 'CHAIN_MISMATCH' | 'INVALID_ADDRESS' | 'INVALID_BYTES32' | 'INVALID_PROVIDER_RESPONSE' | 'INVALID_SS58' | 'INVALID_TRANSACTION_PLAN' | 'MISSING_TRANSPORT' | 'RPC_ERROR' | 'SIMULATION_REVERTED';
+declare class ForeverMoneyError extends Error {
+    readonly code: ForeverMoneyErrorCode;
+    readonly details: Readonly<Record<string, unknown>> | undefined;
+    constructor(code: ForeverMoneyErrorCode, message: string, details?: Readonly<Record<string, unknown>>);
+}
+
+declare function vaultManagerFromCreationReceipt(receipt: TransactionReceiptLike): string | null;
+
+interface Eip1193TransactionRequest {
+    readonly from: string;
+    readonly to: string;
+    readonly data: string;
+    readonly value: string;
+    readonly gas?: string;
+}
+declare function toEip1193Transaction(transaction: PreparedTransaction): Eip1193TransactionRequest;
+declare function toEthersTransaction(transaction: PreparedTransaction): Readonly<TransactionRequest>;
+
+export { BASE_CCIP_SELECTOR, BASE_CHAIN_ID, BASIS_POINTS, type BaseToSubtensorRequest, type BridgeDirection, type BridgePreparation, type BridgeSourceStatus, type BridgeSourceStatusRequest, type BridgeSourceTransactionStatus, type BuildBaseToSubtensorPlanRequest, type BuildEvmToSubtensorPlanRequest, type BuildSubtensorToBasePlanRequest, type BuildSubtensorToEvmPlanRequest, type CcipDeliveryCheckpoint, type CcipDeliveryStatus, type CcipDeliveryStatusRequest, type CreateVaultRequest, type DepositVaultRequest, EVM_WEI_PER_RAO, type Eip1193TransactionRequest, type EvmToSubtensorRequest, FOREVERMONEY_DEPLOYMENT_VERSION, type ForeverMoneyClient, type ForeverMoneyClientOptions, type ForeverMoneyDeployment, ForeverMoneyError, type ForeverMoneyErrorCode, type ForeverMoneyEvmChain, GAS_LIMIT_BUFFER_BPS, type HttpTransportOptions, MIN_LIQUID_BASE_TO_SUBTENSOR_WEI, MIN_LIQUID_EVM_TO_SUBTENSOR_WEI, NETWORK_FEE_BUFFER_BPS, type PreparedTransaction, RAO_PER_TAO, ROBINHOOD_CCIP_SELECTOR, ROBINHOOD_CHAIN_ID, type ReceiptLog, type RpcRequest, type RpcTransport, SUBTENSOR_CCIP_SELECTOR, SUBTENSOR_CHAIN_ID, type SubtensorDelivery, type SubtensorSource, type SubtensorToBaseRequest, type SubtensorToEvmRequest, type TransactionAction, type TransactionPlan, type TransactionReceiptLike, type TransactionStep, type TransactionStepKind, type VaultStashToken, type VaultTokenAllowance, type WithdrawVaultRequest, assertWholeRao, bridgeMessageIdFromReceipt, buildBaseToSubtensorPlan, buildClaimVaultFeesPlan, buildCreateVaultPlan, buildDepositVaultPlan, buildEvmToSubtensorPlan, buildSetVaultStakingPlan, buildSubtensorToBasePlan, buildSubtensorToEvmPlan, buildWithdrawVaultPlan, createForeverMoneyClient, destinationChainId, evmChainFromBridgeDirection, evmToMirrorSS58, feeWithBuffer, foreverMoneyAbis, foreverMoneyDeployment, formatTaoAmount, gasLimitWithBuffer, getBridgeSourceStatus, getCcipDeliveryCheckpoint, getCcipDeliveryStatus, getForeverMoneyEvmDeployment, http, isBittensorSS58, isEvmToSubtensorDirection, normalizeEvmAddress, normalizeSS58, parseTaoAmount, sourceChainId, ss58ToPublicKey, toEip1193Transaction, toEthersTransaction, vaultManagerFromCreationReceipt };