near-encoding 1.0.0 → 1.1.9071

package/README.md

@@ -1,57 +1,58 @@
 # near-encoding
 
-A utility package for encoding, decoding, and interacting with NEAR smart contracts.
+Utility functions for encoding, decoding, and interacting with the NEAR blockchain.
 
 ## Installation
 
 npm install near-encoding
 
-## API & Usage
+## Usage
 
-### `encodeBase64(input: string): string`
+### Base64 Encoding / Decoding
 
-Encodes a UTF-8 string to Base64.
-
-import { encodeBase64 } from 'near-encoding';
+import { encodeBase64, decodeBase64 } from 'near-encoding';
 
 const encoded = encodeBase64('hello world');
+// "aGVsbG8gd29ybGQ="
 
-### `decodeBase64(input: string): string`
-
-Decodes a Base64 string back to UTF-8.
+const decoded = decodeBase64(encoded);
+// "hello world"
 
-import { decodeBase64 } from 'near-encoding';
+### Encoding / Decoding Contract Arguments
 
-const decoded = decodeBase64('aGVsbG8gd29ybGQ=');
+import { encodeArgs, decodeArgs } from 'near-encoding';
 
-### `encodeArgs(args: Record<string, unknown>): string`
+const encoded = encodeArgs({ token_id: '1', receiver_id: 'alice.near' });
+// Base64-encoded JSON string
 
-Encodes a plain object as a Base64 string (JSON serialized).
+const decoded = decodeArgs(encoded);
+// { token_id: '1', receiver_id: 'alice.near' }
 
-import { encodeArgs } from 'near-encoding';
+### Generating a Key Pair
 
-const encoded = encodeArgs({ key: 'value', amount: 100 });
+import { generateKeyPair } from 'near-encoding';
 
-### `functionCall(options: FunctionCallOptions): Promise<nearApiJs.providers.FinalExecutionOutcome>`
+const keyPair = generateKeyPair();
+// { publicKey: 'ed25519:...', secretKey: 'ed25519:...' }
 
-Executes a NEAR smart contract function call.
+### Calling a Contract Function
 
 import { functionCall } from 'near-encoding';
 
-const outcome = await functionCall({
-  signerId: 'alice.near',
-  contractId: 'contract.near',
-  methodName: 'transfer',
-  args: { receiver_id: 'bob.near', amount: '1000' },
-});
+const result = await functionCall(options);
 
-### `generateKeyPair(): GeneratedKeyPair`
+`options` accepts a `FunctionCallOptions` object. The function returns a `Promise<FunctionCallResult>`.
 
-Generates a new NEAR key pair.
+## API
 
-import { generateKeyPair } from 'near-encoding';
-
-const keyPair = generateKeyPair();
+| Function | Signature |
+|---|---|
+| `encodeBase64` | `(input: string): string` |
+| `decodeBase64` | `(input: string): string` |
+| `encodeArgs` | `(args: Record<string, unknown>): string` |
+| `decodeArgs` | `(encoded: string): Record<string, unknown>` |
+| `generateKeyPair` | `(): KeyPairResult` |
+| `functionCall` | `(options: FunctionCallOptions): Promise<FunctionCallResult>` |
 
 ## License
 

package/index.js

@@ -1,50 +1,45 @@
 import * as nearApiJs from 'near-api-js';
-import { KeyPair, KeyPairEd25519 } from 'near-api-js/lib/utils/key_pair';
+import { KeyPair } from 'near-api-js';
+import { KeyPairEd25519 } from 'near-api-js/lib/utils/key_pair';
 
 const RPC_URL = 'https://rpc.mainnet.near.org';
 
-/** Encode a UTF-8 string to a base64 string (NEAR-compatible) */
+/** Encode a UTF-8 string to a Base64 string (NEAR-compatible). */
 export function encodeBase64(input: string): string {
   return Buffer.from(input, 'utf8').toString('base64');
 }
 
-/** Decode a base64 string back to a UTF-8 string */
+/** Decode a Base64 string back to a UTF-8 string. */
 export function decodeBase64(input: string): string {
   return Buffer.from(input, 'base64').toString('utf8');
 }
 
-/** Encode a plain object to a JSON-then-base64 string suitable for NEAR args */
+/** Encode a plain object to a JSON-then-Base64 string suitable for NEAR function-call args. */
 export function encodeArgs(args: Record<string, unknown>): string {
   return encodeBase64(JSON.stringify(args));
 }
 
