near-api-js 7.1.0 → 7.2.0

package/lib/accounts/account.d.ts

@@ -3,7 +3,7 @@ import { type Provider } from '../providers/index.js';
 import type { RpcTransactionResponse } from '../rpc/types.gen.js';
 import { type SignedMessage, type Signer } from '../signers/index.js';
 import type { SignDelegateActionReturn } from '../signers/signer.js';
-import type { FungibleToken, NativeToken } from '../tokens/index.js';
+import { FungibleToken, type NativeToken } from '../tokens/index.js';
 import { type Action, type DelegateAction, type SignedDelegate, type SignedTransaction } from '../transactions/index.js';
 import type { SerializedReturnValue, TxExecutionStatus } from '../types/index.js';
 export declare const DEFAULT_WAIT_STATUS: TxExecutionStatus;

package/lib/accounts/account.js

@@ -3,7 +3,7 @@ import { parseTransactionExecutionError } from '../providers/errors/parse.js';
 import { InvalidNonceError } from '../providers/errors/transaction_execution.js';
 import { JsonRpcProvider } from '../providers/index.js';
 import { KeyPairSigner } from '../signers/index.js';
-import { NEAR } from '../tokens/index.js';
+import { FungibleToken, NEAR } from '../tokens/index.js';
 import { actions, buildDelegateAction, createTransaction, } from '../transactions/index.js';
 import { baseDecode, getTransactionLastResult } from '../utils/index.js';
 import { NonceManager } from './nonce-manager.js';
