hedge-web3 0.1.16 → 0.1.19

package/declarations/Constants.d.ts

@@ -1,5 +1,5 @@
 import { PublicKey } from '@solana/web3.js';
-export declare const HEDGE_PROGRAM_ID = "h4sPyjiRvWLquKRULRND9jHCPKqRYZZukvrjMZn21Pz";
+export declare const HEDGE_PROGRAM_ID = "h6GZ7ZMB6Jwmj3k4mQZY1bfXMGREEWH47uJHbKvE6nd";
 export declare const HEDGE_PROGRAM_PUBLICKEY: PublicKey;
 export declare const CHAINLINK_SOL_USD_ID = "FmAmfoyPXiA8Vhhe6MZTr3U6rZfEZ1ctEHay1ysqCqcf";
 export declare const CHAINLINK_SOL_USD_PUBLICKEY: PublicKey;
@@ -10,5 +10,6 @@ export declare function getVaultSystemStatePublicKey(): Promise<PublicKey>;
 export declare function getHedgeMintPublicKey(): Promise<PublicKey>;
 export declare function getPoolPublicKeyForMint(mintPublicKey: PublicKey): Promise<[PublicKey, number, string]>;
 export declare function getVaultTypeAccountPublicKey(collateralType: string): Promise<PublicKey>;
+export declare function getVaultTypeOracleAccountPublicKey(collateralType: string): Promise<PublicKey>;
 export declare function findVaultAddress(vaultSalt: string): Promise<PublicKey>;
 export declare function findAssociatedTokenAddress(walletAddress: PublicKey, tokenMintAddress: PublicKey): Promise<PublicKey>;

package/declarations/instructions/createVault.d.ts

@@ -1,4 +1,5 @@
-import { Program, Provider } from '@project-serum/anchor';
-import { PublicKey, Signer, TransactionInstruction } from '@solana/web3.js';
+import { Program, Provider } from "@project-serum/anchor";
+import { PublicKey, Signer, Transaction, TransactionInstruction } from "@solana/web3.js";
 export declare function createVault(program: Program, provider: Provider, payer: Signer, collateralType: string, depositAmount: number, overrideTime?: number): Promise<PublicKey>;
-export declare function createVaultInstruction(program: Program, salt: string, vaultSystemStatePublicKey: PublicKey, payerPublicKey: PublicKey, payerTokenAccountPublicKey: PublicKey, vaultPublicKey: PublicKey, vaultAssociatedTokenAccount: PublicKey, feePool: PublicKey, feePoolAssociatedUsdhTokenAccount: PublicKey, vaultTypeAccount: PublicKey, collateralMint: PublicKey, historyPublicKey: PublicKey, usdhMintPublickey: PublicKey, depositAmount: number, overrideTime?: number): Promise<TransactionInstruction>;
+export declare function buildCreateVaultTransaction(program: Program, collateralType: string, depositAmount: number, overrideTime?: number): Promise<[Transaction, Signer[], PublicKey]>;
+export declare function createVaultInstruction(program: Program, salt: string, payerPublicKey: PublicKey, payerTokenAccountPublicKey: PublicKey, vaultPublicKey: PublicKey, vaultAssociatedTokenAccount: PublicKey, feePool: PublicKey, feePoolAssociatedUsdhTokenAccount: PublicKey, vaultTypeAccount: PublicKey, collateralMint: PublicKey, historyPublicKey: PublicKey, usdhMintPublickey: PublicKey, depositAmount: number, overrideTime?: number): Promise<TransactionInstruction>;

package/declarations/state/VaultAccount.d.ts

