amogus-sdk-internal-utils 0.35.2

package/dist/utils/messageFactory.cjs

@@ -0,0 +1,137 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_config = require('../config.cjs');
+const require_assert = require('./assert.cjs');
+let _scure_base = require("@scure/base");
+let _noble_hashes_sha256 = require("@noble/hashes/sha256");
+
+//#region src/utils/messageFactory.ts
+var messageFactory_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	makeChallenge: () => makeChallenge,
+	makeEmptyMessage: () => makeEmptyMessage,
+	makeInnerSwapMessage: () => makeInnerSwapMessage,
+	makeInnerTransferMessage: () => makeInnerTransferMessage,
+	makeSwapMessage: () => makeSwapMessage,
+	randomDefuseNonce: () => randomDefuseNonce
+});
+/**
+* @param tokenDeltas
+* @param signerId
+* @param deadlineTimestamp Unix timestamp in milliseconds
+* @param referral
+* @param memo
+* @param appFee
+* @param appFeeRecipient
+*/
+function makeInnerSwapMessage({ tokenDeltas, signerId, deadlineTimestamp, referral, memo, appFee, appFeeRecipient }) {
+	const tokenDiff = {};
+	const tokenDiffNum = {};
+	const intents = [{
+		intent: "token_diff",
+		diff: tokenDiff,
+		referral,
+		memo
+	}];
+	if (appFee.length) intents.push({
+		intent: "transfer",
+		tokens: Object.fromEntries(appFee.map(([token, amount]) => [token, amount.toString()])),
+		receiver_id: appFeeRecipient,
+		memo: "APP_FEE"
+	});
+	for (const [token, amount] of tokenDeltas) {
+		tokenDiffNum[token] ??= 0n;
+		tokenDiffNum[token] += amount;
+		tokenDiff[token] = tokenDiffNum[token].toString();
+	}
+	if (Object.keys(tokenDiff).length === 0) return {
+		deadline: new Date(deadlineTimestamp).toISOString(),
+		intents: [],
+		signer_id: signerId
+	};
+	return {
+		deadline: new Date(deadlineTimestamp).toISOString(),
+		intents,
+		signer_id: signerId
+	};
+}
+function makeSwapMessage({ innerMessage, nonce = randomDefuseNonce() }) {
+	const payload = {
+		signer_id: innerMessage.signer_id,
+		verifying_contract: require_config.config.env.contractID,
+		deadline: innerMessage.deadline,
+		nonce: _scure_base.base64.encode(nonce),
+		intents: innerMessage.intents
+	};
+	const payloadSerialized = JSON.stringify(payload);
+	const payloadBytes = new TextEncoder().encode(payloadSerialized);
+	return {
+		NEP413: {
+			message: JSON.stringify(innerMessage),
+			recipient: require_config.config.env.contractID,
+			nonce
+		},
+		ERC191: { message: JSON.stringify(payload, null, 2) },
+		SOLANA: { message: payloadBytes },
+		STELLAR: { message: JSON.stringify(payload, null, 2) },
+		WEBAUTHN: {
+			challenge: makeChallenge(payloadBytes),
+			payload: payloadSerialized,
+			parsedPayload: payload
+		},
+		TON_CONNECT: { message: {
+			type: "text",
+			text: JSON.stringify(payload, null, 2)
+		} },
+		TRON: { message: JSON.stringify(payload, null, 2) }
+	};
+}
+function makeEmptyMessage({ signerId, deadlineTimestamp, nonce = randomDefuseNonce() }) {
+	return makeSwapMessage({
+		innerMessage: {
+			deadline: new Date(deadlineTimestamp).toISOString(),
+			intents: [],
+			signer_id: signerId
+		},
+		nonce
+	});
+}
+function randomDefuseNonce() {
+	return randomBytes(32);
+}
+function randomBytes(length) {
+	return crypto.getRandomValues(new Uint8Array(length));
+}
+/**
+* Converts UTF-8 string to bytes for WebAuthn challenge
+*/
+function makeChallenge(payload) {
+	const hash = (0, _noble_hashes_sha256.sha256)(payload);
+	return new Uint8Array(hash);
+}
+function makeInnerTransferMessage({ tokenDeltas, signerId, deadlineTimestamp, receiverId, memo }) {
+	const tokens = {};
+	const seenTokens = /* @__PURE__ */ new Set();
+	for (const [token, amount] of tokenDeltas) {
+		require_assert.assert(!seenTokens.has(token), `Duplicate token found: ${token}`);
+		seenTokens.add(token);
+		require_assert.assert(amount > 0n, `Transfer amount must be positive, got: ${amount} for token ${token}`);
+		tokens[token] = amount.toString();
+	}
+	return {
+		deadline: new Date(deadlineTimestamp).toISOString(),
+		intents: [{
+			intent: "transfer",
+			tokens,
+			receiver_id: receiverId,
+			...memo ? { memo } : {}
+		}],
+		signer_id: signerId
+	};
+}
+
+//#endregion
+Object.defineProperty(exports, 'messageFactory_exports', {
+  enumerable: true,
+  get: function () {
+    return messageFactory_exports;
+  }
+});

