near-account-utils-sdk 1.0.7855

package/README.md

@@ -0,0 +1,65 @@
+# near-account-utils
+
+Utility functions for interacting with NEAR Protocol accounts and smart contracts.
+
+## Installation
+
+npm install near-account-utils
+
+## API & Usage
+
+### `getAccountInfo(accountId)`
+
+Fetch on-chain account details.
+
+import { getAccountInfo } from 'near-account-utils';
+
+const info = await getAccountInfo('alice.near');
+// { amount, code_hash, storage_usage, block_height }
+
+### `accountExists(accountId)`
+
+Check whether an account exists on-chain.
+
+import { accountExists } from 'near-account-utils';
+
+const exists = await accountExists('alice.near'); // true | false
+
+### `generateKeyPair()`
+
+Generate a new NEAR key pair and its derived implicit account ID.
+
+import { generateKeyPair } from 'near-account-utils';
+
+const { publicKey, secretKey, implicitAccountId } = await generateKeyPair();
+
+### `viewFunction(contractId, methodName, args)`
+
+Call a read-only contract method.
+
+import { viewFunction } from 'near-account-utils';
+
+const result = await viewFunction('contract.near', 'get_balance', { account_id: 'alice.near' });
+
+### `callFunction(signerAccountId, contractId, methodName, args, options)`
+
+Execute a state-changing contract method.
+
+import { callFunction } from 'near-account-utils';
+
+const outcome = await callFunction(
+  'alice.near',
+  'contract.near',
+  'transfer',
+  { receiver_id: 'bob.near', amount: '100' },
+  {
+    keyPair: myKeyPair,
+    attachedDeposit: '1000000000000000000000000',
+    gas: '30000000000000',
+    networkId: 'mainnet',
+  }
+);
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,121 @@
+import * as nearApiJs from 'near-api-js';
+
+const RPC_URL = 'https://rpc.mainnet.near.org';
+
+/** Fetches basic account info (balance, code_hash, storage) for a NEAR account */
+export async function getAccountInfo(accountId: string): Promise<{
+  amount: string;
+  code_hash: string;
+  storage_usage: number;
+  block_height: number;
+}> {
+  const response = await fetch(RPC_URL, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 'near-account-utils',
+      method: 'query',
+      params: {
+        request_type: 'view_account',
+        finality: 'final',
+        account_id: accountId,
+      },
+    }),
+  });
+  const data = await response.json();
+  if (data.error) throw new Error(data.error.data ?? data.error.message);
+  return {
+    amount: data.result.amount,
+    code_hash: data.result.code_hash,
+    storage_usage: data.result.storage_usage,
+    block_height: data.result.block_height,
+  };
+}
+
+/** Checks whether a NEAR account exists on-chain */
+export async function accountExists(accountId: string): Promise<boolean> {
+  try {
+    await getAccountInfo(accountId);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Generates a new random ed25519 keypair; returns publicKey, secretKey, and an implicit accountId */
+export async function generateKeyPair(): Promise<{
+  publicKey: string;
+  secretKey: string;
+  implicitAccountId: string;
+}> {
+  const keyPair = nearApiJs.KeyPair.fromRandom('ed25519');
+  const publicKey = keyPair.getPublicKey().toString();
+  const secretKey = (keyPair as nearApiJs.KeyPairEd25519).secretKey ?? keyPair.toString();
+  // Implicit account id = hex of the raw public key bytes
+  const rawBytes = keyPair.getPublicKey().data;
+  const implicitAccountId = Buffer.from(rawBytes).toString('hex');
+  return { publicKey, secretKey, implicitAccountId };
+}
+
+/** Calls a read-only (view) function on a NEAR smart contract */
+export async function viewFunction(
+  contractId: string,
+  methodName: string,
+  args: Record<string, unknown> = {}
+): Promise<unknown> {
+  const argsBase64 = Buffer.from(JSON.stringify(args)).toString('base64');
+  const response = await fetch(RPC_URL, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 'near-account-utils',
+      method: 'query',
+      params: {
+        request_type: 'call_function',
+        finality: 'final',
+        account_id: contractId,
+        method_name: methodName,
+        args_base64: argsBase64,
+      },
+    }),
+  });
+  const data = await response.json();
+  if (data.error) throw new Error(data.error.data ?? data.error.message);
+  const resultBytes: number[] = data.result.result;
+  return JSON.parse(Buffer.from(resultBytes).toString('utf8'));
+}
+
+/** Calls a state-changing function on a NEAR contract using near-api-js Account */
+export async function callFunction(
+  signerAccountId: string,
+  contractId: string,
+  methodName: string,
+  args: Record<string, unknown>,
+  options: {
+    keyPair: nearApiJs.KeyPair;
+    attachedDeposit?: string;
+    gas?: string;
+    networkId?: string;
+  }
+): Promise<nearApiJs.providers.FinalExecutionOutcome> {
+  const networkId = options.networkId ?? 'mainnet';
+  const keyStore = new nearApiJs.keyStores.InMemoryKeyStore();
+  await keyStore.setKey(networkId, signerAccountId, options.keyPair);
+
+  const near = await nearApiJs.connect({
+    networkId,
+    keyStore,
+    nodeUrl: RPC_URL,
+  });
+
+  const account = await near.account(signerAccountId);
+  return account.functionCall({
+    contractId,
+    methodName,
+    args,
+    gas: BigInt(options.gas ?? '30000000000000'),
+    attachedDeposit: BigInt(options.attachedDeposit ?? '0'),
+  });
+}

package/package.json

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