@@ -8,12 +8,15 @@ export declare class VaultAccount {
     publicKey: PublicKey;
     /** The public key of the vault owner. */
     vaultOwner: PublicKey;
-    /** The outstanding debt of the vault (in USDH Lamports). */
-    debt: number;
+    /** The public key of the vault owner. */
+    pdaSalt: string;
     /** The deposited collateral of the vault (in SOL Lamports). */
     deposited: number;
-    /** The minimum collateral ratio this vault must maintain to not be subject to liquidation. */
-    minCollateralRatio: Decimal;
+    /** The outstanding debt of the vault (in USDH Lamports). Denormalized to time 0. */
+    denormalizedDebt: number;
+    debtProductSnapshotBytes: Decimal;
+    collateralAccumulatorSnapshotBytes: Decimal;
+    collateralType: string;
     /** Current State of the vautl ("Open", "Closed", "Liquidated") */
     vaultStatus: string;
     constructor(vault: any, publicKey: PublicKey);

package/lib/Constants.js

@@ -9,10 +9,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findAssociatedTokenAddress = exports.findVaultAddress = exports.getVaultTypeAccountPublicKey = exports.getPoolPublicKeyForMint = exports.getHedgeMintPublicKey = exports.getVaultSystemStatePublicKey = exports.getUsdhMintPublicKey = exports.getLiquidationPoolUsdhAccountPublicKey = exports.getLiquidationPoolStatePublicKey = exports.CHAINLINK_SOL_USD_PUBLICKEY = exports.CHAINLINK_SOL_USD_ID = exports.HEDGE_PROGRAM_PUBLICKEY = exports.HEDGE_PROGRAM_ID = void 0;
+exports.findAssociatedTokenAddress = exports.findVaultAddress = exports.getVaultTypeOracleAccountPublicKey = exports.getVaultTypeAccountPublicKey = exports.getPoolPublicKeyForMint = exports.getHedgeMintPublicKey = exports.getVaultSystemStatePublicKey = exports.getUsdhMintPublicKey = exports.getLiquidationPoolUsdhAccountPublicKey = exports.getLiquidationPoolStatePublicKey = exports.CHAINLINK_SOL_USD_PUBLICKEY = exports.CHAINLINK_SOL_USD_ID = exports.HEDGE_PROGRAM_PUBLICKEY = exports.HEDGE_PROGRAM_ID = void 0;
 const spl_token_1 = require("@solana/spl-token");
 const web3_js_1 = require("@solana/web3.js");
-exports.HEDGE_PROGRAM_ID = 'h4sPyjiRvWLquKRULRND9jHCPKqRYZZukvrjMZn21Pz';
+exports.HEDGE_PROGRAM_ID = 'h6GZ7ZMB6Jwmj3k4mQZY1bfXMGREEWH47uJHbKvE6nd';
 exports.HEDGE_PROGRAM_PUBLICKEY = new web3_js_1.PublicKey(exports.HEDGE_PROGRAM_ID);
 exports.CHAINLINK_SOL_USD_ID = 'FmAmfoyPXiA8Vhhe6MZTr3U6rZfEZ1ctEHay1ysqCqcf';
 exports.CHAINLINK_SOL_USD_PUBLICKEY = new web3_js_1.PublicKey(exports.CHAINLINK_SOL_USD_ID);
@@ -67,6 +67,13 @@ function getVaultTypeAccountPublicKey(collateralType) {
     });
 }
 exports.getVaultTypeAccountPublicKey = getVaultTypeAccountPublicKey;