package/dist/utils/messageFactory.d.cts

@@ -0,0 +1,70 @@
+import { IntentsUserId } from "../types/intentsUserId.cjs";
+import { WalletMessage } from "../types/walletMessage.cjs";
+import { Nep413DefuseMessageFor_DefuseIntents } from "amogus-sdk-contract-types";
+
+//#region src/utils/messageFactory.d.ts
+declare namespace messageFactory_d_exports {
+  export { makeChallenge, makeEmptyMessage, makeInnerSwapMessage, makeInnerTransferMessage, makeSwapMessage, randomDefuseNonce };
+}
+/**
+ * @param tokenDeltas
+ * @param signerId
+ * @param deadlineTimestamp Unix timestamp in milliseconds
+ * @param referral
+ * @param memo
+ * @param appFee
+ * @param appFeeRecipient
+ */
+declare function makeInnerSwapMessage({
+  tokenDeltas,
+  signerId,
+  deadlineTimestamp,
+  referral,
+  memo,
+  appFee,
+  appFeeRecipient
+}: {
+  tokenDeltas: [string, bigint][];
+  signerId: IntentsUserId;
+  deadlineTimestamp: number;
+  referral?: string;
+  memo?: string;
+  appFee: [string, bigint][];
+  appFeeRecipient: string;
+}): Nep413DefuseMessageFor_DefuseIntents;
+declare function makeSwapMessage({
+  innerMessage,
+  nonce
+}: {
+  innerMessage: Nep413DefuseMessageFor_DefuseIntents;
+  nonce?: Uint8Array;
+}): WalletMessage;
+declare function makeEmptyMessage({
+  signerId,
+  deadlineTimestamp,
+  nonce
+}: {
+  signerId: IntentsUserId;
+  deadlineTimestamp: number;
+  nonce?: Uint8Array;
+}): WalletMessage;
+declare function randomDefuseNonce(): Uint8Array;
+/**
+ * Converts UTF-8 string to bytes for WebAuthn challenge
+ */
+declare function makeChallenge(payload: Uint8Array): Uint8Array;
+declare function makeInnerTransferMessage({
+  tokenDeltas,
+  signerId,
+  deadlineTimestamp,
+  receiverId,
+  memo
+}: {
+  tokenDeltas: [string, bigint][];
+  signerId: IntentsUserId;
+  deadlineTimestamp: number;
+  receiverId: string;
+  memo?: string;
+}): Nep413DefuseMessageFor_DefuseIntents;
+//#endregion
+export { messageFactory_d_exports };

package/dist/utils/messageFactory.d.ts