@@ -298,7 +298,7 @@ export class Account {
         }
         const splitted = newAccountId.split('.');
         if (splitted.length != 2) {
-            throw new Error('newAccountId needs to be of the form <string>.<tla>');
+            throw new Error(`${this.accountId} can only create sub-accounts of itself, or accounts of the form <account>.<tla>`);
         }
         const TLA = splitted[1];
         return this.signAndSendTransaction({
@@ -512,6 +512,15 @@ export class Account {
      *
      */
     async transfer({ receiverId, amount, token = NEAR }) {
+        if (token instanceof FungibleToken) {
+            const isRegistered = await token.isAccountRegistered({ accountId: receiverId, provider: this.provider });
+            if (!isRegistered) {
+                await token.registerAccount({
+                    accountIdToRegister: receiverId,
+                    fundingAccount: this,
+                });
+            }
+        }
         return token.transfer({ from: this, receiverId, amount });
     }
 }

package/lib/crypto/key_pair_ed25519.js

@@ -1,5 +1,4 @@
 import { ed25519 } from '@noble/curves/ed25519.js';
-import { randomBytes } from '@noble/hashes/utils.js';
 import { baseDecode, baseEncode } from '../utils/index.js';
 import { KeySize, KeyType } from './constants.js';
 import { KeyPairBase } from './key_pair_base.js';
@@ -34,7 +33,7 @@ export class KeyPairEd25519 extends KeyPairBase {
      * // returns [SECRET_KEY]
      */
     static fromRandom() {
-        const secretKey = randomBytes(KeySize.SECRET_KEY);
+        const secretKey = crypto.getRandomValues(new Uint8Array(KeySize.SECRET_KEY));
         const publicKey = ed25519.getPublicKey(new Uint8Array(secretKey));
         const extendedSecretKey = new Uint8Array([...secretKey, ...publicKey]);
         return new KeyPairEd25519(baseEncode(extendedSecretKey));

package/lib/crypto/key_pair_secp256k1.js

@@ -1,5 +1,4 @@
-import { randomBytes } from '@noble/hashes/utils.js';
-import secp256k1 from 'secp256k1';
+import { secp256k1 } from '@noble/curves/secp256k1.js';
 import { baseDecode, baseEncode } from '../utils/index.js';
 import { KeySize, KeyType } from './constants.js';
 import { KeyPairBase } from './key_pair_base.js';
@@ -24,8 +23,8 @@ export class KeyPairSecp256k1 extends KeyPairBase {
         super();
         const decoded = baseDecode(extendedSecretKey);
         const secretKey = new Uint8Array(decoded.slice(0, KeySize.SECRET_KEY));
-        const withHeader = secp256k1.publicKeyCreate(new Uint8Array(secretKey), false);
-        const data = withHeader.subarray(1, withHeader.length); // remove the 0x04 header byte
+        const withHeader = secp256k1.getPublicKey(new Uint8Array(secretKey), false);
+        const data = withHeader.subarray(1); // remove the 0x04 header byte
         this.publicKey = new PublicKey({
             keyType: KeyType.SECP256K1,
             data,
@@ -44,17 +43,21 @@ export class KeyPairSecp256k1 extends KeyPairBase {
      * // returns [SECRET_KEY]
      */
     static fromRandom() {
-        // TODO: find better way to generate PK
-        const secretKey = randomBytes(KeySize.SECRET_KEY);
-        const withHeader = secp256k1.publicKeyCreate(new Uint8Array(secretKey), false);
-        const publicKey = withHeader.subarray(1, withHeader.length);
+        const secretKey = crypto.getRandomValues(new Uint8Array(KeySize.SECRET_KEY));
+        const withHeader = secp256k1.getPublicKey(secretKey, false);
+        const publicKey = withHeader.subarray(1);
         const extendedSecretKey = new Uint8Array([...secretKey, ...publicKey]);
         return new KeyPairSecp256k1(baseEncode(extendedSecretKey));
     }
     sign(message) {
         // nearcore expects 65 byte signatures formed by appending the recovery id to the 64 byte signature
-        const { signature, recid } = secp256k1.ecdsaSign(message, baseDecode(this.secretKey));
-        return { signature: new Uint8Array([...signature, recid]), publicKey: this.publicKey };
+        // noble v2 'recovered' format is [recovery, r, s] but NEAR expects [r, s, recovery]
+        // prehash: false because NEAR already provides a sha256-hashed message
+        const raw = secp256k1.sign(message, baseDecode(this.secretKey), { prehash: false, format: 'recovered' });
+        const signature = new Uint8Array(65);
+        signature.set(raw.subarray(1), 0); // r, s (64 bytes)
+        signature[64] = raw[0]; // recovery byte
+        return { signature, publicKey: this.publicKey };
     }
     verify(message, signature) {
         return this.publicKey.verify(message, signature);

package/lib/crypto/public_key.js

@@ -1,5 +1,5 @@
 import { ed25519 } from '@noble/curves/ed25519.js';
-import secp256k1 from 'secp256k1';
+import { secp256k1 } from '@noble/curves/secp256k1.js';
 import { baseDecode, baseEncode } from '../utils/index.js';
 import { KeySize, KeyType } from './constants.js';
 function key_type_to_str(keyType) {
@@ -70,16 +70,30 @@ export class PublicKey extends Enum {
         this[keyName] = publicKey;
         this.enum = keyName;
     }
-    /**
-     * Creates a PublicKey instance from a string or an existing PublicKey instance.
-     * @param value The string or PublicKey instance to create a PublicKey from.
-     * @returns {PublicKey} The PublicKey instance.
-     */
     static from(value) {
         if (typeof value === 'string') {
             return PublicKey.fromString(value);
         }
-        return value;
+        if (value instanceof PublicKey) {
+            return value;
+        }
+        if (typeof value === 'object' && value !== null) {
+            const maybeEd25519 = value['ed25519Key'];
+            if (typeof maybeEd25519 === 'object' && maybeEd25519 !== null && 'data' in maybeEd25519) {
+                return new PublicKey({
+                    keyType: KeyType.ED25519,
+                    data: Uint8Array.from(maybeEd25519.data),
+                });
+            }
+            const maybeSecp256k1 = value['secp256k1Key'];
+            if (typeof maybeSecp256k1 === 'object' && maybeSecp256k1 !== null && 'data' in maybeSecp256k1) {
+                return new PublicKey({
+                    keyType: KeyType.SECP256K1,
+                    data: Uint8Array.from(maybeSecp256k1.data),
+                });
+            }
+        }
+        throw new Error('Unsupported public key format');
     }
     /**
      * Creates a PublicKey instance from an encoded key string.
@@ -131,7 +145,9 @@ export class PublicKey extends Enum {
             case KeyType.ED25519:
                 return ed25519.verify(signature, message, data);
             case KeyType.SECP256K1:
-                return secp256k1.ecdsaVerify(signature.subarray(0, 64), message, new Uint8Array([0x04, ...data]));
+                return secp256k1.verify(signature.subarray(0, 64), message, new Uint8Array([0x04, ...data]), {
+                    prehash: false,
+                });
             default:
                 throw new Error(`Unknown key type: ${keyType}`);
         }

package/lib/providers/json-rpc-provider.d.ts

@@ -64,14 +64,14 @@ export declare class JsonRpcProvider implements Provider {
         block_height: number;
     }>;
     viewContractCode({ contractId, blockQuery }: ViewContractCodeArgs): Promise<{
-        code: Uint8Array<ArrayBuffer>;
+        code: Uint8Array<ArrayBufferLike>;
         code_base64: string;
         hash: CryptoHash;
         block_hash: CryptoHash;
         block_height: number;
     }>;
     viewGlobalContractCode({ identifier, blockQuery, }: ViewGlobalContractCodeArgs): Promise<{
-        code: Uint8Array<ArrayBuffer>;
+        code: Uint8Array<ArrayBufferLike>;
         code_base64: string;
         hash: CryptoHash;
         block_hash: CryptoHash;

package/lib/providers/json-rpc-provider.js

@@ -6,7 +6,7 @@
  */
 import { encodeTransaction } from '../transactions/index.js';
 import { TypedError, } from '../types/index.js';
-import { baseEncode, findSeatPrice } from '../utils/index.js';
+import { base64Decode, base64Encode, baseEncode, bytesToString, findSeatPrice, stringToBytes } from '../utils/index.js';
 import { parseRpcError, parseRpcErrorMessage } from './errors/parse.js';
 import { RpcError } from './errors/rpc.js';
 import { fetchJsonRpc, retryConfig } from './fetch_json.js';
@@ -122,7 +122,7 @@ export class JsonRpcProvider {
         });
         return {
             ...data,
-            code: new Uint8Array(Buffer.from(data.code_base64, 'base64')),
+            code: base64Decode(data.code_base64),
         };
     }
     async viewGlobalContractCode({ identifier, blockQuery = { finality: DEFAULT_FINALITY }, }) {
@@ -143,7 +143,7 @@ export class JsonRpcProvider {
                 request_type: 'view_global_contract_code',
                 code_hash: typeof identifier.codeHash === 'string'
                     ? identifier.codeHash
-                    : Buffer.from(identifier.codeHash).toString('hex'),
+                    : Array.from(identifier.codeHash, (b) => b.toString(16).padStart(2, '0')).join(''),
             });
         }
         else if ('accountId' in identifier) {
@@ -158,11 +158,11 @@ export class JsonRpcProvider {
         }
         return {
             ...data,
-            code: new Uint8Array(Buffer.from(data.code_base64, 'base64')),
+            code: base64Decode(data.code_base64),
         };
     }
     async viewContractState({ contractId, prefix, blockQuery = { finality: DEFAULT_FINALITY }, }) {
-        const prefixBase64 = Buffer.from(prefix || '').toString('base64');
+        const prefixBase64 = base64Encode(stringToBytes(prefix || ''));
         let reference;
         if ('blockId' in blockQuery) {
             reference = { block_id: blockQuery.blockId };
@@ -184,7 +184,7 @@ export class JsonRpcProvider {
         const { result } = await this.callFunctionRaw({ contractId, method, args, blockQuery });
         if (result.length === 0)
             return undefined;
-        const serializedResult = Buffer.from(result).toString();
+        const serializedResult = bytesToString(new Uint8Array(result));
         try {
             return JSON.parse(serializedResult);
         }
@@ -193,8 +193,8 @@ export class JsonRpcProvider {
         }
     }
     async callFunctionRaw({ contractId, method, args, blockQuery = { finality: DEFAULT_FINALITY }, }) {
-        const argsBuffer = ArrayBuffer.isView(args) ? Buffer.from(args) : Buffer.from(JSON.stringify(args));
-        const argsBase64 = argsBuffer.toString('base64');
+        const argsBytes = args instanceof Uint8Array ? args : stringToBytes(JSON.stringify(args));
+        const argsBase64 = base64Encode(argsBytes);
         if ('blockId' in blockQuery) {
             return this.query({
                 request_type: 'call_function',
@@ -279,7 +279,7 @@ export class JsonRpcProvider {
     async sendTransactionUntil(signedTransaction, waitUntil) {
         const bytes = encodeTransaction(signedTransaction);
         return this.sendJsonRpc('send_tx', {
-            signed_tx_base64: Buffer.from(bytes).toString('base64'),
+            signed_tx_base64: base64Encode(bytes),
             wait_until: waitUntil,
         });
     }

package/lib/tokens/ft/index.d.ts

@@ -1,4 +1,5 @@
 import type { Account } from '../../accounts/account.js';
+import type { Provider } from '../../providers/provider.js';
 interface FTMetadata {
     spec?: string;
     name: string;
@@ -61,7 +62,10 @@ export declare class FungibleToken extends BaseFT {
         receiverId: string;
         amount: string | number | bigint;
     }): Promise<any>;
-    getBalance(account: Account): Promise<bigint>;
+    getBalance({ accountId, provider }: {
+        accountId: string;
+        provider: Provider;
+    }): Promise<bigint>;
     /**
      * Transfer tokens and call a function on the receiver contract,
      * only works if the receiver implements the `ft_on_transfer` method
@@ -100,6 +104,18 @@ export declare class FungibleToken extends BaseFT {
         account: Account;
         force: boolean;
     }): Promise<any>;
+    /**
+     * Checks if an account is registered to the fungible token contract
+     *
+     * @param param
+     * @param param.accountId The AccountID to check
+     * @param param.provider A Provider to use for the query
+     * @returns Whether the account is registered
+     */
+    isAccountRegistered({ accountId, provider, }: {
+        accountId: string;
+        provider: Provider;
+    }): Promise<boolean>;
 }
 /**
  * The NEAR token is the native token of the NEAR blockchain

package/lib/tokens/ft/index.js

@@ -1,4 +1,5 @@
 import { actions } from '../../transactions/action_creators.js';
+import { teraToGas } from '../../units/gas.js';
 import { formatAmount, parseAmount } from './format.js';
 class BaseFT {
     constructor(metadata) {
@@ -51,15 +52,15 @@ export class FungibleToken extends BaseFT {
                 amount: amount.toString(),
                 receiver_id: receiverId,
             },
-            gas: '30000000000000',
+            gas: teraToGas(30),
             deposit: 1,
         });
     }
-    async getBalance(account) {
-        const balance = await account.provider.callFunction({
+    async getBalance({ accountId, provider }) {
+        const balance = await provider.callFunction({
             contractId: this.accountId,
             method: 'ft_balance_of',
-            args: { account_id: account.accountId },
+            args: { account_id: accountId },
         });
         return BigInt(balance);
     }
@@ -82,7 +83,7 @@ export class FungibleToken extends BaseFT {
                 amount: amount.toString(),
                 msg,
             },
-            gas: '30000000000000',
+            gas: teraToGas(30),
             deposit: 1,
         });
     }
@@ -107,7 +108,7 @@ export class FungibleToken extends BaseFT {
                 account_id: accountIdToRegister,
                 registration_only: true,
             },
-            gas: '30000000000000',
+            gas: teraToGas(30),
             deposit: requiredDeposit,
         });
     }
@@ -123,10 +124,35 @@ export class FungibleToken extends BaseFT {
             contractId: this.accountId,
             methodName: 'storage_unregister',
             args: { force },
-            gas: '30000000000000',
+            gas: teraToGas(30),
             deposit: 1,
         });
     }
+    /**
+     * Checks if an account is registered to the fungible token contract
+     *
+     * @param param
+     * @param param.accountId The AccountID to check
+     * @param param.provider A Provider to use for the query
+     * @returns Whether the account is registered
+     */
+    async isAccountRegistered({ accountId, provider, }) {
+        const [storage, required] = await Promise.all([
+            provider.callFunction({
+                contractId: this.accountId,
+                method: 'storage_balance_of',
+                args: { account_id: accountId },
+            }),
+            provider.callFunction({
+                contractId: this.accountId,
+                method: 'storage_balance_bounds',
+                args: {},
+            }),
+        ]);
+        if (!storage)
+            return false;
+        return BigInt(storage.total) >= BigInt(required.min);
+    }
 }
 /**
  * The NEAR token is the native token of the NEAR blockchain

package/lib/transactions/action_creators.d.ts

@@ -27,11 +27,11 @@ declare function createAccount(): Action;
  */
 declare function deployContract(code: Uint8Array): Action;
 /**
- * Converts an input argument to a Buffer, handling cases for both JSON and Uint8Array.
+ * Converts an input argument to a Uint8Array, handling cases for both JSON and Uint8Array.
  * @param args The input argument, either JSON object or Uint8Array.
- * @returns A Buffer representation of the input argument.
+ * @returns A Uint8Array representation of the input argument.
  */
-export declare function stringifyJsonOrBytes(args: any): Buffer;
+export declare function stringifyJsonOrBytes(args: any): Uint8Array;
 /**
  * Constructs {@link Action} instance representing contract method call.
  *

package/lib/transactions/action_creators.js

@@ -1,3 +1,4 @@
+import { stringToBytes } from '../utils/index.js';
 import { AccessKey, AccessKeyPermission, Action, AddKey, CreateAccount, DeleteAccount, DeleteKey, DeployContract, DeployGlobalContract, FullAccessPermission, FunctionCall, FunctionCallPermission, GlobalContractDeployMode, GlobalContractIdentifier, SignedDelegate, Stake, Transfer, UseGlobalContract, } from './actions.js';
 /**
  * Creates a full access key with full access permissions.
@@ -46,13 +47,14 @@ function deployContract(code) {
     return new Action({ deployContract: new DeployContract({ code }) });
 }
 /**
- * Converts an input argument to a Buffer, handling cases for both JSON and Uint8Array.
+ * Converts an input argument to a Uint8Array, handling cases for both JSON and Uint8Array.
  * @param args The input argument, either JSON object or Uint8Array.
- * @returns A Buffer representation of the input argument.
+ * @returns A Uint8Array representation of the input argument.
  */
 export function stringifyJsonOrBytes(args) {
-    const isUint8Array = args.byteLength !== undefined && args.byteLength === args.length;
-    return isUint8Array ? args : Buffer.from(JSON.stringify(args));
+    if (args instanceof Uint8Array)
+        return args;
+    return stringToBytes(JSON.stringify(args));
 }
 /**
  * Constructs {@link Action} instance representing contract method call.
@@ -170,7 +172,7 @@ function useGlobalContract(contractIdentifier) {
         })
         : new GlobalContractIdentifier({
             CodeHash: typeof contractIdentifier.codeHash === 'string'
-                ? Buffer.from(contractIdentifier.codeHash, 'hex')
+                ? new Uint8Array(contractIdentifier.codeHash.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)))
                 : contractIdentifier.codeHash,
         });
     return new Action({ useGlobalContract: new UseGlobalContract({ contractIdentifier: identifier }) });

package/lib/transactions/schema.d.ts

@@ -1,5 +1,5 @@
 import { type Schema } from 'borsh';
-import type { PublicKey } from '../crypto/index.js';
+import { PublicKey } from '../crypto/index.js';
 import type { Action, SignedDelegate } from './actions.js';
 import type { DelegateAction } from './delegate.js';
 import type { Signature } from './signature.js';

package/lib/transactions/schema.js

@@ -1,4 +1,5 @@
 import { deserialize, serialize } from 'borsh';
+import { PublicKey } from '../crypto/index.js';
 import { DelegateActionPrefix } from './prefix.js';
 /**
  * Borsh-encode a delegate action for inclusion as an action within a meta transaction
@@ -45,7 +46,7 @@ export function decodeSignedTransaction(bytes) {
 export class Transaction {
     constructor({ signerId, publicKey, nonce, receiverId, actions, blockHash, }) {
         this.signerId = signerId;
-        this.publicKey = publicKey;
+        this.publicKey = PublicKey.from(publicKey);
         this.nonce = nonce;
         this.receiverId = receiverId;
         this.actions = actions;
@@ -60,7 +61,7 @@ export class Transaction {
 }
 export class SignedTransaction {
     constructor({ transaction, signature }) {
-        this.transaction = transaction;
+        this.transaction = transaction instanceof Transaction ? transaction : new Transaction(transaction);
         this.signature = signature;
     }
     encode() {

package/lib/utils/format.d.ts

@@ -41,4 +41,28 @@ export declare function baseEncode(value: Uint8Array | string): string;
  * @returns Uint8Array representing the decoded value
  */
 export declare function baseDecode(value: string): Uint8Array;
+/**
+ * Encodes a Uint8Array into a base64 string
+ * @param bytes Uint8Array to encode
+ * @returns base64 encoded string
+ */
+export declare function base64Encode(bytes: Uint8Array): string;
+/**
+ * Decodes a base64 string into a Uint8Array
+ * @param str base64 encoded string
+ * @returns Uint8Array representing the decoded value
+ */
+export declare function base64Decode(str: string): Uint8Array;
+/**
+ * Encodes a string into a Uint8Array using UTF-8
+ * @param str string to encode
+ * @returns Uint8Array representing the UTF-8 bytes
+ */
+export declare function stringToBytes(str: string): Uint8Array;
+/**
+ * Decodes a Uint8Array into a string using UTF-8
+ * @param bytes Uint8Array to decode
+ * @returns decoded string
+ */
+export declare function bytesToString(bytes: Uint8Array): string;
 export {};

package/lib/utils/format.js

@@ -1,4 +1,4 @@
-import { base58 } from '@scure/base';
+import { base58, base64 } from '@scure/base';
 /**
  * Exponent for calculating how many indivisible units are there in one NEAR. See {@link NEAR_NOMINATION}.
  */
@@ -126,3 +126,37 @@ export function baseEncode(value) {
 export function baseDecode(value) {
     return base58.decode(value);
 }
+/**
+ * Encodes a Uint8Array into a base64 string
+ * @param bytes Uint8Array to encode
+ * @returns base64 encoded string
+ */
+export function base64Encode(bytes) {
+    return base64.encode(bytes);
+}
+/**
+ * Decodes a base64 string into a Uint8Array
+ * @param str base64 encoded string
+ * @returns Uint8Array representing the decoded value
+ */
+export function base64Decode(str) {
+    return base64.decode(str);
+}
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+/**
+ * Encodes a string into a Uint8Array using UTF-8
+ * @param str string to encode
+ * @returns Uint8Array representing the UTF-8 bytes
+ */
+export function stringToBytes(str) {
+    return encoder.encode(str);
+}
+/**
+ * Decodes a Uint8Array into a string using UTF-8
+ * @param bytes Uint8Array to decode
+ * @returns decoded string
+ */
+export function bytesToString(bytes) {
+    return decoder.decode(bytes);
+}

package/lib/utils/provider.js

@@ -1,3 +1,4 @@
+import { base64Decode, bytesToString } from './format.js';
 /** @hidden */
 // eslint-disable-next-line @typescript-eslint/ban-types
 export function getTransactionLastResult(txResult) {
@@ -5,7 +6,7 @@ export function getTransactionLastResult(txResult) {
         txResult.status !== null &&
         'SuccessValue' in txResult.status &&
         typeof txResult.status.SuccessValue === 'string') {
-        const value = Buffer.from(txResult.status.SuccessValue, 'base64').toString();
+        const value = bytesToString(base64Decode(txResult.status.SuccessValue));
         try {
             return JSON.parse(value);
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "near-api-js",
   "description": "JavaScript library to interact with NEAR Protocol via RPC API",
-  "version": "7.1.0",
+  "version": "7.2.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/near/near-api-js.git"
@@ -48,8 +48,7 @@
     "@scure/base": "2.0.0",
     "borsh": "2.0.0",
     "is-my-json-valid": "2.20.6",
-    "near-seed-phrase": "0.2.1",
-    "secp256k1": "5.0.1"
+    "near-seed-phrase": "0.2.1"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "0.18.2",