@carrot-protocol/http-client 0.2.4-add-typings-dev-adbd3c1 → 0.2.4-add-typings-dev-878b388

package/dist/index.d.ts

@@ -0,0 +1,49 @@
+import { web3, BN, AnchorProvider } from "@coral-xyz/anchor";
+import { Vault, VaultPerformance } from "@carrot-protocol/common/src";
+export declare class Client {
+    readonly baseUrl: string;
+    readonly provider: AnchorProvider;
+    private headers;
+    constructor(baseUrl: string, provider: AnchorProvider);
+    index(): Promise<void>;
+    getVault(vault: web3.PublicKey): Promise<Vault>;
+    getVaultPerformance(vault: web3.PublicKey): Promise<VaultPerformance>;
+    getUser(vault: web3.PublicKey): Promise<UserResponse>;
+    issue(vault: web3.PublicKey, assetMint: web3.PublicKey, amount: BN): Promise<string>;
+    redeem(vault: web3.PublicKey, assetMint: web3.PublicKey, amount: BN): Promise<string>;
+    private send;
+}
+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 declare function prepareUnsignedTx(connection: web3.Connection, payer: web3.PublicKey, ixns: web3.TransactionInstruction[], lutAddr?: web3.PublicKey, additionalSigner?: AnchorProvider): Promise<string>;

package/dist/index.js