@@ -0,0 +1,70 @@
+import { IntentsUserId } from "../types/intentsUserId.js";
+import { WalletMessage } from "../types/walletMessage.js";
+import { Nep413DefuseMessageFor_DefuseIntents } from "amogus-sdk-contract-types";
+
+//#region src/utils/messageFactory.d.ts
+declare namespace messageFactory_d_exports {
+  export { makeChallenge, makeEmptyMessage, makeInnerSwapMessage, makeInnerTransferMessage, makeSwapMessage, randomDefuseNonce };
+}
+/**
+ * @param tokenDeltas
+ * @param signerId
+ * @param deadlineTimestamp Unix timestamp in milliseconds
+ * @param referral
+ * @param memo
+ * @param appFee
+ * @param appFeeRecipient
+ */
+declare function makeInnerSwapMessage({
+  tokenDeltas,
+  signerId,
+  deadlineTimestamp,
+  referral,
+  memo,
+  appFee,
+  appFeeRecipient
+}: {
+  tokenDeltas: [string, bigint][];
+  signerId: IntentsUserId;
+  deadlineTimestamp: number;
+  referral?: string;
+  memo?: string;
+  appFee: [string, bigint][];
+  appFeeRecipient: string;
+}): Nep413DefuseMessageFor_DefuseIntents;
+declare function makeSwapMessage({
+  innerMessage,
+  nonce
+}: {
+  innerMessage: Nep413DefuseMessageFor_DefuseIntents;
+  nonce?: Uint8Array;
+}): WalletMessage;
+declare function makeEmptyMessage({
+  signerId,
+  deadlineTimestamp,
+  nonce
+}: {
+  signerId: IntentsUserId;
+  deadlineTimestamp: number;
+  nonce?: Uint8Array;
+}): WalletMessage;
+declare function randomDefuseNonce(): Uint8Array;
+/**
+ * Converts UTF-8 string to bytes for WebAuthn challenge
+ */
+declare function makeChallenge(payload: Uint8Array): Uint8Array;
+declare function makeInnerTransferMessage({
+  tokenDeltas,
+  signerId,
+  deadlineTimestamp,
+  receiverId,
+  memo
+}: {
+  tokenDeltas: [string, bigint][];
+  signerId: IntentsUserId;
+  deadlineTimestamp: number;
+  receiverId: string;
+  memo?: string;
+}): Nep413DefuseMessageFor_DefuseIntents;
+//#endregion
+export { messageFactory_d_exports };

package/dist/utils/messageFactory.js

@@ -0,0 +1,132 @@
+import { __exportAll } from "../_virtual/rolldown_runtime.js";
+import { config } from "../config.js";
+import { assert } from "./assert.js";
+import { base64 } from "@scure/base";
+import { sha256 } from "@noble/hashes/sha256";
+
+//#region src/utils/messageFactory.ts
+var messageFactory_exports = /* @__PURE__ */ __exportAll({
+	makeChallenge: () => makeChallenge,
+	makeEmptyMessage: () => makeEmptyMessage,
+	makeInnerSwapMessage: () => makeInnerSwapMessage,
+	makeInnerTransferMessage: () => makeInnerTransferMessage,
+	makeSwapMessage: () => makeSwapMessage,
+	randomDefuseNonce: () => randomDefuseNonce
+});
+/**
+* @param tokenDeltas
+* @param signerId
+* @param deadlineTimestamp Unix timestamp in milliseconds
+* @param referral
+* @param memo
+* @param appFee
+* @param appFeeRecipient
+*/
+function makeInnerSwapMessage({ tokenDeltas, signerId, deadlineTimestamp, referral, memo, appFee, appFeeRecipient }) {
+	const tokenDiff = {};
+	const tokenDiffNum = {};
+	const intents = [{
+		intent: "token_diff",
+		diff: tokenDiff,
+		referral,
+		memo
+	}];
+	if (appFee.length) intents.push({
+		intent: "transfer",
+		tokens: Object.fromEntries(appFee.map(([token, amount]) => [token, amount.toString()])),
+		receiver_id: appFeeRecipient,
+		memo: "APP_FEE"
+	});
+	for (const [token, amount] of tokenDeltas) {
+		tokenDiffNum[token] ??= 0n;
+		tokenDiffNum[token] += amount;
+		tokenDiff[token] = tokenDiffNum[token].toString();
+	}
+	if (Object.keys(tokenDiff).length === 0) return {
+		deadline: new Date(deadlineTimestamp).toISOString(),
+		intents: [],
+		signer_id: signerId
+	};
+	return {
+		deadline: new Date(deadlineTimestamp).toISOString(),
+		intents,
+		signer_id: signerId
+	};
+}
+function makeSwapMessage({ innerMessage, nonce = randomDefuseNonce() }) {
+	const payload = {
+		signer_id: innerMessage.signer_id,
+		verifying_contract: config.env.contractID,
+		deadline: innerMessage.deadline,
+		nonce: base64.encode(nonce),
+		intents: innerMessage.intents
+	};
+	const payloadSerialized = JSON.stringify(payload);
+	const payloadBytes = new TextEncoder().encode(payloadSerialized);
+	return {
+		NEP413: {
+			message: JSON.stringify(innerMessage),
+			recipient: config.env.contractID,
+			nonce
+		},
+		ERC191: { message: JSON.stringify(payload, null, 2) },
+		SOLANA: { message: payloadBytes },
+		STELLAR: { message: JSON.stringify(payload, null, 2) },
+		WEBAUTHN: {
+			challenge: makeChallenge(payloadBytes),
+			payload: payloadSerialized,
+			parsedPayload: payload
+		},
+		TON_CONNECT: { message: {
+			type: "text",
+			text: JSON.stringify(payload, null, 2)
+		} },
+		TRON: { message: JSON.stringify(payload, null, 2) }
+	};
+}
+function makeEmptyMessage({ signerId, deadlineTimestamp, nonce = randomDefuseNonce() }) {
+	return makeSwapMessage({
+		innerMessage: {
+			deadline: new Date(deadlineTimestamp).toISOString(),
+			intents: [],
+			signer_id: signerId
+		},
+		nonce
+	});
+}
+function randomDefuseNonce() {
+	return randomBytes(32);
+}
+function randomBytes(length) {
+	return crypto.getRandomValues(new Uint8Array(length));
+}
+/**
+* Converts UTF-8 string to bytes for WebAuthn challenge
+*/
+function makeChallenge(payload) {
+	const hash = sha256(payload);
+	return new Uint8Array(hash);
+}
+function makeInnerTransferMessage({ tokenDeltas, signerId, deadlineTimestamp, receiverId, memo }) {
+	const tokens = {};
+	const seenTokens = /* @__PURE__ */ new Set();
+	for (const [token, amount] of tokenDeltas) {
+		assert(!seenTokens.has(token), `Duplicate token found: ${token}`);
+		seenTokens.add(token);
+		assert(amount > 0n, `Transfer amount must be positive, got: ${amount} for token ${token}`);
+		tokens[token] = amount.toString();
+	}
+	return {
+		deadline: new Date(deadlineTimestamp).toISOString(),
+		intents: [{
+			intent: "transfer",
+			tokens,
+			receiver_id: receiverId,
+			...memo ? { memo } : {}
+		}],
+		signer_id: signerId
+	};
+}
+
+//#endregion
+export { messageFactory_exports };

