@scalecrx/sdk 0.4.0

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { Scale } from "./scale";
+export { ScaleAmm, ScaleSdkError } from "./scaleAmm";
+export { ScaleVmm } from "./scaleVmm";
+export { AMM_ADDRESS, VMM_ADDRESS, CLUSTER_RPC_URLS } from "./constants";
+export * from "./types";

package/dist/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLUSTER_RPC_URLS = exports.VMM_ADDRESS = exports.AMM_ADDRESS = exports.ScaleVmm = exports.ScaleSdkError = exports.ScaleAmm = exports.Scale = void 0;
+var scale_1 = require("./scale");
+Object.defineProperty(exports, "Scale", { enumerable: true, get: function () { return scale_1.Scale; } });
+var scaleAmm_1 = require("./scaleAmm");
+Object.defineProperty(exports, "ScaleAmm", { enumerable: true, get: function () { return scaleAmm_1.ScaleAmm; } });
+Object.defineProperty(exports, "ScaleSdkError", { enumerable: true, get: function () { return scaleAmm_1.ScaleSdkError; } });
+var scaleVmm_1 = require("./scaleVmm");
+Object.defineProperty(exports, "ScaleVmm", { enumerable: true, get: function () { return scaleVmm_1.ScaleVmm; } });
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "AMM_ADDRESS", { enumerable: true, get: function () { return constants_1.AMM_ADDRESS; } });
+Object.defineProperty(exports, "VMM_ADDRESS", { enumerable: true, get: function () { return constants_1.VMM_ADDRESS; } });
+Object.defineProperty(exports, "CLUSTER_RPC_URLS", { enumerable: true, get: function () { return constants_1.CLUSTER_RPC_URLS; } });
+__exportStar(require("./types"), exports);

package/dist/scale.d.ts

@@ -0,0 +1,35 @@
+import { AnchorProvider, Idl, Program, Wallet } from "@coral-xyz/anchor";
+import { Connection, PublicKey } from "@solana/web3.js";
+import { ScaleAmm } from "./scaleAmm";
+import { ScaleVmm } from "./scaleVmm";
+import { ScaleCluster } from "./constants";
+export type ScaleOptions = {
+    ammProgramId?: PublicKey;
+    vmmProgramId?: PublicKey;
+    ammIdl?: Idl;
+    vmmIdl?: Idl;
+    programId?: PublicKey;
+    idl?: Idl;
+    providerOptions?: ConstructorParameters<typeof AnchorProvider>[2];
+};
+export declare class Scale {
+    readonly connection: Connection;
+    readonly wallet: Wallet;
+    readonly hasWallet: boolean;
+    readonly provider: AnchorProvider;
+    readonly ammIdl: Idl;
+    readonly vmmIdl: Idl;
+    readonly ammProgramId: PublicKey;
+    readonly vmmProgramId: PublicKey;
+    readonly amm: ScaleAmm;
+    readonly vmm: ScaleVmm;
+    constructor(connection: Connection, wallet: Wallet, options?: ScaleOptions);
+    constructor(rpcUrl: string, wallet?: Wallet, options?: ScaleOptions);
+    constructor(cluster: ScaleCluster, wallet?: Wallet, options?: ScaleOptions);
+    loadAmm(programId?: PublicKey, idlOverride?: Idl): ScaleAmm;
+    loadVmm(programId?: PublicKey, idlOverride?: Idl): ScaleVmm;
+    load(programId?: PublicKey, idlOverride?: Idl): ScaleAmm;
+}
+export declare const createAmmProgram: (provider: AnchorProvider, programId: PublicKey, idlOverride?: Idl) => Program<Idl>;
+export declare const createVmmProgram: (provider: AnchorProvider, programId: PublicKey, idlOverride?: Idl) => Program<Idl>;
+export declare const createScaleProgram: (provider: AnchorProvider, programId: PublicKey, idlOverride?: Idl) => Program<Idl>;