+function getVaultTypeOracleAccountPublicKey(collateralType) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [vaultTypeOracleAccount] = yield web3_js_1.PublicKey.findProgramAddress([enc.encode(collateralType), enc.encode('Oracle')], exports.HEDGE_PROGRAM_PUBLICKEY);
+        return vaultTypeOracleAccount;
+    });
+}
+exports.getVaultTypeOracleAccountPublicKey = getVaultTypeOracleAccountPublicKey;
 function findVaultAddress(vaultSalt) {
     return __awaiter(this, void 0, void 0, function* () {
         const [vaultAddress] = yield web3_js_1.PublicKey.findProgramAddress([enc.encode('Vault'), enc.encode(vaultSalt)], exports.HEDGE_PROGRAM_PUBLICKEY);

package/lib/instructions/createVault.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createVaultInstruction = exports.createVault = void 0;
+exports.createVaultInstruction = exports.buildCreateVaultTransaction = exports.createVault = void 0;
 const anchor_1 = require("@project-serum/anchor");
 const serum_1 = require("@project-serum/serum");
 const spl_token_1 = require("@solana/spl-token");
@@ -29,11 +29,11 @@ function createVault(program, provider, payer, collateralType, depositAmount, ov
         const vaultTypeAccountInfo = yield program.account.vaultType.fetch(vaultTypeAccountPublicKey);
         const payerTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(payer.publicKey, vaultTypeAccountInfo.collateralMint);
         const vaultAssociatedTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(newVaultPublicKey, vaultTypeAccountInfo.collateralMint);
-        const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
         const wrappedSolAccount = web3_js_1.Keypair.generate();
         const transaction = new web3_js_1.Transaction();
         const signers = [payer, history];
-        const isWrappedSol = vaultTypeAccountInfo.collateralMint.toString() === serum_1.TokenInstructions.WRAPPED_SOL_MINT.toString();
+        const isWrappedSol = vaultTypeAccountInfo.collateralMint.toString() ===
+            serum_1.TokenInstructions.WRAPPED_SOL_MINT.toString();
         const [hedgeStakingPoolPublicKey] = yield (0, Constants_1.getPoolPublicKeyForMint)(yield (0, Constants_1.getHedgeMintPublicKey)());
         const feePoolAssociatedUsdhTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(hedgeStakingPoolPublicKey, usdhMintPublickey);
         if (isWrappedSol) {
@@ -42,20 +42,20 @@ function createVault(program, provider, payer, collateralType, depositAmount, ov
                 lamports: depositAmount + 2.04e6,
                 newAccountPubkey: wrappedSolAccount.publicKey,
                 programId: spl_token_1.TOKEN_PROGRAM_ID,
-                space: 165
+                space: 165,
             }), serum_1.TokenInstructions.initializeAccount({
                 account: wrappedSolAccount.publicKey,
                 mint: serum_1.TokenInstructions.WRAPPED_SOL_MINT,
-                owner: payer.publicKey
+                owner: payer.publicKey,
             }));
             signers.push(wrappedSolAccount);
         }
-        transaction.add(yield createVaultInstruction(program, salt, vaultSystemStatePublicKey, payer.publicKey, isWrappedSol ? wrappedSolAccount.publicKey : payerTokenAccount, newVaultPublicKey, vaultAssociatedTokenAccount, hedgeStakingPoolPublicKey, feePoolAssociatedUsdhTokenAccount, vaultTypeAccountPublicKey, vaultTypeAccountInfo.collateralMint, history.publicKey, usdhMintPublickey, depositAmount, overrideTime));
+        transaction.add(yield createVaultInstruction(program, salt, payer.publicKey, isWrappedSol ? wrappedSolAccount.publicKey : payerTokenAccount, newVaultPublicKey, vaultAssociatedTokenAccount, hedgeStakingPoolPublicKey, feePoolAssociatedUsdhTokenAccount, vaultTypeAccountPublicKey, vaultTypeAccountInfo.collateralMint, history.publicKey, usdhMintPublickey, depositAmount, overrideTime));
         if (isWrappedSol) {
             transaction.add(serum_1.TokenInstructions.closeAccount({
                 source: wrappedSolAccount.publicKey,
                 destination: payer.publicKey,
-                owner: payer.publicKey
+                owner: payer.publicKey,
             }));
         }
         yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, signers, provider === null || provider === void 0 ? void 0 : provider.opts).catch(Errors_1.parseAnchorErrors);
@@ -63,8 +63,68 @@ function createVault(program, provider, payer, collateralType, depositAmount, ov
     });
 }
 exports.createVault = createVault;
