Socket
Socket
Sign inDemoInstall

near-sdk-js

Package Overview
Dependencies
Maintainers
2
Versions
26
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

near-sdk-js - npm Package Compare versions

Comparing version 0.4.0-4 to 0.4.0-5

2

cli/cli.js

@@ -158,5 +158,5 @@ #!/usr/bin/env node

async function wasiStubStandaloneContract(standaloneContractTarget) {
console.log(`Excecuting wasi-stub...`);
console.log(`Executing wasi-stub...`);
const WASI_STUB = `${NEAR_SDK_JS}/cli/deps/binaryen/wasi-stub/run.sh`;
await executeCommand(`${WASI_STUB} ${standaloneContractTarget} >/dev/null`);
}

12

cli/post-install.js
import { executeCommand } from './utils.js';
async function download(url) {
await executeCommand(`curl -LOf ${url}`);
}
const OS = await executeCommand('uname -s', true);

@@ -23,3 +27,3 @@ const ARCH = await executeCommand('uname -m', true);

await executeCommand(`wget https://github.com/near/binaryen/releases/download/${BINARYEN_VERSION_TAG}/${BINARYEN_TAR_NAME}`);
await download(`https://github.com/near/binaryen/releases/download/${BINARYEN_VERSION_TAG}/${BINARYEN_TAR_NAME}`);
await executeCommand(`mkdir -p binaryen && tar xvf ${BINARYEN_TAR_NAME} --directory binaryen`);

@@ -39,4 +43,4 @@ await executeCommand(`rm ${BINARYEN_TAR_NAME}`);

// Download QuickJS
await executeCommand(`wget https://github.com/near/quickjs/releases/download/${QUICK_JS_VERSION_TAG}/qjsc-${QUICK_JS_SYSTEM_NAME}-${QUICK_JS_ARCH_NAME}`);
await executeCommand(`wget https://github.com/near/quickjs/archive/refs/tags/${QUICK_JS_VERSION_TAG}.tar.gz`);
await download(`https://github.com/near/quickjs/releases/download/${QUICK_JS_VERSION_TAG}/qjsc-${QUICK_JS_SYSTEM_NAME}-${QUICK_JS_ARCH_NAME}`);
await download(`https://github.com/near/quickjs/archive/refs/tags/${QUICK_JS_VERSION_TAG}.tar.gz`);
// Extract QuickJS

@@ -61,3 +65,3 @@ await executeCommand(`tar xvf ${QUICK_JS_TAR_NAME}`);

// Download WASI SDK
await executeCommand(`wget https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-${WASI_SDK_MAJOR_VER}/${WASI_SDK_TAR_NAME}`);
await download(`https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-${WASI_SDK_MAJOR_VER}/${WASI_SDK_TAR_NAME}`);
// Extract WASI SDK

@@ -64,0 +68,0 @@ await executeCommand(`tar xvf ${WASI_SDK_TAR_NAME}`);

20

lib/collections/lookup-map.d.ts

@@ -1,12 +0,12 @@