package/dist/utils/multiPayload/webauthn.cjs

@@ -0,0 +1,27 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_assert = require('../assert.cjs');
+const require_webAuthn = require('../webAuthn.cjs');
+let _scure_base = require("@scure/base");
+
+//#region src/utils/multiPayload/webauthn.ts
+function makeWebAuthnMultiPayload(userInfo, signature) {
+	require_assert.assert(userInfo.userChainType === "webauthn", "User chain and signature chain must match");
+	const { curveType, publicKey } = require_webAuthn.parsePublicKey(userInfo.userAddress);
+	return {
+		standard: "webauthn",
+		payload: signature.signedData.payload,
+		public_key: formatPublicKey(publicKey, curveType),
+		signature: formatSignature(require_webAuthn.extractRawSignature(signature.signatureData.signature, curveType), curveType),
+		client_data_json: new TextDecoder("utf-8").decode(signature.signatureData.clientDataJSON),
+		authenticator_data: _scure_base.base64urlnopad.encode(new Uint8Array(signature.signatureData.authenticatorData))
+	};
+}
+function formatPublicKey(publicKey, curveType) {
+	return `${curveType}:${_scure_base.base58.encode(publicKey)}`;
+}
+function formatSignature(signature, curveType) {
+	return `${curveType}:${_scure_base.base58.encode(new Uint8Array(signature))}`;
+}
+
+//#endregion
+exports.makeWebAuthnMultiPayload = makeWebAuthnMultiPayload;

package/dist/utils/multiPayload/webauthn.js

@@ -0,0 +1,26 @@
+import { assert } from "../assert.js";
+import { extractRawSignature, parsePublicKey } from "../webAuthn.js";
+import { base58, base64urlnopad } from "@scure/base";
+
+//#region src/utils/multiPayload/webauthn.ts
+function makeWebAuthnMultiPayload(userInfo, signature) {
+	assert(userInfo.userChainType === "webauthn", "User chain and signature chain must match");
+	const { curveType, publicKey } = parsePublicKey(userInfo.userAddress);
+	return {
+		standard: "webauthn",
+		payload: signature.signedData.payload,
+		public_key: formatPublicKey(publicKey, curveType),
+		signature: formatSignature(extractRawSignature(signature.signatureData.signature, curveType), curveType),
+		client_data_json: new TextDecoder("utf-8").decode(signature.signatureData.clientDataJSON),
+		authenticator_data: base64urlnopad.encode(new Uint8Array(signature.signatureData.authenticatorData))
+	};
+}
+function formatPublicKey(publicKey, curveType) {
+	return `${curveType}:${base58.encode(publicKey)}`;
+}
+function formatSignature(signature, curveType) {
+	return `${curveType}:${base58.encode(new Uint8Array(signature))}`;
+}
+
+//#endregion
+export { makeWebAuthnMultiPayload };