-function createVaultInstruction(program, salt, vaultSystemStatePublicKey, payerPublicKey, payerTokenAccountPublicKey, vaultPublicKey, vaultAssociatedTokenAccount, feePool, feePoolAssociatedUsdhTokenAccount, vaultTypeAccount, collateralMint, historyPublicKey, usdhMintPublickey, depositAmount, overrideTime) {
+function buildCreateVaultTransaction(program, collateralType, depositAmount, overrideTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log("HEDGE SDK: buildCreateVaultTransaction");
+        const usdhMintPublickey = yield (0, Constants_1.getUsdhMintPublicKey)();
+        const payerPublicKey = program.provider.wallet.publicKey;
+        const salt = (0, uuid_1.v4)().substring(0, 8);
+        const newVaultPublicKey = yield (0, Constants_1.findVaultAddress)(salt);
+        const history = web3_js_1.Keypair.generate();
+        const { blockhash } = yield program.provider.connection.getLatestBlockhash();
+        const transaction = new web3_js_1.Transaction({
+            feePayer: payerPublicKey,
+            recentBlockhash: blockhash,
+        });
+        const signers = [history];
+        const wrappedSolAccount = web3_js_1.Keypair.generate();
+        console.log('Lookup getVaultTypeAccountPublicKey', collateralType);
+        // Lookup the vault type info
+        const vaultTypeAccountPublicKey = yield (0, Constants_1.getVaultTypeAccountPublicKey)(collateralType);
+        console.log('Lookup vaultTypeAccountPublicKey', vaultTypeAccountPublicKey.toString());
+        const vaultTypeAccountInfo = yield program.account.vaultType.fetch(vaultTypeAccountPublicKey);
+        console.log('Lookup vaultTypeAccountInfo', vaultTypeAccountInfo);
+        const isWrappedSol = vaultTypeAccountInfo.collateralMint.toString() ===
+            serum_1.TokenInstructions.WRAPPED_SOL_MINT.toString();
+        const payerTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(payerPublicKey, vaultTypeAccountInfo.collateralMint);
+        const vaultAssociatedTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(newVaultPublicKey, vaultTypeAccountInfo.collateralMint);
+        const [hedgeStakingPoolPublicKey] = yield (0, Constants_1.getPoolPublicKeyForMint)(yield (0, Constants_1.getHedgeMintPublicKey)());
+        const feePoolAssociatedUsdhTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(hedgeStakingPoolPublicKey, usdhMintPublickey);
+        console.log('about to start building transaction');
+        // If wrapped SOL collateral, we convert the SOL to wSOL to use in the instruction
+        if (isWrappedSol) {
+            transaction.add(web3_js_1.SystemProgram.createAccount({
+                fromPubkey: payerPublicKey,
+                lamports: depositAmount + 2.04e6,
+                newAccountPubkey: wrappedSolAccount.publicKey,
+                programId: spl_token_1.TOKEN_PROGRAM_ID,
+                space: 165,
+            }), serum_1.TokenInstructions.initializeAccount({
+                account: wrappedSolAccount.publicKey,
+                mint: serum_1.TokenInstructions.WRAPPED_SOL_MINT,
+                owner: payerPublicKey,
+            }));
+            signers.push(wrappedSolAccount);
+        }
+        console.log("hedgeStakingPoolPublicKey", hedgeStakingPoolPublicKey.toString());
+        transaction.add(yield createVaultInstruction(program, salt, payerPublicKey, isWrappedSol ? wrappedSolAccount.publicKey : payerTokenAccount, newVaultPublicKey, vaultAssociatedTokenAccount, hedgeStakingPoolPublicKey, feePoolAssociatedUsdhTokenAccount, vaultTypeAccountPublicKey, vaultTypeAccountInfo.collateralMint, history.publicKey, usdhMintPublickey, depositAmount, overrideTime));
+        if (isWrappedSol) {
+            transaction.add(serum_1.TokenInstructions.closeAccount({
+                source: wrappedSolAccount.publicKey,
+                destination: payerPublicKey,
+                owner: payerPublicKey,
+            }));
+        }
+        transaction.partialSign(wrappedSolAccount);
+        transaction.partialSign(history);
+        console.log("transaction", transaction);
+        return [transaction, signers, newVaultPublicKey];
+    });
+}
+exports.buildCreateVaultTransaction = buildCreateVaultTransaction;
+function createVaultInstruction(program, salt, payerPublicKey, payerTokenAccountPublicKey, vaultPublicKey, vaultAssociatedTokenAccount, feePool, feePoolAssociatedUsdhTokenAccount, vaultTypeAccount, collateralMint, historyPublicKey, usdhMintPublickey, depositAmount, overrideTime) {
     return __awaiter(this, void 0, void 0, function* () {
+        const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
         const ix = program.instruction.createVault(salt, new anchor_1.BN(depositAmount), new anchor_1.BN(overrideTime !== null && overrideTime !== void 0 ? overrideTime : Math.floor(Date.now() / 1000)), // override override time
         {
             accounts: {
@@ -82,9 +142,9 @@ function createVaultInstruction(program, salt, vaultSystemStatePublicKey, payerP
                 systemProgram: web3_js_1.SystemProgram.programId,
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
                 associatedTokenProgram: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
-                rent: web3_js_1.SYSVAR_RENT_PUBKEY
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
             },
-            signers: []
+            signers: [],
         });
         return ix;
     });

package/lib/state/VaultAccount.js

@@ -10,9 +10,12 @@ class VaultAccount {
     constructor(vault, publicKey) {
         this.publicKey = publicKey;
         this.vaultOwner = vault.vaultOwner;
-        this.debt = vault.debt.toNumber();
+        this.pdaSalt = vault.pdaSalt;
         this.deposited = vault.deposited.toNumber();
-        this.minCollateralRatio = (0, HedgeDecimal_1.DecimalFromU128)(vault.minCollateralRatio);
+        this.denormalizedDebt = vault.denormalizedDebt.toNumber();
+        this.debtProductSnapshotBytes = (0, HedgeDecimal_1.DecimalFromU128)(vault.debtProductSnapshotBytes.toString());
+        this.collateralAccumulatorSnapshotBytes = (0, HedgeDecimal_1.DecimalFromU128)(vault.collateralAccumulatorSnapshotBytes.toString());
+        this.collateralType = vault.collateralType;
         this.vaultStatus = Object.keys(vault.vaultStatus)[0];
     }
     /**
@@ -22,7 +25,7 @@ class VaultAccount {
      * @returns true if publicKey matches the owner publicKey
      */
     isOwnedBy(publicKey) {
-        return publicKey.toString() === this.vaultOwner.toString();
+        return publicKey && publicKey.toString() === this.vaultOwner.toString();
     }
     /**
      * Get the collateral value in SOL
@@ -38,7 +41,7 @@ class VaultAccount {
      * @returns debt value in USDH
      */
     inUsd() {
-        return this.debt / web3_js_1.LAMPORTS_PER_SOL;
+        return this.denormalizedDebt / web3_js_1.LAMPORTS_PER_SOL;
     }
     /**
      * Pretty print the vault publickey for easy display

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedge-web3",
-  "version": "0.1.16",
+  "version": "0.1.19",
   "description": "Hedge Javascript Web3 API",
   "main": "lib/index.js",
   "scripts": {

package/src/Constants.ts

@@ -1,7 +1,7 @@
 import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@solana/spl-token'
 import { PublicKey } from '@solana/web3.js'
 
-export const HEDGE_PROGRAM_ID = 'h4sPyjiRvWLquKRULRND9jHCPKqRYZZukvrjMZn21Pz'
+export const HEDGE_PROGRAM_ID = 'h6GZ7ZMB6Jwmj3k4mQZY1bfXMGREEWH47uJHbKvE6nd'
 export const HEDGE_PROGRAM_PUBLICKEY = new PublicKey(HEDGE_PROGRAM_ID)
 
 export const CHAINLINK_SOL_USD_ID = 'FmAmfoyPXiA8Vhhe6MZTr3U6rZfEZ1ctEHay1ysqCqcf'
@@ -43,6 +43,10 @@ export async function getVaultTypeAccountPublicKey (collateralType: string): Pro
   const [vaultTypeAccount] = await PublicKey.findProgramAddress([enc.encode(collateralType), enc.encode('State')], HEDGE_PROGRAM_PUBLICKEY)
   return vaultTypeAccount
 }
+export async function getVaultTypeOracleAccountPublicKey (collateralType: string): Promise<PublicKey> {
+  const [vaultTypeOracleAccount] = await PublicKey.findProgramAddress([enc.encode(collateralType), enc.encode('Oracle')], HEDGE_PROGRAM_PUBLICKEY)
+  return vaultTypeOracleAccount
+}
 export async function findVaultAddress (vaultSalt: string): Promise<PublicKey> {
   const [vaultAddress] = await PublicKey.findProgramAddress([enc.encode('Vault'), enc.encode(vaultSalt)], HEDGE_PROGRAM_PUBLICKEY)
   return vaultAddress

package/src/instructions/createVault.ts

@@ -1,13 +1,34 @@
-import { BN, Program, Provider } from '@project-serum/anchor'
-import { TokenInstructions } from '@project-serum/serum'
-import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID, getOrCreateAssociatedTokenAccount } from '@solana/spl-token'
-import { Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, SYSVAR_RENT_PUBKEY, Transaction, TransactionInstruction } from '@solana/web3.js'
-import { findAssociatedTokenAddress, findVaultAddress, getVaultTypeAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey, getPoolPublicKeyForMint, getHedgeMintPublicKey } from '../Constants'
+import { BN, Idl, Program, Provider } from "@project-serum/anchor";
+import { TokenInstructions } from "@project-serum/serum";
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  TOKEN_PROGRAM_ID,
+  getOrCreateAssociatedTokenAccount,
+} from "@solana/spl-token";
+import {
+  Keypair,
+  PublicKey,
+  sendAndConfirmTransaction,
+  Signer,
+  SystemProgram,
+  SYSVAR_RENT_PUBKEY,
+  Transaction,
+  TransactionInstruction,
+} from "@solana/web3.js";
+import {
+  findAssociatedTokenAddress,
+  findVaultAddress,
+  getVaultTypeAccountPublicKey,
+  getUsdhMintPublicKey,
+  getVaultSystemStatePublicKey,
+  getPoolPublicKeyForMint,
+  getHedgeMintPublicKey,
+} from "../Constants";
 
-import { v4 as uuidv4 } from 'uuid'
-import { parseAnchorErrors } from '../utils/Errors'
+import { v4 as uuidv4 } from "uuid";
+import { parseAnchorErrors } from "../utils/Errors";
 
-export async function createVault (
+export async function createVault(
   program: Program,
   provider: Provider,
   payer: Signer,
@@ -15,34 +36,52 @@ export async function createVault (
   depositAmount: number,
   overrideTime?: number
 ): Promise<PublicKey> {
-  const usdhMintPublickey = await getUsdhMintPublicKey()
+  const usdhMintPublickey = await getUsdhMintPublicKey();
 
-  const salt = uuidv4().substring(0, 8)
-  const newVaultPublicKey = await findVaultAddress(salt)
-  const history = Keypair.generate()
+  const salt = uuidv4().substring(0, 8);
+  const newVaultPublicKey = await findVaultAddress(salt);
+  const history = Keypair.generate();
 
   // Prep the user to get USDH back out at some point
-  await getOrCreateAssociatedTokenAccount(provider.connection, payer, usdhMintPublickey, payer.publicKey)
+  await getOrCreateAssociatedTokenAccount(
+    provider.connection,
+    payer,
+    usdhMintPublickey,
+    payer.publicKey
+  );
 
-  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(collateralType)
-  const vaultTypeAccountInfo = await program.account.vaultType.fetch(vaultTypeAccountPublicKey)
+  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(
+    collateralType
+  );
+  const vaultTypeAccountInfo = await program.account.vaultType.fetch(
+    vaultTypeAccountPublicKey
+  );
 
-  const payerTokenAccount = await findAssociatedTokenAddress(payer.publicKey, vaultTypeAccountInfo.collateralMint)
-  const vaultAssociatedTokenAccount = await findAssociatedTokenAddress(newVaultPublicKey, vaultTypeAccountInfo.collateralMint)
-  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
+  const payerTokenAccount = await findAssociatedTokenAddress(
+    payer.publicKey,
+    vaultTypeAccountInfo.collateralMint
+  );
+  const vaultAssociatedTokenAccount = await findAssociatedTokenAddress(
+    newVaultPublicKey,
+    vaultTypeAccountInfo.collateralMint
+  );
 
-  const wrappedSolAccount = Keypair.generate()
+  const wrappedSolAccount = Keypair.generate();
 
-  const transaction = new Transaction()
-  const signers = [payer, history]
+  const transaction = new Transaction();
+  const signers = [payer, history];
 
-  const isWrappedSol = vaultTypeAccountInfo.collateralMint.toString() === TokenInstructions.WRAPPED_SOL_MINT.toString()
+  const isWrappedSol =
+    vaultTypeAccountInfo.collateralMint.toString() ===
+    TokenInstructions.WRAPPED_SOL_MINT.toString();
 
-  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(await getHedgeMintPublicKey())
+  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(
+    await getHedgeMintPublicKey()
+  );
   const feePoolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(
     hedgeStakingPoolPublicKey,
     usdhMintPublickey
-  )
+  );
 
   if (isWrappedSol) {
     transaction.add(
@@ -51,21 +90,20 @@ export async function createVault (
         lamports: depositAmount + 2.04e6,
         newAccountPubkey: wrappedSolAccount.publicKey,
         programId: TOKEN_PROGRAM_ID,
-        space: 165
+        space: 165,
       }),
       TokenInstructions.initializeAccount({
         account: wrappedSolAccount.publicKey,
         mint: TokenInstructions.WRAPPED_SOL_MINT,
-        owner: payer.publicKey
+        owner: payer.publicKey,
       })
-    )
-    signers.push(wrappedSolAccount)
+    );
+    signers.push(wrappedSolAccount);
   }
   transaction.add(
     await createVaultInstruction(
       program,
       salt,
-      vaultSystemStatePublicKey,
       payer.publicKey,
       isWrappedSol ? wrappedSolAccount.publicKey : payerTokenAccount,
       newVaultPublicKey,
@@ -79,25 +117,141 @@ export async function createVault (
       depositAmount,
       overrideTime
     )
-  )
+  );
   if (isWrappedSol) {
     transaction.add(
       TokenInstructions.closeAccount({
         source: wrappedSolAccount.publicKey,
         destination: payer.publicKey,
-        owner: payer.publicKey
+        owner: payer.publicKey,
+      })
+    );
+  }
+
+  await sendAndConfirmTransaction(
+    provider.connection,
+    transaction,
+    signers,
+    provider?.opts
+  ).catch(parseAnchorErrors);
+  return newVaultPublicKey;
+}
+
+export async function buildCreateVaultTransaction(
+  program: Program,
+  collateralType: string,
+  depositAmount: number,
+  overrideTime?: number
+): Promise<[Transaction, Signer[], PublicKey]> {
+
+  console.log("HEDGE SDK: buildCreateVaultTransaction")
+  const usdhMintPublickey = await getUsdhMintPublicKey();
+  const payerPublicKey = program.provider.wallet.publicKey;
+
+  const salt = uuidv4().substring(0, 8);
+  const newVaultPublicKey = await findVaultAddress(salt);
+  const history = Keypair.generate() as Signer;
+  const { blockhash } = await program.provider.connection.getLatestBlockhash()
+  const transaction = new Transaction({
+    feePayer: payerPublicKey,
+    recentBlockhash: blockhash,
+  })
+  const signers = [history];
+  const wrappedSolAccount = Keypair.generate();
+
+  console.log('Lookup getVaultTypeAccountPublicKey', collateralType)
+
+  // Lookup the vault type info
+  const vaultTypeAccountPublicKey = await getVaultTypeAccountPublicKey(
+    collateralType
+  );
+
+  console.log('Lookup vaultTypeAccountPublicKey', vaultTypeAccountPublicKey.toString())
+
+  const vaultTypeAccountInfo = await program.account.vaultType.fetch(
+    vaultTypeAccountPublicKey
+  );
+  console.log('Lookup vaultTypeAccountInfo', vaultTypeAccountInfo)
+
+  const isWrappedSol =
+    vaultTypeAccountInfo.collateralMint.toString() ===
+    TokenInstructions.WRAPPED_SOL_MINT.toString();
+
+  const payerTokenAccount = await findAssociatedTokenAddress(
+    payerPublicKey,
+    vaultTypeAccountInfo.collateralMint
+  );
+  const vaultAssociatedTokenAccount = await findAssociatedTokenAddress(
+    newVaultPublicKey,
+    vaultTypeAccountInfo.collateralMint
+  );
+
+  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(
+    await getHedgeMintPublicKey()
+  );
+  const feePoolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(
+    hedgeStakingPoolPublicKey,
+    usdhMintPublickey
+  );
+
+  console.log('about to start building transaction')
+
+  // If wrapped SOL collateral, we convert the SOL to wSOL to use in the instruction
+  if (isWrappedSol) {
+    transaction.add(
+      SystemProgram.createAccount({
+        fromPubkey: payerPublicKey,
+        lamports: depositAmount + 2.04e6,
+        newAccountPubkey: wrappedSolAccount.publicKey,
+        programId: TOKEN_PROGRAM_ID,
+        space: 165,
+      }),
+      TokenInstructions.initializeAccount({
+        account: wrappedSolAccount.publicKey,
+        mint: TokenInstructions.WRAPPED_SOL_MINT,
+        owner: payerPublicKey,
       })
+    );
+    signers.push(wrappedSolAccount);
+  }
+  console.log("hedgeStakingPoolPublicKey", hedgeStakingPoolPublicKey.toString())
+  transaction.add(
+    await createVaultInstruction(
+      program,
+      salt,
+      payerPublicKey,
+      isWrappedSol ? wrappedSolAccount.publicKey : payerTokenAccount,
+      newVaultPublicKey,
+      vaultAssociatedTokenAccount,
+      hedgeStakingPoolPublicKey,
+      feePoolAssociatedUsdhTokenAccount,
+      vaultTypeAccountPublicKey,
+      vaultTypeAccountInfo.collateralMint,
+      history.publicKey,
+      usdhMintPublickey,
+      depositAmount,
+      overrideTime
     )
+  );
+  if (isWrappedSol) {
+    transaction.add(
+      TokenInstructions.closeAccount({
+        source: wrappedSolAccount.publicKey,
+        destination: payerPublicKey,
+        owner: payerPublicKey,
+      })
+    );
   }
+  transaction.partialSign(wrappedSolAccount)
+  transaction.partialSign(history)
+  console.log("transaction", transaction)
 
-  await sendAndConfirmTransaction(provider.connection, transaction, signers, provider?.opts).catch(parseAnchorErrors)
-  return newVaultPublicKey
+  return [transaction, signers, newVaultPublicKey];
 }
 
-export async function createVaultInstruction (
+export async function createVaultInstruction(
   program: Program,
   salt: string,
-  vaultSystemStatePublicKey: PublicKey,
   payerPublicKey: PublicKey,
   payerTokenAccountPublicKey: PublicKey,
   vaultPublicKey: PublicKey,
@@ -111,6 +265,8 @@ export async function createVaultInstruction (
   depositAmount: number,
   overrideTime?: number
 ): Promise<TransactionInstruction> {
+  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey();
+
   const ix = program.instruction.createVault(
     salt,
     new BN(depositAmount),
@@ -131,9 +287,10 @@ export async function createVaultInstruction (
         systemProgram: SystemProgram.programId,
         tokenProgram: TOKEN_PROGRAM_ID,
         associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
-        rent: SYSVAR_RENT_PUBKEY
+        rent: SYSVAR_RENT_PUBKEY,
       },
-      signers: []
-    })
-  return ix
+      signers: [],
+    }
+  );
+  return ix;
 }

package/src/state/VaultAccount.ts

@@ -12,14 +12,20 @@ export class VaultAccount {
   /** The public key of the vault owner. */
   vaultOwner: PublicKey
 
-  /** The outstanding debt of the vault (in USDH Lamports). */
-  debt: number
-
+  /** The public key of the vault owner. */
+  pdaSalt: string
+  
   /** The deposited collateral of the vault (in SOL Lamports). */
   deposited: number
 
-  /** The minimum collateral ratio this vault must maintain to not be subject to liquidation. */
-  minCollateralRatio: Decimal
+  /** The outstanding debt of the vault (in USDH Lamports). Denormalized to time 0. */
+  denormalizedDebt: number
+
+  debtProductSnapshotBytes: Decimal
+
+  collateralAccumulatorSnapshotBytes: Decimal
+
+  collateralType: string
 
   /** Current State of the vautl ("Open", "Closed", "Liquidated") */
   vaultStatus: string
@@ -27,9 +33,13 @@ export class VaultAccount {
   constructor (vault: any, publicKey: PublicKey) {
     this.publicKey = publicKey
     this.vaultOwner = vault.vaultOwner
-    this.debt = vault.debt.toNumber()
+    this.pdaSalt = vault.pdaSalt
     this.deposited = vault.deposited.toNumber()
-    this.minCollateralRatio = DecimalFromU128(vault.minCollateralRatio)
+    this.denormalizedDebt = vault.denormalizedDebt.toNumber()
+    this.debtProductSnapshotBytes = DecimalFromU128(vault.debtProductSnapshotBytes.toString())
+    this.collateralAccumulatorSnapshotBytes = DecimalFromU128(vault.collateralAccumulatorSnapshotBytes.toString())
+    this.collateralType = vault.collateralType
+
     this.vaultStatus = Object.keys(vault.vaultStatus)[0]
   }
 
@@ -40,7 +50,8 @@ export class VaultAccount {
    * @returns true if publicKey matches the owner publicKey
    */
   public isOwnedBy (publicKey: PublicKey): boolean {
-    return publicKey.toString() === this.vaultOwner.toString()
+
+    return publicKey && publicKey.toString() === this.vaultOwner.toString()
   }
 
   /**
@@ -58,7 +69,7 @@ export class VaultAccount {
    * @returns debt value in USDH
    */
   public inUsd (): number {
-    return this.debt / LAMPORTS_PER_SOL
+    return this.denormalizedDebt / LAMPORTS_PER_SOL
   }
 
   /**