mintbase-sdk 1.0.0

package/README.md

@@ -0,0 +1,67 @@
+# mintbase-sdk
+
+A lightweight npm package for interacting with Mintbase and the NEAR blockchain — mint NFTs, transfer tokens, and query account state with ease.
+
+## Installation
+
+npm install mintbase-sdk
+
+## API & Usage
+
+### `createWallet(accountId: string): Promise<MintbaseWallet>`
+
+import { createWallet } from 'mintbase-sdk';
+
+const wallet = await createWallet('alice.near');
+
+---
+
+### `getAccountState(accountId: string): Promise<NearRpcResult>`
+
+import { getAccountState } from 'mintbase-sdk';
+
+const state = await getAccountState('alice.near');
+
+---
+
+### `mintNFT(params): Promise<NearRpcResult>`
+
+import { mintNFT } from 'mintbase-sdk';
+
+const result = await mintNFT({
+  accountId: 'alice.near',
+  contractId: 'my-store.mintbase1.near',
+  metadata: { title: 'My NFT', description: 'A cool token' },
+  keyPair: wallet.keyPair,
+  networkId: 'mainnet',
+});
+
+---
+
+### `transferNFT(params): Promise<NearRpcResult>`
+
+import { transferNFT } from 'mintbase-sdk';
+
+const result = await transferNFT({
+  accountId: 'alice.near',
+  contractId: 'my-store.mintbase1.near',
+  tokenId: '123',
+  receiverId: 'bob.near',
+  keyPair: wallet.keyPair,
+  networkId: 'mainnet',
+});
+
+---
+
+### `getNFTsForOwner(params): Promise<NearRpcResult>`
+
+import { getNFTsForOwner } from 'mintbase-sdk';
+
+const nfts = await getNFTsForOwner({
+  accountId: 'alice.near',
+  contractId: 'my-store.mintbase1.near',
+});
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,199 @@
+import * as nearApiJs from 'near-api-js';
+import { KeyPair } from 'near-api-js';
+import { PublicKey } from 'near-api-js/lib/utils';
+
+const NEAR_RPC = 'https://rpc.mainnet.near.org';
+const MINTBASE_CONTRACT = 'mintbase1.near';
+
+/** Generated wallet keypair and accountId */
+export interface MintbaseWallet {
+  accountId: string;
+  keyPair: nearApiJs.KeyPair;
+  publicKey: string;
+}
+
+/** NFT token metadata */
+export interface TokenMetadata {
+  title: string;
+  description?: string;
+  media?: string;
+  copies?: number;
+  extra?: string;
+}
+
+/** RPC response shape */
+export interface NearRpcResult {
+  result?: unknown;
+  error?: string;
+}
+
+/**
+ * Creates a new NEAR keypair and returns wallet info for use with SDK functions.
+ */
+export async function createWallet(accountId: string): Promise<MintbaseWallet> {
+  const keyPair = nearApiJs.KeyPair.fromRandom('ed25519');
+  const publicKey = keyPair.getPublicKey().toString();
+  return { accountId, keyPair, publicKey };
+}
+
+/**
+ * Fetches the NEAR account state (balance, storage) via RPC.
+ */
+export async function getAccountState(
+  accountId: string
+): Promise<NearRpcResult> {
+  const body = {
+    jsonrpc: '2.0',
+    id: 'dontcare',
+    method: 'query',
+    params: {
+      request_type: 'view_account',
+      finality: 'final',
+      account_id: accountId,
+    },
+  };
+  const response = await fetch(NEAR_RPC, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  const data = await response.json();
+  if (data.error) return { error: data.error.message ?? JSON.stringify(data.error) };
+  return { result: data.result };
+}
+
+/**
+ * Mints an NFT on a Mintbase store contract using near-api-js functionCall.
+ */
+export async function mintNFT(params: {
+  accountId: string;
+  contractId?: string;
+  metadata: TokenMetadata;
+  keyPair: nearApiJs.KeyPair;
+  networkId?: string;
+}): Promise<NearRpcResult> {
+  const {
+    accountId,
+    contractId = MINTBASE_CONTRACT,
+    metadata,
+    keyPair,
+    networkId = 'mainnet',
+  } = params;
+
+  const keyStore = new nearApiJs.keyStores.InMemoryKeyStore();
+  await keyStore.setKey(networkId, accountId, keyPair);
+
+  const near = await nearApiJs.connect({
+    networkId,
+    keyStore,
+    nodeUrl: NEAR_RPC,
+  });
+
+  const account = await near.account(accountId);
+
+  try {
+    const result = await account.functionCall({
+      contractId,
+      methodName: 'nft_mint',
+      args: {
+        token_id: `token-${Date.now()}`,
+        receiver_id: accountId,
+        token_metadata: metadata,
+      },
+      gas: BigInt('300000000000000'),
+      attachedDeposit: BigInt('7000000000000000000000'),
+    });
+    return { result };
+  } catch (err: unknown) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+}
+
+/**
+ * Transfers an NFT token to a receiver on a Mintbase store contract.
+ */
+export async function transferNFT(params: {
+  accountId: string;
+  contractId?: string;
+  tokenId: string;
+  receiverId: string;
+  keyPair: nearApiJs.KeyPair;
+  networkId?: string;
+}): Promise<NearRpcResult> {
+  const {
+    accountId,
+    contractId = MINTBASE_CONTRACT,
+    tokenId,
+    receiverId,
+    keyPair,
+    networkId = 'mainnet',
+  } = params;
+
+  const keyStore = new nearApiJs.keyStores.InMemoryKeyStore();
+  await keyStore.setKey(networkId, accountId, keyPair);
+
+  const near = await nearApiJs.connect({
+    networkId,
+    keyStore,
+    nodeUrl: NEAR_RPC,
+  });
+
+  const account = await near.account(accountId);
+
+  try {
+    const result = await account.functionCall({
+      contractId,
+      methodName: 'nft_transfer',
+      args: { receiver_id: receiverId, token_id: tokenId },
+      gas: BigInt('30000000000000'),
+      attachedDeposit: BigInt('1'),
+    });
+    return { result };
+  } catch (err: unknown) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+}
+
+/**
+ * Queries NFTs owned by an account from a Mintbase store contract via RPC view call.
+ */
+export async function getNFTsForOwner(params: {
+  accountId: string;
+  contractId?: string;
+}): Promise<NearRpcResult> {
+  const { accountId, contractId = MINTBASE_CONTRACT } = params;
+
+  const args = Buffer.from(
+    JSON.stringify({ account_id: accountId, from_index: '0', limit: 50 })
+  ).toString('base64');
+
+  const body = {
+    jsonrpc: '2.0',
+    id: 'dontcare',
+    method: 'query',
+    params: {
+      request_type: 'call_function',
+      finality: 'final',
+      account_id: contractId,
+      method_name: 'nft_tokens_for_owner',
+      args_base64: args,
+    },
+  };
+
+  const response = await fetch(NEAR_RPC, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  const data = await response.json();
+  if (data.error) return { error: data.error.message ?? JSON.stringify(data.error) };
+
+  try {
+    const decoded = JSON.parse(
+      Buffer.from(data.result.result).toString()
+    );
+    return { result: decoded };
+  } catch {
+    return { result: data.result };
+  }
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "mintbase-sdk",
+  "version": "1.0.0",
+  "description": "npm Package - mintbase-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"
+  ]
+}