@carrot-protocol/http-client 0.2.6-spl1-dev-fee4913 → 0.2.6-spl1-dev-0bcb5aa

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carrot-protocol/http-client",
-  "version": "0.2.6-spl1-dev-fee4913",
+  "version": "0.2.6-spl1-dev-0bcb5aa",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,6 +9,10 @@
     "fmt:check": "prettier --check src/",
     "fmt": "prettier --write src/"
   },
+  "files": [
+    "dist",
+    "package.json"
+  ],
   "author": "",
   "license": "ISC",
   "dependencies": {

package/src/index.ts

@@ -1,297 +0,0 @@
-import fetch from "cross-fetch";
-import { web3, BN, AnchorProvider } from "@coral-xyz/anchor";
-import { encode } from "bs58";
-import { Vault, VaultPerformance } from "@carrot-protocol/common";
-
-export class Client {
-  readonly baseUrl: string;
-  readonly provider: AnchorProvider;
-  private headers = { "Content-Type": "application/json" };
-
-  constructor(baseUrl: string, provider: AnchorProvider) {
-    this.baseUrl = baseUrl;
-    this.provider = provider;
-  }
-
-  async index(): Promise<void> {
-    const response = await fetch(this.baseUrl);
-    checkResponse(response);
-
-    const body = await response.json();
-
-    console.log(JSON.stringify(body, undefined, 2));
-  }
-
-  async getVault(vault: web3.PublicKey): Promise<Vault> {
-    const url = new URL(`${this.baseUrl}/vault?vault=${vault.toString()}`);
-    const response = await fetch(url, {
-      method: "GET",
-      headers: this.headers,
-    });
-    checkResponse(response);
-
-    const rawBody = await response.json();
-
-    let body: Vault = JSON.parse(JSON.stringify(rawBody));
-    body.address = new web3.PublicKey(body.address);
-    body.authority = new web3.PublicKey(body.authority);
-    body.shares = new web3.PublicKey(body.shares);
-    body.sharesSupply = new BN(body.sharesSupply);
-
-    body.assets = body.assets.map((asset) => ({
-      ...asset,
-      assetId: Number(asset.assetId),
-      balanceUsd: Number(asset.balanceUsd),
-      mint: new web3.PublicKey(asset.mint),
-      ata: new web3.PublicKey(asset.ata),
-      oracle: new web3.PublicKey(asset.oracle),
-      ataAmount: new BN(asset.ataAmount, "hex"),
-    }));
-
-    body.strategies = body.strategies.map((strategy) => ({
-      address: new web3.PublicKey(strategy.address),
-      record: {
-        strategyId: Number(strategy.record.strategyId),
-        assetId: Number(strategy.record.assetId),
-        balance: new BN(strategy.record.balance, "hex"),
-        balanceUsd: Number(strategy.record.balanceUsd),
-        netEarnings: new BN(strategy.record.netEarnings, "hex"),
-      },
-      metadata: {
-        ...strategy.metadata,
-        strategyId: Number(strategy.metadata.strategyId),
-        assetMint: new web3.PublicKey(strategy.metadata.assetMint),
-        vault: new web3.PublicKey(strategy.metadata.vault),
-      },
-      strategyType: strategy.strategyType,
-    }));
-
-    return body;
-  }
-
-  async getVaultPerformance(vault: web3.PublicKey): Promise<VaultPerformance> {
-    const url = new URL(
-      `${this.baseUrl}/performance?vault=${vault.toString()}`,
-    );
-
-    const response = await fetch(url, {
-      method: "GET",
-      headers: this.headers,
-    });
-    checkResponse(response);
-
-    const rawBody = await response.json();
-
-    let body: VaultPerformance = JSON.parse(JSON.stringify(rawBody));
-    body.apy = Number(body.apy);
-
-    for (let strats of body.strategyAPY) {
-      strats.apy = Number(strats.apy);
-      strats.balanceUsd = Number(strats.balanceUsd);
-      strats.strategy = new web3.PublicKey(strats.strategy);
-      strats.vaultWeight = Number(strats.vaultWeight);
-      strats.assetMint = new web3.PublicKey(strats.assetMint);
-    }
-
-    return body;
-  }
-
-  async getUser(vault: web3.PublicKey): Promise<UserResponse> {
-    const url = new URL(
-      `${this.baseUrl}/user?vault=${vault.toString()}&user=${this.provider.publicKey.toString()}`,
-    );
-
-    const response = await fetch(url, {
-      method: "GET",
-      headers: this.headers,
-    });
-
-    checkResponse(response);
-
-    const body: UserResponse = JSON.parse(
-      JSON.stringify(await response.json()),
-    );
-    body.solAmount = new BN(body.solAmount, "hex");
-    body.sharesAmount = new BN(body.sharesAmount, "hex");
-
-    body.assets = body.assets.map((asset) => ({
-      ...asset,
-      mint: new web3.PublicKey(asset.mint),
-      amount: new BN(asset.amount, "hex"),
-    }));
-
-    return body;
-  }
-
-  async issue(
-    vault: web3.PublicKey,
-    assetMint: web3.PublicKey,
-    amount: BN,
-  ): Promise<string> {
-    const url = new URL(`${this.baseUrl}/issue`);
-
-    const body: IssueRequest = {
-      user: this.provider.publicKey,
-      vault,
-      amount,
-      assetMint,
-    };
-
-    const response = await fetch(url, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify(body),
-    });
-
-    checkResponse(response);
-
-    const responseBody = await response.json();
-
-    const issueResponse: IssueResponse = JSON.parse(
-      JSON.stringify(responseBody),
-    );
-
-    const txSig = await this.send(issueResponse.tx);
-
-    return txSig;
-  }
-
-  async redeem(vault: web3.PublicKey, assetMint: web3.PublicKey, amount: BN) {
-    const url = new URL(`${this.baseUrl}/redeem`);
-
-    const body: RedeemRequest = {
-      user: this.provider.publicKey,
-      vault,
-      amount,
-      assetMint,
-    };
-
-    const response = await fetch(url, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify(body),
-    });
-
-    checkResponse(response);
-
-    const responseBody = await response.json();
-
-    const redeemResponse: RedeemResponse = JSON.parse(
-      JSON.stringify(responseBody),
-    );
-
-    const txSig = await this.send(redeemResponse.tx);
-
-    return txSig;
-  }
-
-  private async send(base64Tx: string): Promise<string> {
-    const txBytes = Buffer.from(base64Tx, "base64");
-    const tx = web3.VersionedTransaction.deserialize(new Uint8Array(txBytes));
-    const signedTx = await this.provider.wallet.signTransaction(tx);
-    const txSig = signedTx.signatures[0];
-
-    const encodedAndSignedTx = Buffer.from(signedTx.serialize()).toString(
-      "base64",
-    );
-
-    const sendRequest: SendRequest = {
-      tx: encodedAndSignedTx,
-    };
-
-    const url = new URL(`${this.baseUrl}/send`);
-
-    const response = await fetch(url, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify(sendRequest),
-    });
-
-    checkResponse(response);
-
-    if (response.status !== 200) {
-      throw new Error(`unexpected http status of ${response.status}`);
-    }
-
-    return encode(txSig);
-  }
-}
-
-export interface SendRequest {
-  tx: string;
-}
-
-export interface RedeemRequest {
-  vault: web3.PublicKey;
-  assetMint: web3.PublicKey;
-  amount: BN;
-  user: web3.PublicKey;
-}
-
-export interface IssueRequest {
-  vault: web3.PublicKey;
-  assetMint: web3.PublicKey;
-  amount: BN;
-  user: web3.PublicKey;
-}
-
-export interface RedeemResponse {
-  tx: string;
-}
-
-export interface IssueResponse {
-  tx: string;
-}
-
-export interface UserResponse {
-  solAmount: BN;
-  solAmountUi: number;
-  sharesAmount: BN;
-  sharesAmountUi: number;
-  assets: UserAssetBalance[];
-}
-
-export interface UserAssetBalance {
-  mint: web3.PublicKey;
-  amount: BN;
-  amountUi: number;
-}
-
-export async function prepareUnsignedTx(
-  connection: web3.Connection,
-  payer: web3.PublicKey,
-  ixns: web3.TransactionInstruction[],
-  lutAddr?: web3.PublicKey,
-  additionalSigner?: AnchorProvider,
-): Promise<string> {
-  const lutAccounts: web3.AddressLookupTableAccount[] = [];
-  if (lutAddr) {
-    const account = (await connection.getAddressLookupTable(lutAddr)).value!;
-    lutAccounts.push(account);
-  }
-
-  const recentBh = await connection.getLatestBlockhash({
-    commitment: "confirmed",
-  });
-
-  const msg = new web3.TransactionMessage({
-    payerKey: payer,
-    recentBlockhash: recentBh.blockhash,
-    instructions: ixns,
-  }).compileToV0Message(lutAccounts);
-
-  const tx = new web3.VersionedTransaction(msg);
-  let base64Tx = Buffer.from(tx.serialize()).toString("base64");
-  if (additionalSigner) {
-    const signedTx = await additionalSigner.wallet.signTransaction(tx);
-    base64Tx = Buffer.from(signedTx.serialize()).toString("base64");
-  }
-
-  return base64Tx;
-}
-
-function checkResponse(response: Response): void {
-  if (response.status !== 200) {
-    throw new Error(`unexpected http status of ${response.status}`);
-  }
-}

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "declaration": true,
-    "module": "commonjs",
-    "target": "es2020",
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "strict": true
-  },
-  "include": ["src/**/*"]
-}