package/dist/utils/near.cjs

@@ -0,0 +1,58 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let valibot = require("valibot");
+valibot = require_rolldown_runtime.__toESM(valibot);
+
+//#region src/utils/near.ts
+/**
+* Use this function to decode a raw response from `nearClient.query()`
+*/
+function decodeQueryResult(response, schema) {
+	const parsed = valibot.parse(valibot.object({ result: valibot.array(valibot.number()) }), response);
+	const uint8Array = new Uint8Array(parsed.result);
+	const result = new TextDecoder().decode(uint8Array);
+	return valibot.parse(schema, JSON.parse(result));
+}
+function getBlockReference({ blockId, finality }) {
+	if (blockId != null) return { blockId };
+	if (finality != null) return { finality };
+	return { finality: "optimistic" };
+}
+async function queryContract({ nearClient, contractId, methodName, args, blockId, finality, schema }) {
+	return decodeQueryResult(await nearClient.query({
+		request_type: "call_function",
+		account_id: contractId,
+		method_name: methodName,
+		args_base64: btoa(JSON.stringify(args)),
+		...getBlockReference({
+			blockId,
+			finality
+		})
+	}), schema);
+}
+const ACCOUNT_ID_REGEX = /^(([a-z\d]+[-_])*[a-z\d]+\.)*([a-z\d]+[-_])*[a-z\d]+$/;
+const MIN_ACCOUNT_ID_LENGTH = 2;
+const ETH_IMPLICIT_ACCOUNT_LENGTH = 42;
+const NEAR_IMPLICIT_ACCOUNT_LENGTH = 64;
+function validateNearAddress(accountId) {
+	if (accountId.length < MIN_ACCOUNT_ID_LENGTH || accountId.length > NEAR_IMPLICIT_ACCOUNT_LENGTH) return false;
+	if (isImplicitAccount(accountId)) return true;
+	return ACCOUNT_ID_REGEX.test(accountId);
+}
+function isEthImplicitAccount(accountId) {
+	return accountId.length === ETH_IMPLICIT_ACCOUNT_LENGTH && accountId.startsWith("0x") && /^[0-9a-f]+$/.test(accountId.slice(2));
+}
+function isNearDeterministic(accountId) {
+	return accountId.length === ETH_IMPLICIT_ACCOUNT_LENGTH && accountId.startsWith("0s") && /^[0-9a-f]+$/.test(accountId.slice(2));
+}
+function isNearImplicit(accountId) {
+	return accountId.length === NEAR_IMPLICIT_ACCOUNT_LENGTH && /^[0-9a-f]+$/.test(accountId);
+}
+function isImplicitAccount(accountId) {
+	return isEthImplicitAccount(accountId) || isNearImplicit(accountId) || isNearDeterministic(accountId);
+}
+
+//#endregion
+exports.decodeQueryResult = decodeQueryResult;
+exports.isImplicitAccount = isImplicitAccount;
+exports.queryContract = queryContract;
+exports.validateNearAddress = validateNearAddress;

package/dist/utils/near.d.cts

@@ -0,0 +1,35 @@
+import * as v from "valibot";
+import { providers } from "near-api-js";
+import { BlockId, Finality } from "near-api-js/lib/providers/provider";
+
+//#region src/utils/near.d.ts
+
+/**
+ * Use this function to decode a raw response from `nearClient.query()`
+ */
+declare function decodeQueryResult<T extends v.BaseSchema<TInput, TOutput, TIssue>, TInput, TOutput, TIssue extends v.BaseIssue<unknown>>(response: unknown, schema: T): v.InferOutput<T>;
+type OptionalBlockReference = {
+  blockId?: BlockId;
+  finality?: Finality;
+};
+declare function queryContract<T extends v.BaseSchema<TInput, TOutput, TIssue>, TInput, TOutput, TIssue extends v.BaseIssue<unknown>>({
+  nearClient,
+  contractId,
+  methodName,
+  args,
+  blockId,
+  finality,
+  schema
+}: {
+  nearClient: providers.Provider;
+  contractId: string;
+  methodName: string;
+  args: Record<string, unknown>;
+  blockId?: BlockId;
+  finality?: Finality;
+  schema: T;
+}): Promise<v.InferOutput<T>>;
+declare function validateNearAddress(accountId: string): boolean;
+declare function isImplicitAccount(accountId: string): boolean;
+//#endregion
+export { OptionalBlockReference, decodeQueryResult, isImplicitAccount, queryContract, validateNearAddress };