package/dist/scale.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createScaleProgram = exports.createVmmProgram = exports.createAmmProgram = exports.Scale = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const scaleAmm_1 = require("./scaleAmm");
+const scaleVmm_1 = require("./scaleVmm");
+const scale_amm_json_1 = __importDefault(require("./idl/scale_amm.json"));
+const scale_vmm_json_1 = __importDefault(require("./idl/scale_vmm.json"));
+const constants_1 = require("./constants");
+class ReadonlyWallet {
+    constructor(publicKey = web3_js_1.Keypair.generate().publicKey) {
+        this.publicKey = publicKey;
+        this.payer = web3_js_1.Keypair.generate();
+    }
+    async signTransaction(_tx) {
+        throw new Error("No wallet was provided. Use a constructor overload with wallet for direct execution.");
+    }
+    async signAllTransactions(_txs) {
+        throw new Error("No wallet was provided. Use a constructor overload with wallet for direct execution.");
+    }
+}
+class Scale {
+    constructor(connectionOrRpcOrCluster, wallet, options = {}) {
+        const connection = connectionOrRpcOrCluster instanceof web3_js_1.Connection
+            ? connectionOrRpcOrCluster
+            : new web3_js_1.Connection(connectionOrRpcOrCluster === "mainnet" ||
+                connectionOrRpcOrCluster === "devnet"
+                ? constants_1.CLUSTER_RPC_URLS[connectionOrRpcOrCluster]
+                : connectionOrRpcOrCluster, options.providerOptions?.commitment ?? "confirmed");
+        const resolvedWallet = wallet ?? new ReadonlyWallet();
+        this.connection = connection;
+        this.wallet = resolvedWallet;
+        this.hasWallet = Boolean(wallet);
+        this.provider = new anchor_1.AnchorProvider(connection, resolvedWallet, options.providerOptions);
+        this.ammIdl = options.ammIdl ?? options.idl ?? scale_amm_json_1.default;
+        this.vmmIdl = options.vmmIdl ?? scale_vmm_json_1.default;
+        this.ammProgramId =
+            options.ammProgramId ??
+                options.programId ??
+                constants_1.AMM_ADDRESS;
+        this.vmmProgramId =
+            options.vmmProgramId ??
+                constants_1.VMM_ADDRESS;
+        this.amm = new scaleAmm_1.ScaleAmm(this.provider, this.ammProgramId, this.ammIdl, this.hasWallet);
+        this.vmm = new scaleVmm_1.ScaleVmm(this.provider, this.vmmProgramId, this.vmmIdl, this.ammProgramId, this.hasWallet);
+    }
+    loadAmm(programId = this.ammProgramId, idlOverride) {
+        const resolvedIdl = idlOverride ?? this.ammIdl;
+        return new scaleAmm_1.ScaleAmm(this.provider, programId, resolvedIdl, this.hasWallet);
+    }
+    loadVmm(programId = this.vmmProgramId, idlOverride) {
+        const resolvedIdl = idlOverride ?? this.vmmIdl;
+        return new scaleVmm_1.ScaleVmm(this.provider, programId, resolvedIdl, this.ammProgramId, this.hasWallet);
+    }
+    load(programId = this.ammProgramId, idlOverride) {
+        return this.loadAmm(programId, idlOverride);
+    }
+}
+exports.Scale = Scale;
+const createAmmProgram = (provider, programId, idlOverride) => {
+    const resolvedIdl = idlOverride ?? scale_amm_json_1.default;
+    const idlWithAddress = {
+        ...resolvedIdl,
+        address: programId.toBase58(),
+    };
+    return new anchor_1.Program(idlWithAddress, provider);
+};
+exports.createAmmProgram = createAmmProgram;
+const createVmmProgram = (provider, programId, idlOverride) => {
+    const resolvedIdl = idlOverride ?? scale_vmm_json_1.default;
+    const idlWithAddress = {
+        ...resolvedIdl,
+        address: programId.toBase58(),
+    };
+    return new anchor_1.Program(idlWithAddress, provider);
+};
+exports.createVmmProgram = createVmmProgram;
+exports.createScaleProgram = exports.createAmmProgram;

package/dist/scaleAmm.d.ts