@@ -0,0 +1,187 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+exports.prepareUnsignedTx = prepareUnsignedTx;
+const cross_fetch_1 = __importDefault(require("cross-fetch"));
+const anchor_1 = require("@coral-xyz/anchor");
+const bs58_1 = require("bs58");
+class Client {
+    constructor(baseUrl, provider) {
+        this.headers = { "Content-Type": "application/json" };
+        this.baseUrl = baseUrl;
+        this.provider = provider;
+    }
+    async index() {
+        const response = await (0, cross_fetch_1.default)(this.baseUrl);
+        checkResponse(response);
+        const body = await response.json();
+        console.log(JSON.stringify(body, undefined, 2));
+    }
+    async getVault(vault) {
+        const url = new URL(`${this.baseUrl}/vault?vault=${vault.toString()}`);
+        const response = await (0, cross_fetch_1.default)(url, {
+            method: "GET",
+            headers: this.headers,
+        });
+        checkResponse(response);
+        const rawBody = await response.json();
+        let body = JSON.parse(JSON.stringify(rawBody));
+        body.address = new anchor_1.web3.PublicKey(body.address);
+        body.authority = new anchor_1.web3.PublicKey(body.authority);
+        body.shares = new anchor_1.web3.PublicKey(body.shares);
+        body.sharesSupply = new anchor_1.BN(body.sharesSupply);
+        body.assets = body.assets.map((asset) => ({
+            ...asset,
+            assetId: Number(asset.assetId),
+            balanceUsd: Number(asset.balanceUsd),
+            mint: new anchor_1.web3.PublicKey(asset.mint),
+            ata: new anchor_1.web3.PublicKey(asset.ata),
+            oracle: new anchor_1.web3.PublicKey(asset.oracle),
+            ataAmount: new anchor_1.BN(asset.ataAmount, "hex"),
+        }));
+        body.strategies = body.strategies.map((strategy) => ({
+            address: new anchor_1.web3.PublicKey(strategy.address),
+            record: {
+                strategyId: Number(strategy.record.strategyId),
+                assetId: Number(strategy.record.assetId),
+                balance: new anchor_1.BN(strategy.record.balance, "hex"),
+                balanceUsd: Number(strategy.record.balanceUsd),
+                netEarnings: new anchor_1.BN(strategy.record.netEarnings, "hex"),
+            },
+            metadata: {
+                ...strategy.metadata,
+                strategyId: Number(strategy.metadata.strategyId),
+                assetMint: new anchor_1.web3.PublicKey(strategy.metadata.assetMint),
+                vault: new anchor_1.web3.PublicKey(strategy.metadata.vault),
+            },
+            strategyType: strategy.strategyType,
+        }));
+        return body;
+    }
+    async getVaultPerformance(vault) {
+        const url = new URL(`${this.baseUrl}/performance?vault=${vault.toString()}`);
+        const response = await (0, cross_fetch_1.default)(url, {
+            method: "GET",
+            headers: this.headers,
+        });
+        checkResponse(response);
+        const rawBody = await response.json();
+        let body = 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 anchor_1.web3.PublicKey(strats.strategy);
+            strats.vaultWeight = Number(strats.vaultWeight);
+            strats.assetMint = new anchor_1.web3.PublicKey(strats.assetMint);
+        }
+        return body;
+    }
+    async getUser(vault) {
+        const url = new URL(`${this.baseUrl}/user?vault=${vault.toString()}&user=${this.provider.publicKey.toString()}`);
+        const response = await (0, cross_fetch_1.default)(url, {
+            method: "GET",
+            headers: this.headers,
+        });
+        checkResponse(response);
+        const body = JSON.parse(JSON.stringify(await response.json()));
+        body.solAmount = new anchor_1.BN(body.solAmount, "hex");
+        body.sharesAmount = new anchor_1.BN(body.sharesAmount, "hex");
+        body.assets = body.assets.map((asset) => ({
+            ...asset,
+            mint: new anchor_1.web3.PublicKey(asset.mint),
+            amount: new anchor_1.BN(asset.amount, "hex"),
+        }));
+        return body;
+    }
+    async issue(vault, assetMint, amount) {
+        const url = new URL(`${this.baseUrl}/issue`);
+        const body = {
+            user: this.provider.publicKey,
+            vault,
+            amount,
+            assetMint,
+        };
+        const response = await (0, cross_fetch_1.default)(url, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(body),
+        });
+        checkResponse(response);
+        const responseBody = await response.json();
+        const issueResponse = JSON.parse(JSON.stringify(responseBody));
+        const txSig = await this.send(issueResponse.tx);
+        return txSig;
+    }
+    async redeem(vault, assetMint, amount) {
+        const url = new URL(`${this.baseUrl}/redeem`);
+        const body = {
+            user: this.provider.publicKey,
+            vault,
+            amount,
+            assetMint,
+        };
+        const response = await (0, cross_fetch_1.default)(url, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(body),
+        });
+        checkResponse(response);
+        const responseBody = await response.json();
+        const redeemResponse = JSON.parse(JSON.stringify(responseBody));
+        const txSig = await this.send(redeemResponse.tx);
+        return txSig;
+    }
+    async send(base64Tx) {
+        const txBytes = Buffer.from(base64Tx, "base64");
+        const tx = anchor_1.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 = {
+            tx: encodedAndSignedTx,
+        };
+        const url = new URL(`${this.baseUrl}/send`);
+        const response = await (0, cross_fetch_1.default)(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 (0, bs58_1.encode)(txSig);
+    }
+}
+exports.Client = Client;
+async function prepareUnsignedTx(connection, payer, ixns, lutAddr, additionalSigner) {
+    const lutAccounts = [];
+    if (lutAddr) {
+        const account = (await connection.getAddressLookupTable(lutAddr)).value;
+        lutAccounts.push(account);
+    }
+    const recentBh = await connection.getLatestBlockhash({
+        commitment: "confirmed",
+    });
+    const msg = new anchor_1.web3.TransactionMessage({
+        payerKey: payer,
+        recentBlockhash: recentBh.blockhash,
+        instructions: ixns,
+    }).compileToV0Message(lutAccounts);
+    const tx = new anchor_1.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) {
+    if (response.status !== 200) {
+        throw new Error(`unexpected http status of ${response.status}`);
+    }
+}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@carrot-protocol/http-client",
-  "version": "0.2.4-add-typings-dev-adbd3c1",
+  "version": "0.2.4-add-typings-dev-878b388",
   "description": "",
-  "main": "index.js",
-  "types": "index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
-    "build": "rm -rf *.tgz && npm i && npm pack",
+    "build": "rm -rf dist node_modules && npm ci && tsc && npm pack",
     "fmt:check": "prettier --check src/",
     "fmt": "prettier --write src/"
   },
@@ -13,7 +13,7 @@
   "license": "ISC",
   "dependencies": {
     "@coral-xyz/anchor": "^0.29.0",
-    "@carrot/common": "file:../common",
+    "@carrot-protocol/common": "0.2.3",
     "bs58": "^5.0.0",
     "cross-fetch": "^4.0.0"
   },

package/src/index.ts

@@ -1,7 +1,7 @@
 import fetch from "cross-fetch";
 import { web3, BN, AnchorProvider } from "@coral-xyz/anchor";
 import { encode } from "bs58";
-import { Vault, VaultPerformance } from "../../common/src";
+import { Vault, VaultPerformance } from "@carrot-protocol/common/src";
 
 export class Client {
   readonly baseUrl: string;

package/tsconfig.json

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