package/dist/utils/near.d.ts

@@ -0,0 +1,35 @@
+import * as v from "valibot";
+import { providers } from "near-api-js";
+import { BlockId, Finality } from "near-api-js/lib/providers/provider";
+
+//#region src/utils/near.d.ts
+
+/**
+ * Use this function to decode a raw response from `nearClient.query()`
+ */
+declare function decodeQueryResult<T extends v.BaseSchema<TInput, TOutput, TIssue>, TInput, TOutput, TIssue extends v.BaseIssue<unknown>>(response: unknown, schema: T): v.InferOutput<T>;
+type OptionalBlockReference = {
+  blockId?: BlockId;
+  finality?: Finality;
+};
+declare function queryContract<T extends v.BaseSchema<TInput, TOutput, TIssue>, TInput, TOutput, TIssue extends v.BaseIssue<unknown>>({
+  nearClient,
+  contractId,
+  methodName,
+  args,
+  blockId,
+  finality,
+  schema
+}: {
+  nearClient: providers.Provider;
+  contractId: string;
+  methodName: string;
+  args: Record<string, unknown>;
+  blockId?: BlockId;
+  finality?: Finality;
+  schema: T;
+}): Promise<v.InferOutput<T>>;
+declare function validateNearAddress(accountId: string): boolean;
+declare function isImplicitAccount(accountId: string): boolean;
+//#endregion
+export { OptionalBlockReference, decodeQueryResult, isImplicitAccount, queryContract, validateNearAddress };

package/dist/utils/near.js

@@ -0,0 +1,53 @@
+import * as v from "valibot";
+
+//#region src/utils/near.ts
+/**
+* Use this function to decode a raw response from `nearClient.query()`
+*/
+function decodeQueryResult(response, schema) {
+	const parsed = v.parse(v.object({ result: v.array(v.number()) }), response);
+	const uint8Array = new Uint8Array(parsed.result);
+	const result = new TextDecoder().decode(uint8Array);
+	return v.parse(schema, JSON.parse(result));
+}
+function getBlockReference({ blockId, finality }) {
+	if (blockId != null) return { blockId };
+	if (finality != null) return { finality };
+	return { finality: "optimistic" };
+}
+async function queryContract({ nearClient, contractId, methodName, args, blockId, finality, schema }) {
+	return decodeQueryResult(await nearClient.query({
+		request_type: "call_function",
+		account_id: contractId,
+		method_name: methodName,
+		args_base64: btoa(JSON.stringify(args)),
+		...getBlockReference({
+			blockId,
+			finality
+		})
+	}), schema);
+}
+const ACCOUNT_ID_REGEX = /^(([a-z\d]+[-_])*[a-z\d]+\.)*([a-z\d]+[-_])*[a-z\d]+$/;
+const MIN_ACCOUNT_ID_LENGTH = 2;
+const ETH_IMPLICIT_ACCOUNT_LENGTH = 42;
+const NEAR_IMPLICIT_ACCOUNT_LENGTH = 64;
+function validateNearAddress(accountId) {
+	if (accountId.length < MIN_ACCOUNT_ID_LENGTH || accountId.length > NEAR_IMPLICIT_ACCOUNT_LENGTH) return false;
+	if (isImplicitAccount(accountId)) return true;
+	return ACCOUNT_ID_REGEX.test(accountId);
+}
+function isEthImplicitAccount(accountId) {
+	return accountId.length === ETH_IMPLICIT_ACCOUNT_LENGTH && accountId.startsWith("0x") && /^[0-9a-f]+$/.test(accountId.slice(2));
+}
+function isNearDeterministic(accountId) {
+	return accountId.length === ETH_IMPLICIT_ACCOUNT_LENGTH && accountId.startsWith("0s") && /^[0-9a-f]+$/.test(accountId.slice(2));
+}
+function isNearImplicit(accountId) {
+	return accountId.length === NEAR_IMPLICIT_ACCOUNT_LENGTH && /^[0-9a-f]+$/.test(accountId);
+}
+function isImplicitAccount(accountId) {
+	return isEthImplicitAccount(accountId) || isNearImplicit(accountId) || isNearDeterministic(accountId);
+}
+
+//#endregion
+export { decodeQueryResult, isImplicitAccount, queryContract, validateNearAddress };