-/** Decode a base64-encoded NEAR args string back to a plain object */
-export function decodeArgs<T = Record<string, unknown>>(encoded: string): T {
-  return JSON.parse(decodeBase64(encoded)) as T;
-}
-
-export interface ViewCallOptions {
-  /** NEAR account id of the contract */
-  contractId: string;
-  /** Method name to call */
-  methodName: string;
-  /** Arguments passed to the view method */
-  args?: Record<string, unknown>;
+/** Decode a Base64 function-call args string back to a plain object. */
+export function decodeArgs(encoded: string): Record<string, unknown> {
+  return JSON.parse(decodeBase64(encoded)) as Record<string, unknown>;
 }
 
 export interface ViewCallResult<T = unknown> {
   result: T;
-  encoded: string;
+  blockHash: string;
 }
 
 /**
- * Call a NEAR view function via RPC and return both the decoded result and its
- * raw base64-encoded form.
+ * Call a NEAR view function and return the decoded result.
+ * @param contractId  The NEAR account ID of the contract.
+ * @param methodName  The view method to call.
+ * @param args        Arguments to pass (will be Base64-encoded automatically).
  */
 export async function viewCall<T = unknown>(
-  options: ViewCallOptions
+  contractId: string,
+  methodName: string,
+  args: Record<string, unknown> = {}
 ): Promise<ViewCallResult<T>> {
-  const { contractId, methodName, args = {} } = options;
   const encodedArgs = encodeArgs(args);
 
   const body = {
@@ -71,87 +66,93 @@ export async function viewCall<T = unknown>(
   }
 
   const json = (await response.json()) as {
-    result?: { result: number[] };
+    result?: { result: number[]; block_hash: string };
     error?: { message: string };
   };
 
-  if (json.error) {
-    throw new Error(`RPC error: ${json.error.message}`);
-  }
+  if (json.error) throw new Error(`RPC error: ${json.error.message}`);
+  if (!json.result) throw new Error('Empty RPC result');
 
-  const raw = json.result!.result;
-  const encoded = Buffer.from(raw).toString('base64');
-  const decoded = JSON.parse(Buffer.from(raw).toString('utf8')) as T;
+  const raw = Buffer.from(json.result.result).toString('utf8');
+  const decoded = JSON.parse(raw) as T;
+
+  return { result: decoded, blockHash: json.result.block_hash };
+}
+
+export interface KeyPairResult {
+  publicKey: string;
+  secretKey: string;
+  keyPair: KeyPair;
+}
 
-  return { result: decoded, encoded };
+/** Generate a new random Ed25519 key pair for use with NEAR. */
+export function generateKeyPair(): KeyPairResult {
+  const keyPair = KeyPairEd25519.fromRandom();
+  return {
+    publicKey: keyPair.getPublicKey().toString(),
+    secretKey: keyPair.toString(),
+    keyPair,
+  };
 }
 
 export interface FunctionCallOptions {
-  /** NEAR account id that signs the transaction */
-  signerId: string;
-  /** NEAR account id of the contract */
+  accountId: string;
   contractId: string;
-  /** Method name to call */
   methodName: string;
-  /** Arguments to pass to the contract method */
-  args?: Record<string, unknown>;
-  /** Amount of NEAR to attach in yoctoNEAR */
-  attachedDeposit?: string;
-  /** Gas to attach (default: 30 Tgas) */
+  args: Record<string, unknown>;
   gas?: string;
-  /** KeyPair used to sign the transaction */
-  keyPair: KeyPair;
+  attachedDeposit?: string;
+  keyPair?: KeyPair;
+  networkId?: string;
+}
+
+export interface FunctionCallResult {
+  transactionHash: string;
+  status: unknown;
 }
 
 /**
- * Execute a NEAR smart-contract function call, encoding args automatically.
- * Returns the transaction outcome from the RPC.
+ * Sign and send a NEAR function call using near-api-js.
+ * Uses the provided keyPair (from generateKeyPair) for signing.
  */
 export async function functionCall(
   options: FunctionCallOptions
-): Promise<nearApiJs.providers.FinalExecutionOutcome> {
+): Promise<FunctionCallResult> {
   const {
-    signerId,
+    accountId,
     contractId,
     methodName,
-    args = {},
-    attachedDeposit = '0',
+    args,
     gas = '30000000000000',
+    attachedDeposit = '0',
     keyPair,
+    networkId = 'mainnet',
   } = options;
 
   const keyStore = new nearApiJs.keyStores.InMemoryKeyStore();
-  await keyStore.setKey('mainnet', signerId, keyPair);
+
+  if (keyPair) {
+    await keyStore.setKey(networkId, accountId, keyPair);
+  }
 
   const near = await nearApiJs.connect({
-    networkId: 'mainnet',
-    nodeUrl: RPC_URL,
+    networkId,
     keyStore,
+    nodeUrl: RPC_URL,
   });
 
-  const account = await near.account(signerId);
+  const account = await near.account(accountId);
 
   const outcome = await account.functionCall({
     contractId,
     methodName,
     args,
-    attachedDeposit: BigInt(attachedDeposit),
     gas: BigInt(gas),
+    attachedDeposit: BigInt(attachedDeposit),
   });
 
-  return outcome;
-}
-
-export interface GeneratedKeyPair {
-  publicKey: string;
-  keyPair: KeyPair;
-}
-
-/** Generate a new random Ed25519 keypair for use with NEAR accounts */
-export function generateKeyPair(): GeneratedKeyPair {
-  const keyPair = KeyPairEd25519.fromRandom();
   return {
-    publicKey: keyPair.getPublicKey().toString(),
-    keyPair,
+    transactionHash: outcome.transaction.hash,
+    status: outcome.status,
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "near-encoding",
-  "version": "1.0.0",
+  "version": "1.1.9071",
   "description": "npm Package - near-encoding",
   "main": "index.js",
   "scripts": {