jumbo-exchange-sdk 1.0.0

package/README.md

@@ -0,0 +1,67 @@
+# jumbo-exchange-sdk
+
+SDK for interacting with the Jumbo Exchange on NEAR Protocol.
+
+## Installation
+
+npm install jumbo-exchange-sdk
+
+## Usage
+
+### Get Configuration
+
+import { getConfig } from 'jumbo-exchange-sdk';
+
+const config = getConfig({ networkId: 'mainnet' });
+
+### Get Pool Info
+
+import { getPool } from 'jumbo-exchange-sdk';
+
+const pool = await getPool(42);
+// with config override
+const pool = await getPool(42, { networkId: 'testnet' });
+
+### Get Token Balance
+
+import { getTokenBalance } from 'jumbo-exchange-sdk';
+
+const balance = await getTokenBalance(
+  'token.near',
+  'myaccount.near'
+);
+
+### Swap Tokens
+
+import { swap } from 'jumbo-exchange-sdk';
+
+const result = await swap({
+  tokenIn: 'token-a.near',
+  tokenOut: 'token-b.near',
+  amountIn: '1000000',
+  minAmountOut: '990000',
+});
+
+### Add Liquidity
+
+import { addLiquidity } from 'jumbo-exchange-sdk';
+
+const result = await addLiquidity(
+  42,
+  ['1000000', '2000000'],
+  account
+);
+
+## API
+
+| Function | Description |
+|---|---|
+| `getConfig(overrides?)` | Returns full resolved config |
+| `getPool(poolId, config?)` | Fetches pool info by ID |
+| `getTokenBalance(tokenId, accountId, config?)` | Fetches token balance for an account |
+| `swap(params, config?)` | Executes a token swap |
+| `addLiquidity(poolId, amounts, account, config?)` | Adds liquidity to a pool |
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,194 @@
+import * as nearApiJs from 'near-api-js';
+
+/** Configuration for Jumbo Exchange SDK */
+export interface JumboConfig {
+  networkId?: string;
+  nodeUrl?: string;
+  contractId?: string;
+}
+
+/** Swap parameters */
+export interface SwapParams {
+  tokenIn: string;
+  tokenOut: string;
+  amountIn: string;
+  minAmountOut: string;
+  account: nearApiJs.Account;
+}
+
+/** Pool info returned from Jumbo */
+export interface PoolInfo {
+  id: number;
+  tokenIds: string[];
+  amounts: string[];
+  totalFee: number;
+  sharesTotalSupply: string;
+}
+
+/** Token balance result */
+export interface TokenBalance {
+  token: string;
+  balance: string;
+  decimals: number;
+}
+
+/** Transaction result */
+export interface TxResult {
+  transactionHash: string;
+  status: string;
+}
+
+const DEFAULT_CONTRACT = 'v1.jumbo_exchange.near';
+const DEFAULT_RPC = 'https://rpc.mainnet.near.org';
+
+/** Returns default Jumbo config merged with provided overrides */
+export function getConfig(overrides: JumboConfig = {}): Required<JumboConfig> {
+  return {
+    networkId: overrides.networkId ?? 'mainnet',
+    nodeUrl: overrides.nodeUrl ?? DEFAULT_RPC,
+    contractId: overrides.contractId ?? DEFAULT_CONTRACT,
+  };
+}
+
+/**
+ * Fetches pool information by pool ID from Jumbo Exchange.
+ */
+export async function getPool(
+  poolId: number,
+  config: JumboConfig = {}
+): Promise<PoolInfo> {
+  const { nodeUrl, contractId } = getConfig(config);
+  const args = Buffer.from(JSON.stringify({ pool_id: poolId })).toString('base64');
+  const response = await fetch(nodeUrl, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 'jumbo-sdk',
+      method: 'query',
+      params: {
+        request_type: 'call_function',
+        finality: 'final',
+        account_id: contractId,
+        method_name: 'get_pool',
+        args_base64: args,
+      },
+    }),
+  });
+  const json = await response.json();
+  if (json.error) throw new Error(json.error.message ?? 'RPC error');
+  const result: PoolInfo = JSON.parse(
+    Buffer.from(json.result.result).toString()
+  );
+  return result;
+}
+
+/**
+ * Returns the token balance of an account for a given NEP-141 token.
+ */
+export async function getTokenBalance(
+  tokenId: string,
+  accountId: string,
+  config: JumboConfig = {}
+): Promise<TokenBalance> {
+  const { nodeUrl } = getConfig(config);
+  const args = Buffer.from(JSON.stringify({ account_id: accountId })).toString('base64');
+  const response = await fetch(nodeUrl, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 'jumbo-sdk',
+      method: 'query',
+      params: {
+        request_type: 'call_function',
+        finality: 'final',
+        account_id: tokenId,
+        method_name: 'ft_balance_of',
+        args_base64: args,
+      },
+    }),
+  });
+  const json = await response.json();
+  if (json.error) throw new Error(json.error.message ?? 'RPC error');
+  const balance: string = JSON.parse(Buffer.from(json.result.result).toString());
+
+  const metaArgs = Buffer.from('{}').toString('base64');
+  const metaResponse = await fetch(nodeUrl, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 'jumbo-sdk-meta',
+      method: 'query',
+      params: {
+        request_type: 'call_function',
+        finality: 'final',
+        account_id: tokenId,
+        method_name: 'ft_metadata',
+        args_base64: metaArgs,
+      },
+    }),
+  });
+  const metaJson = await metaResponse.json();
+  const meta = JSON.parse(Buffer.from(metaJson.result.result).toString());
+  return { token: tokenId, balance, decimals: meta.decimals };
+}
+
+/**
+ * Executes a token swap on Jumbo Exchange using near-api-js Account.
+ */
+export async function swap(params: SwapParams, config: JumboConfig = {}): Promise<TxResult> {
+  const { contractId } = getConfig(config);
+  const { tokenIn, tokenOut, amountIn, minAmountOut, account } = params;
+
+  const actions = [
+    {
+      pool_id: 0,
+      token_in: tokenIn,
+      token_out: tokenOut,
+      amount_in: amountIn,
+      min_amount_out: minAmountOut,
+    },
+  ];
+
+  const outcome = await account.functionCall({
+    contractId: tokenIn,
+    methodName: 'ft_transfer_call',
+    args: {
+      receiver_id: contractId,
+      amount: amountIn,
+      msg: JSON.stringify({ force: 0, actions }),
+    },
+    gas: '100000000000000',
+    attachedDeposit: '1',
+  });
+
+  return {
+    transactionHash: outcome.transaction.hash,
+    status: Object.keys(outcome.status)[0],
+  };
+}
+
+/**
+ * Adds liquidity to a Jumbo pool using near-api-js Account.
+ */
+export async function addLiquidity(
+  poolId: number,
+  amounts: string[],
+  account: nearApiJs.Account,
+  config: JumboConfig = {}
+): Promise<TxResult> {
+  const { contractId } = getConfig(config);
+  const outcome = await account.functionCall({
+    contractId,
+    methodName: 'add_liquidity',
+    args: { pool_id: poolId, amounts },
+    gas: '100000000000000',
+    attachedDeposit: '970000000000000000000',
+  });
+  return {
+    transactionHash: outcome.transaction.hash,
+    status: Object.keys(outcome.status)[0],
+  };
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "jumbo-exchange-sdk",
+  "version": "1.0.0",
+  "description": "npm Package - jumbo-exchange-sdk",
+  "main": "index.js",
+  "scripts": {
+    "test": "jest --passWithNoTests"
+  },
+  "keywords": [
+    "near",
+    "blockchain",
+    "web3"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "near-api-js": "^4.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0",
+    "jest": "^29.0.0",
+    "@types/jest": "^29.0.0",
+    "ts-jest": "^29.0.0"
+  },
+  "files": [
+    "dist/**/*",
+    "README.md"
+  ]
+}