@@ -0,0 +1,68 @@
+import { AnchorProvider, BN, Idl, Program } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+import { CreatePoolOptions, CreatePoolParamsInput, CreatePoolInstructionResult, CurveTypeInput, CreatePoolWithDevBuyInstructionResult, EstimateResult, PoolAddress, PoolRef, SwapInstructionResult, SwapOptions, SwapParamsInput } from "./types";
+import { ScaleSdkError } from "./errors";
+export type PoolAccount = {
+    enabled: boolean;
+    owner: PublicKey;
+    mintA: PublicKey;
+    mintB: PublicKey;
+    tokenAReserves: BN;
+    tokenBReserves: BN;
+    shift: BN;
+    curve: CurveTypeInput;
+    bump: number;
+    feeBeneficiaryCount: number;
+    feeBeneficiaries: Array<{
+        wallet: PublicKey;
+        shareBps: number;
+    }>;
+};
+export declare class ScaleAmm {
+    readonly provider: AnchorProvider;
+    readonly programId: PublicKey;
+    readonly program: Program;
+    readonly idl: Idl;
+    readonly idlErrors: Map<number, string>;
+    readonly hasWallet: boolean;
+    constructor(provider: AnchorProvider, programId: PublicKey, idlOverride?: Idl, hasWallet?: boolean);
+    getConfigAddress(): PublicKey;
+    getPoolAddress(owner: PublicKey, mintA: PublicKey, mintB: PublicKey): PublicKey;
+    getVaultAddress(pool: PublicKey, mint: PublicKey): PublicKey;
+    getPlatformConfig(): Promise<any>;
+    getPlatformBaseToken(): Promise<PublicKey | null>;
+    getFeeBeneficiaries(poolInput: PoolAddress | PoolRef): Promise<{
+        wallet: PublicKey;
+        shareBps: number;
+    }[]>;
+    getFeeShare(poolInput: PoolAddress | PoolRef, wallet: PublicKey): Promise<number>;
+    getTotalCreatorFeeBps(poolInput: PoolAddress | PoolRef): Promise<number>;
+    getPool(poolOrAddress: PoolAddress | PoolRef): Promise<PoolRef & {
+        data: PoolAccount;
+    }>;
+    getPoolByAddress(pool: PublicKey): Promise<PoolRef & {
+        data: PoolAccount;
+    }>;
+    getPoolByMints(owner: PublicKey, mintA: PublicKey, mintB: PublicKey): Promise<PoolRef & {
+        data: PoolAccount;
+    }>;
+    createPool(params: CreatePoolParamsInput, mintA: PublicKey, mintB: PublicKey, options?: CreatePoolOptions): Promise<{
+        pool: PublicKey;
+        vaultA: PublicKey;
+        vaultB: PublicKey;
+        signature: string;
+    }>;
+    createPoolInstructions(params: CreatePoolParamsInput, mintA: PublicKey, mintB: PublicKey, options?: CreatePoolOptions): Promise<CreatePoolInstructionResult>;
+    createWithDevBuyInstructions(params: CreatePoolParamsInput, mintA: PublicKey, mintB: PublicKey, buyParams: SwapParamsInput, options?: (CreatePoolOptions & SwapOptions)): Promise<CreatePoolWithDevBuyInstructionResult>;
+    buy(poolInput: PoolAddress | PoolRef, params: SwapParamsInput, options?: SwapOptions): Promise<string>;
+    sell(poolInput: PoolAddress | PoolRef, params: SwapParamsInput, options?: SwapOptions): Promise<string>;
+    buyInstructions(poolInput: PoolAddress | PoolRef, params: SwapParamsInput, options?: SwapOptions): Promise<SwapInstructionResult>;
+    sellInstructions(poolInput: PoolAddress | PoolRef, params: SwapParamsInput, options?: SwapOptions): Promise<SwapInstructionResult>;
+    estimateBuy(poolInput: PoolAddress | PoolRef, params: SwapParamsInput): Promise<EstimateResult>;
+    estimateSell(poolInput: PoolAddress | PoolRef, params: SwapParamsInput): Promise<EstimateResult>;
+    private estimate;
+    private resolvePool;
+    private swapInstructions;
+    private sendTransaction;
+}
+export { ScaleSdkError };