import { Bytes, ClassMap } from '../utils';
import { Serializer } from 'superserial';
export declare class LookupMap<K, V> {
import { Bytes } from '../utils';
export declare class LookupMap {
readonly keyPrefix: Bytes;
readonly serializer: Serializer;
constructor(keyPrefix: Bytes, classes?: ClassMap);
containsKey(key: K): boolean;
get(key: K): V | null;
remove(key: K): V | null;
set(key: K, value: V): V | null;
extend(objects: [K, V][]): void;
constructor(keyPrefix: Bytes);
containsKey(key: Bytes): boolean;
get(key: Bytes): unknown | null;
remove(key: Bytes): unknown | null;
set(key: Bytes, value: unknown): unknown | null;
extend(objects: [Bytes, unknown][]): void;
serialize(): string;
static deserialize(data: LookupMap): LookupMap;
}

27

lib/collections/lookup-map.js
import * as near from '../api';
import { Serializer } from 'superserial';
export class LookupMap {
constructor(keyPrefix, classes) {
constructor(keyPrefix) {
this.keyPrefix = keyPrefix;
this.serializer = new Serializer({ classes });
}
containsKey(key) {
let storageKey = this.keyPrefix + this.serializer.serialize(key);
let storageKey = this.keyPrefix + JSON.stringify(key);
return near.storageHasKey(storageKey);
}
get(key) {
let storageKey = this.keyPrefix + this.serializer.serialize(key);
let storageKey = this.keyPrefix + JSON.stringify(key);
let raw = near.storageRead(storageKey);
if (raw !== null) {
return this.serializer.deserialize(raw);
return JSON.parse(raw);
}

@@ -21,5 +19,5 @@ return null;

remove(key) {
let storageKey = this.keyPrefix + this.serializer.serialize(key);
let storageKey = this.keyPrefix + JSON.stringify(key);
if (near.storageRemove(storageKey)) {
return this.serializer.deserialize(near.storageGetEvicted());
return JSON.parse(near.storageGetEvicted());
}

@@ -29,6 +27,6 @@ return null;

set(key, value) {
let storageKey = this.keyPrefix + this.serializer.serialize(key);
let storageValue = this.serializer.serialize(value);
let storageKey = this.keyPrefix + JSON.stringify(key);
let storageValue = JSON.stringify(value);
if (near.storageWrite(storageKey, storageValue)) {
return this.serializer.deserialize(near.storageGetEvicted());
return JSON.parse(near.storageGetEvicted());
}

@@ -42,2 +40,9 @@ return null;

}
serialize() {
return JSON.stringify(this);
}
// converting plain object to class object
static deserialize(data) {
return new LookupMap(data.keyPrefix);
}
}

18

lib/collections/lookup-set.d.ts

@@ -1,11 +0,11 @@

import { Bytes, ClassMap } from '../utils';
import { Serializer } from 'superserial';
export declare class LookupSet<K> {
import { Bytes } from '../utils';
export declare class LookupSet {
readonly keyPrefix: Bytes;
readonly serializer: Serializer;
constructor(keyPrefix: Bytes, classes?: ClassMap);
contains(key: K): boolean;
remove(key: K): boolean;
set(key: K): boolean;
extend(keys: K[]): void;
constructor(keyPrefix: Bytes);
contains(key: Bytes): boolean;
remove(key: Bytes): boolean;
set(key: Bytes): boolean;
extend(keys: Bytes[]): void;
serialize(): string;
static deserialize(data: LookupSet): LookupSet;
}

17

lib/collections/lookup-set.js
import * as near from '../api';
import { Serializer } from 'superserial';
export class LookupSet {
constructor(keyPrefix, classes) {
constructor(keyPrefix) {
this.keyPrefix = keyPrefix;
this.serializer = new Serializer({ classes });
}
contains(key) {
let storageKey = this.keyPrefix + this.serializer.serialize(key);
let storageKey = this.keyPrefix + JSON.stringify(key);
return near.storageHasKey(storageKey);

@@ -14,3 +12,3 @@ }

remove(key) {
let storageKey = this.keyPrefix + this.serializer.serialize(key);
let storageKey = this.keyPrefix + JSON.stringify(key);
return near.storageRemove(storageKey);

@@ -21,3 +19,3 @@ }

set(key) {
let storageKey = this.keyPrefix + this.serializer.serialize(key);
let storageKey = this.keyPrefix + JSON.stringify(key);
return !near.storageWrite(storageKey, '');

@@ -30,2 +28,9 @@ }

}
serialize() {
return JSON.stringify(this);
}
// converting plain object to class object
static deserialize(data) {
return new LookupSet(data.keyPrefix);
}
}

35

lib/collections/unordered-map.d.ts

@@ -1,11 +0,10 @@

import { Bytes, ClassMap } from "../utils";
import { Bytes } from "../utils";
import { Vector } from "./vector";
import { Serializer } from 'superserial';
export declare class UnorderedMap<K, V> {
export declare class UnorderedMap {
readonly length: number;
readonly prefix: Bytes;
readonly keyIndexPrefix: Bytes;
readonly keys: Vector<K>;
readonly values: Vector<V>;
readonly serializer: Serializer;
constructor(prefix: Bytes, classes?: ClassMap);
readonly keys: Vector;
readonly values: Vector;
constructor(prefix: Bytes);
len(): number;

@@ -15,17 +14,19 @@ isEmpty(): boolean;

deserializeIndex(rawIndex: Bytes): number;
getIndexRaw(key: K): Bytes;
get(key: K): V | null;
set(key: K, value: V): V | null;
remove(key: K): V | null;
getIndexRaw(key: Bytes): Bytes;
get(key: Bytes): unknown | null;
set(key: Bytes, value: unknown): unknown | null;
remove(key: Bytes): unknown | null;
clear(): void;
toArray(): [K, V][];
[Symbol.iterator](): UnorderedMapIterator<K, V>;
extend(kvs: [K, V][]): void;
toArray(): [Bytes, unknown][];
[Symbol.iterator](): UnorderedMapIterator;
extend(kvs: [Bytes, unknown][]): void;
serialize(): string;
static deserialize(data: UnorderedMap): UnorderedMap;
}
declare class UnorderedMapIterator<K, V> {
declare class UnorderedMapIterator {
private keys;
private values;
constructor(unorderedMap: UnorderedMap<K, V>);
constructor(unorderedMap: UnorderedMap);
next(): {
value: [K | null, V | null];
value: [unknown | null, unknown | null];
done: boolean;

@@ -32,0 +33,0 @@ };

35

lib/collections/unordered-map.js
import * as near from "../api";
import { u8ArrayToBytes, bytesToU8Array } from "../utils";
import { Vector, VectorIterator } from "./vector";
import { Serializer } from 'superserial';
const ERR_INCONSISTENT_STATE = "The collection is an inconsistent state. Did previous smart contract execution terminate unexpectedly?";
export class UnorderedMap {
constructor(prefix, classes) {
constructor(prefix) {
this.length = 0;
this.prefix = prefix;
this.keyIndexPrefix = prefix + "i";
let indexKey = prefix + "k";
let indexValue = prefix + "v";
this.keys = new Vector(indexKey, classes);
this.values = new Vector(indexValue, classes);
this.serializer = new Serializer(classes);
this.keys = new Vector(indexKey);
this.values = new Vector(indexValue);
}

@@ -43,3 +42,3 @@ len() {

getIndexRaw(key) {
let indexLookup = this.keyIndexPrefix + this.serializer.serialize(key);
let indexLookup = this.keyIndexPrefix + JSON.stringify(key);
let indexRaw = near.storageRead(indexLookup);

@@ -63,3 +62,3 @@ return indexRaw;

set(key, value) {
let indexLookup = this.keyIndexPrefix + this.serializer.serialize(key);
let indexLookup = this.keyIndexPrefix + JSON.stringify(key);
let indexRaw = near.storageRead(indexLookup);

@@ -80,3 +79,3 @@ if (indexRaw) {

remove(key) {
let indexLookup = this.keyIndexPrefix + this.serializer.serialize(key);
let indexLookup = this.keyIndexPrefix + JSON.stringify(key);
let indexRaw = near.storageRead(indexLookup);

@@ -100,3 +99,3 @@ if (indexRaw) {

if (lastKey != key) {
let lastLookupKey = this.keyIndexPrefix + this.serializer.serialize(lastKey);
let lastLookupKey = this.keyIndexPrefix + JSON.stringify(lastKey);
near.storageWrite(lastLookupKey, indexRaw);

@@ -113,3 +112,3 @@ }

for (let key of this.keys) {
let indexLookup = this.keyIndexPrefix + this.serializer.serialize(key);
let indexLookup = this.keyIndexPrefix + JSON.stringify(key);
near.storageRemove(indexLookup);

@@ -135,2 +134,18 @@ }

}
serialize() {
return JSON.stringify(this);
}
// converting plain object to class object
static deserialize(data) {
let map = new UnorderedMap(data.prefix);
// reconstruct UnorderedMap
map.length = data.length;
// reconstruct keys Vector
map.keys = new Vector(data.prefix + "k");
map.keys.length = data.keys.length;
// reconstruct values Vector
map.values = new Vector(data.prefix + "v");
map.values.length = data.values.length;
return map;
}
}

@@ -137,0 +152,0 @@ class UnorderedMapIterator {

23

lib/collections/unordered-set.d.ts

@@ -1,10 +0,9 @@

import { Bytes, ClassMap } from "../utils";
import { Bytes } from "../utils";
import { Vector } from "./vector";
import { Serializer } from 'superserial';
export declare class UnorderedSet<E> {
export declare class UnorderedSet {
readonly length: number;
readonly prefix: Bytes;
readonly elementIndexPrefix: Bytes;
readonly elements: Vector<E>;
readonly serializer: Serializer;
constructor(prefix: Bytes, classes?: ClassMap);
readonly elements: Vector;
constructor(prefix: Bytes);
len(): number;

@@ -14,9 +13,11 @@ isEmpty(): boolean;

deserializeIndex(rawIndex: Bytes): number;
contains(element: E): boolean;
set(element: E): boolean;
remove(element: E): boolean;
contains(element: unknown): boolean;
set(element: unknown): boolean;
remove(element: unknown): boolean;
clear(): void;
toArray(): Bytes[];
[Symbol.iterator](): import("./vector").VectorIterator<E>;
extend(elements: E[]): void;
[Symbol.iterator](): import("./vector").VectorIterator;
extend(elements: unknown[]): void;
serialize(): string;
static deserialize(data: UnorderedSet): UnorderedSet;
}

31

lib/collections/unordered-set.js
import * as near from "../api";
import { u8ArrayToBytes, bytesToU8Array } from "../utils";
import { Vector } from "./vector";
import { Serializer } from 'superserial';
const ERR_INCONSISTENT_STATE = "The collection is an inconsistent state. Did previous smart contract execution terminate unexpectedly?";
export class UnorderedSet {
constructor(prefix, classes) {
constructor(prefix) {
this.length = 0;
this.prefix = prefix;
this.elementIndexPrefix = prefix + "i";
let elementsPrefix = prefix + "e";
this.elements = new Vector(elementsPrefix, classes);
this.serializer = new Serializer({ classes });
this.elements = new Vector(elementsPrefix);
}

@@ -31,7 +30,7 @@ len() {

contains(element) {
let indexLookup = this.elementIndexPrefix + this.serializer.serialize(element);
let indexLookup = this.elementIndexPrefix + JSON.stringify(element);
return near.storageHasKey(indexLookup);
}
set(element) {
let indexLookup = this.elementIndexPrefix + this.serializer.serialize(element);
let indexLookup = this.elementIndexPrefix + JSON.stringify(element);
if (near.storageRead(indexLookup)) {

@@ -49,3 +48,3 @@ return false;

remove(element) {
let indexLookup = this.elementIndexPrefix + this.serializer.serialize(element);
let indexLookup = this.elementIndexPrefix + JSON.stringify(element);
let indexRaw = near.storageRead(indexLookup);

@@ -69,3 +68,3 @@ if (indexRaw) {

if (lastElement != element) {
let lastLookupElement = this.elementIndexPrefix + this.serializer.serialize(lastElement);
let lastLookupElement = this.elementIndexPrefix + JSON.stringify(lastElement);
near.storageWrite(lastLookupElement, indexRaw);

@@ -82,3 +81,3 @@ }

for (let element of this.elements) {
let indexLookup = this.elementIndexPrefix + this.serializer.serialize(element);
let indexLookup = this.elementIndexPrefix + JSON.stringify(element);
near.storageRemove(indexLookup);

@@ -103,2 +102,16 @@ }

}
serialize() {
return JSON.stringify(this);
}
// converting plain object to class object
static deserialize(data) {
let set = new UnorderedSet(data.prefix);
// reconstruct UnorderedSet
set.length = data.length;
// reconstruct Vector
let elementsPrefix = data.prefix + "e";
set.elements = new Vector(elementsPrefix);
set.elements.length = data.elements.length;
return set;
}
}

32

lib/collections/vector.d.ts

@@ -1,28 +0,28 @@

import { Bytes, ClassMap } from "../utils";
import { Serializer } from 'superserial';
export declare class Vector<E> {
import { Bytes } from "../utils";
export declare class Vector {
length: number;
readonly prefix: Bytes;
readonly serializer: Serializer;
constructor(prefix: Bytes, classes?: ClassMap);
constructor(prefix: Bytes);
len(): number;
isEmpty(): boolean;
get(index: number): E | null;
swapRemove(index: number): E | null;
push(element: E): void;
pop(): E | null;
replace(index: number, element: E): E;
extend(elements: E[]): void;
[Symbol.iterator](): VectorIterator<E>;
get(index: number): unknown | null;
swapRemove(index: number): unknown | null;
push(element: unknown): void;
pop(): unknown | null;
replace(index: number, element: unknown): unknown;
extend(elements: unknown[]): void;
[Symbol.iterator](): VectorIterator;
clear(): void;
toArray(): E[];
toArray(): unknown[];
serialize(): string;
static deserialize(data: Vector): Vector;
}
export declare class VectorIterator<E> {
export declare class VectorIterator {
private current;
private vector;
constructor(vector: Vector<E>);
constructor(vector: Vector);
next(): {
value: E | null;
value: unknown | null;
done: boolean;
};
}

27

lib/collections/vector.js
import * as near from "../api";
import { u8ArrayToBytes } from "../utils";
import { Serializer } from 'superserial';
const ERR_INDEX_OUT_OF_BOUNDS = "Index out of bounds";

@@ -15,6 +14,5 @@ const ERR_INCONSISTENT_STATE = "The collection is an inconsistent state. Did previous smart contract execution terminate unexpectedly?";

export class Vector {
constructor(prefix, classes) {
constructor(prefix) {
this.length = 0;
this.prefix = prefix;
this.serializer = new Serializer({ classes });
}

@@ -32,3 +30,3 @@ len() {

let storageKey = indexToKey(this.prefix, index);
return this.serializer.deserialize(near.storageRead(storageKey));
return JSON.parse(near.storageRead(storageKey));
}

@@ -48,4 +46,4 @@ /// Removes an element from the vector and returns it in serialized form.

let last = this.pop();
if (near.storageWrite(key, this.serializer.serialize(last))) {
return this.serializer.deserialize(near.storageGetEvicted());
if (near.storageWrite(key, JSON.stringify(last))) {
return JSON.parse(near.storageGetEvicted());
}

@@ -60,3 +58,3 @@ else {

this.length += 1;
near.storageWrite(key, this.serializer.serialize(element));
near.storageWrite(key, JSON.stringify(element));
}

@@ -72,3 +70,3 @@ pop() {

if (near.storageRemove(lastKey)) {
return this.serializer.deserialize(near.storageGetEvicted());
return JSON.parse(near.storageGetEvicted());
}

@@ -86,4 +84,4 @@ else {

let key = indexToKey(this.prefix, index);
if (near.storageWrite(key, this.serializer.serialize(element))) {
return this.serializer.deserialize(near.storageGetEvicted());
if (near.storageWrite(key, JSON.stringify(element))) {
return JSON.parse(near.storageGetEvicted());
}

@@ -117,2 +115,11 @@ else {

}
serialize() {
return JSON.stringify(this);
}
// converting plain object to class object
static deserialize(data) {
let vector = new Vector(data.prefix);
vector.length = data.length;
return vector;
}
}

@@ -119,0 +126,0 @@ export class VectorIterator {

2

lib/near-bindgen.js

@@ -12,2 +12,4 @@ export function call(target, key, descriptor) {

// @ts-ignore
ret.init();
// @ts-ignore
ret.serialize();

@@ -14,0 +16,0 @@ return ret;

4

lib/near-contract.d.ts

@@ -1,2 +0,2 @@

export declare class NearContract {
export declare abstract class NearContract {
deserialize(): void;

@@ -6,2 +6,4 @@ serialize(): void;

static serializeReturn(ret: any): string;
abstract default(): any;
init(): any;
}

15

lib/near-contract.js
import * as near from "./api";
export class NearContract {
deserialize() {
let state = near.storageRead("STATE");
if (state) {
Object.assign(this, JSON.parse(state));
const rawState = near.storageRead("STATE");
if (rawState) {
const state = JSON.parse(rawState);
// reconstruction of the contract class object from plain object
let c = this.default();
Object.assign(this, state);
for (const item in c) {
if (c[item].constructor?.deserialize !== undefined) {
this[item] = c[item].constructor.deserialize(this[item]);
}
}
}

@@ -22,2 +30,3 @@ else {

}
init() { }
}

4

lib/utils.d.ts

@@ -6,4 +6,4 @@ export declare type Bytes = string;

export declare function assert(b: boolean, str: string): void;
export declare type ClassMap = {
[className: string]: ((new (...args: any[]) => any) | Function);
export declare type Mutable<T> = {
-readonly [P in keyof T]: T[P];
};

5

package.json
{
"name": "near-sdk-js",
"version": "0.4.0-4",
"version": "0.4.0-5",
"description": "High Level JavaScript SDK for building smart contracts on NEAR",

@@ -33,3 +33,3 @@ "main": "lib/index.js",

"test:enclaved:examples": "cd jsvm/examples && yarn && yarn rebuild && yarn test && cd ../..",
"postinstall": "cd cli && mkdir -p deps && cd deps && node ../post-install.js"
"postinstall": "cd cli && rm -rf deps && mkdir -p deps && cd deps && node ../post-install.js"
},

@@ -49,3 +49,2 @@ "bin": {

"rollup-plugin-sourcemaps": "^0.6.3",
"superserial": "^0.3.0",
"yargs": "^17.5.1"

@@ -52,0 +51,0 @@ },

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc