@tatchi-xyz/sdk 0.21.0 → 0.31.1

package/dist/esm/sdk/accountIds-DVDhXwVA.js

@@ -0,0 +1,15 @@
+import { validateNearAccountId } from "./validation-BTq6LGPp.js";
+
+//#region src/core/types/accountIds.ts
+/**
+* Convert and validate string to AccountId
+* Validates proper NEAR account format (must contain at least one dot)
+*/
+function toAccountId(accountId) {
+	const validation = validateNearAccountId(accountId);
+	if (!validation.valid) throw new Error(`Invalid NEAR account ID: ${accountId}`);
+	return accountId;
+}
+
+//#endregion
+export { toAccountId };

package/dist/esm/sdk/actions-fHadejPs.js

@@ -0,0 +1,250 @@
+import { isObject } from "./validation-BTq6LGPp.js";
+
+//#region src/core/types/actions.ts
+/**
+* Enum for all supported NEAR action types
+*/
+let ActionType = /* @__PURE__ */ function(ActionType$1) {
+	ActionType$1["CreateAccount"] = "CreateAccount";
+	ActionType$1["DeployContract"] = "DeployContract";
+	ActionType$1["FunctionCall"] = "FunctionCall";
+	ActionType$1["Transfer"] = "Transfer";
+	ActionType$1["Stake"] = "Stake";
+	ActionType$1["AddKey"] = "AddKey";
+	ActionType$1["DeleteKey"] = "DeleteKey";
+	ActionType$1["DeleteAccount"] = "DeleteAccount";
+	ActionType$1["SignedDelegate"] = "SignedDelegate";
+	ActionType$1["DeployGlobalContract"] = "DeployGlobalContract";
+	ActionType$1["UseGlobalContract"] = "UseGlobalContract";
+	return ActionType$1;
+}({});
+function isActionArgsWasm(a) {
+	return isObject(a) && "action_type" in a;
+}
+function toActionArgsWasm(action) {
+	switch (action.type) {
+		case ActionType.Transfer: return {
+			action_type: ActionType.Transfer,
+			deposit: action.amount
+		};
+		case ActionType.FunctionCall: return {
+			action_type: ActionType.FunctionCall,
+			method_name: action.methodName,
+			args: JSON.stringify(action.args),
+			gas: action.gas || "30000000000000",
+			deposit: action.deposit || "0"
+		};
+		case ActionType.AddKey:
+			const rawPermission = action.accessKey.permission;
+			const permission = rawPermission === "FullAccess" ? { FullAccess: {} } : rawPermission;
+			const accessKey = {
+				nonce: action.accessKey.nonce || 0,
+				permission
+			};
+			return {
+				action_type: ActionType.AddKey,
+				public_key: action.publicKey,
+				access_key: JSON.stringify(accessKey)
+			};
+		case ActionType.DeleteKey: return {
+			action_type: ActionType.DeleteKey,
+			public_key: action.publicKey
+		};
+		case ActionType.CreateAccount: return { action_type: ActionType.CreateAccount };
+		case ActionType.DeleteAccount: return {
+			action_type: ActionType.DeleteAccount,
+			beneficiary_id: action.beneficiaryId
+		};
+		case ActionType.DeployContract: return {
+			action_type: ActionType.DeployContract,
+			code: typeof action.code === "string" ? Array.from(new TextEncoder().encode(action.code)) : Array.from(action.code)
+		};
+		case ActionType.DeployGlobalContract: return {
+			action_type: ActionType.DeployGlobalContract,
+			code: typeof action.code === "string" ? Array.from(new TextEncoder().encode(action.code)) : Array.from(action.code),
+			deploy_mode: action.deployMode
+		};
+		case ActionType.UseGlobalContract: return {
+			action_type: ActionType.UseGlobalContract,
+			account_id: action.accountId,
+			code_hash: action.codeHash
+		};
+		case ActionType.Stake: return {
+			action_type: ActionType.Stake,
+			stake: action.stake,
+			public_key: action.publicKey
+		};
+		default: throw new Error(`Action type ${action.type} is not supported`);
+	}
+}
+/**
+* Validate action parameters before sending to worker
+*/
+function validateActionArgsWasm(actionArgsWasm) {
+	switch (actionArgsWasm.action_type) {
+		case ActionType.FunctionCall:
+			if (!actionArgsWasm.method_name) throw new Error("method_name required for FunctionCall");
+			if (!actionArgsWasm.args) throw new Error("args required for FunctionCall");
+			if (!actionArgsWasm.gas) throw new Error("gas required for FunctionCall");
+			if (!actionArgsWasm.deposit) throw new Error("deposit required for FunctionCall");
+			if (typeof actionArgsWasm.args !== "string") throw new Error("FunctionCall action args must be a valid JSON string");
+			try {
+				JSON.parse(actionArgsWasm.args);
+			} catch {
+				throw new Error("FunctionCall action args must be valid JSON string");
+			}
+			break;
+		case ActionType.Transfer:
+			if (!actionArgsWasm.deposit) throw new Error("deposit required for Transfer");
+			break;
+		case ActionType.CreateAccount: break;
+		case ActionType.DeployContract:
+			if (!actionArgsWasm.code || actionArgsWasm.code.length === 0) throw new Error("code required for DeployContract");
+			break;
+		case ActionType.Stake:
+			if (!actionArgsWasm.stake) throw new Error("stake amount required for Stake");
+			if (!actionArgsWasm.public_key) throw new Error("public_key required for Stake");
+			break;
+		case ActionType.AddKey:
+			if (!actionArgsWasm.public_key) throw new Error("public_key required for AddKey");
+			if (!actionArgsWasm.access_key) throw new Error("access_key required for AddKey");
+			if (typeof actionArgsWasm.access_key !== "string") throw new Error("AddKey action access_key must be a valid JSON string");
+			try {
+				JSON.parse(actionArgsWasm.access_key);
+			} catch {
+				throw new Error("AddKey action access_key must be valid JSON string");
+			}
+			break;
+		case ActionType.DeleteKey:
+			if (!actionArgsWasm.public_key) throw new Error("public_key required for DeleteKey");
+			break;
+		case ActionType.DeleteAccount:
+			if (!actionArgsWasm.beneficiary_id) throw new Error("beneficiary_id required for DeleteAccount");
+			break;
+		case ActionType.SignedDelegate: {
+			const payload = actionArgsWasm;
+			if (!payload.delegate_action || typeof payload.delegate_action !== "object") throw new Error("delegate_action required for SignedDelegate");
+			if (!payload.signature || typeof payload.signature !== "object") throw new Error("signature required for SignedDelegate");
+			break;
+		}
+		case ActionType.DeployGlobalContract:
+			if (!actionArgsWasm.code || actionArgsWasm.code.length === 0) throw new Error("code required for DeployGlobalContract");
+			if (!actionArgsWasm.deploy_mode || actionArgsWasm.deploy_mode !== "CodeHash" && actionArgsWasm.deploy_mode !== "AccountId") throw new Error("deploy_mode must be CodeHash or AccountId for DeployGlobalContract");
+			break;
+		case ActionType.UseGlobalContract: {
+			const hasAccountId = !!actionArgsWasm.account_id;
+			const hasCodeHash = !!actionArgsWasm.code_hash;
+			if (hasAccountId === hasCodeHash) throw new Error("UseGlobalContract requires exactly one of account_id or code_hash");
+			break;
+		}
+		default: throw new Error(`Unsupported action type: ${actionArgsWasm.action_type}`);
+	}
+}
+/**
+* Convert a single ActionArgsWasm (snake_case, stringified fields) to ActionArgs (camelCase, typed fields)
+*/
+function fromActionArgsWasm(a) {
+	switch (a.action_type) {
+		case ActionType.FunctionCall: {
+			let parsedArgs = {};
+			try {
+				if (typeof a.args === "string") parsedArgs = a.args ? JSON.parse(a.args) : {};
+				else parsedArgs = a.args || {};
+			} catch {
+				parsedArgs = {};
+			}
+			return {
+				type: ActionType.FunctionCall,
+				methodName: a.method_name,
+				args: parsedArgs,
+				gas: a.gas,
+				deposit: a.deposit
+			};
+		}
+		case ActionType.Transfer: return {
+			type: ActionType.Transfer,
+			amount: a.deposit
+		};
+		case ActionType.CreateAccount: return { type: ActionType.CreateAccount };
+		case ActionType.DeployContract: {
+			const codeBytes = Array.isArray(a.code) ? new Uint8Array(a.code) : new Uint8Array();
+			return {
+				type: ActionType.DeployContract,
+				code: codeBytes
+			};
+		}
+		case ActionType.DeployGlobalContract: {
+			const codeBytes = Array.isArray(a.code) ? new Uint8Array(a.code) : new Uint8Array();
+			return {
+				type: ActionType.DeployGlobalContract,
+				code: codeBytes,
+				deployMode: a.deploy_mode
+			};
+		}
+		case ActionType.Stake: return {
+			type: ActionType.Stake,
+			stake: a.stake,
+			publicKey: a.public_key
+		};
+		case ActionType.AddKey: {
+			let accessKey;
+			try {
+				accessKey = JSON.parse(a.access_key);
+			} catch {
+				accessKey = {
+					nonce: BigInt(0),
+					permission: "FullAccess"
+				};
+			}
+			const permission = accessKey?.permission;
+			let normalizedPermission = "FullAccess";
+			if (isObject(permission)) {
+				if ("FullAccess" in permission) normalizedPermission = "FullAccess";
+				else if ("FunctionCall" in permission) {
+					const fc = permission.FunctionCall;
+					normalizedPermission = { FunctionCall: {
+						allowance: fc.allowance,
+						receiver_id: fc.receiver_id,
+						method_names: fc.method_names
+					} };
+				}
+			}
+			return {
+				type: ActionType.AddKey,
+				publicKey: a.public_key,
+				accessKey: {
+					nonce: typeof accessKey?.nonce === "number" ? accessKey.nonce : 0,
+					permission: normalizedPermission
+				}
+			};
+		}
+		case ActionType.DeleteKey: return {
+			type: ActionType.DeleteKey,
+			publicKey: a.public_key
+		};
+		case ActionType.DeleteAccount: return {
+			type: ActionType.DeleteAccount,
+			beneficiaryId: a.beneficiary_id
+		};
+		case ActionType.UseGlobalContract: return {
+			type: ActionType.UseGlobalContract,
+			accountId: a.account_id,
+			codeHash: a.code_hash
+		};
+		default: throw new Error(`Unsupported wasm action_type: ${a?.action_type}`);
+	}
+}
+/** Convert a TransactionInputWasm structure to TransactionInput */
+function fromTransactionInputWasm(tx) {
+	return {
+		receiverId: tx.receiverId,
+		actions: tx.actions.map(fromActionArgsWasm)
+	};
+}
+/** Convert an array of TransactionInputWasm to TransactionInput[] */
+function fromTransactionInputsWasm(txs) {
+	return (txs || []).map(fromTransactionInputWasm);
+}
+
+//#endregion
+export { ActionType, fromTransactionInputsWasm, isActionArgsWasm, toActionArgsWasm, validateActionArgsWasm };

package/dist/esm/sdk/base64-dqpWgddX.js

@@ -0,0 +1,66 @@
+//#region src/utils/base64.ts
+/**
+* Encodes binary data to standard base64 format for NEAR RPC compatibility.
+* Uses standard base64 characters (+, /, =) rather than base64url encoding.
+*
+* Important: Avoids spreading large arrays into String.fromCharCode(...) which
+* can overflow the JS call stack when encoding big WASM binaries.
+*
+* @param value - ArrayBufferLike or ArrayBufferView containing the binary data to encode
+* @returns Standard base64-encoded string with padding
+*/
+const base64Encode = (value) => {
+	const bytes = ArrayBuffer.isView(value) ? new Uint8Array(value.buffer, value.byteOffset, value.byteLength) : new Uint8Array(value);
+	let binary = "";
+	for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+	return btoa(binary);
+};
+/**
+* Decodes a standard base64-encoded string into a Uint8Array.
+* Handles standard base64 format with +, /, and = characters.
+*
+* @param base64 - The base64-encoded string to decode
+* @returns Uint8Array containing the decoded bytes
+* @throws Error if decoding fails due to invalid base64 input
+*/
+function base64Decode(base64) {
+	const binaryString = atob(base64);
+	const bytes = new Uint8Array(binaryString.length);
+	for (let i = 0; i < binaryString.length; i++) bytes[i] = binaryString.charCodeAt(i);
+	return bytes;
+}
+/**
+* Encodes an ArrayBuffer into a base64url string.
+* Converts binary data to base64 then replaces standard base64 characters with URL-safe ones:
+* + -> -
+* / -> _
+* Removes padding = characters
+*
+* Used for WebAuthn API compatibility in browser environments.
+* Equivalent to Buffer.from(value).toString('base64url') in Node.js.
+*
+* @param value - The ArrayBufferLike or ArrayBufferView to encode
+* @returns A base64url-encoded string without padding
+*/
+const base64UrlEncode = (value) => {
+	return base64Encode(value).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+};
+/**
+* Decodes a base64url-encoded string into a Uint8Array.
+* Handles base64url format by replacing URL-safe characters and adding padding.
+*
+* @param base64Url - The base64url-encoded string to decode
+* @returns Uint8Array containing the decoded bytes
+* @throws Error if decoding fails due to invalid base64url input
+*/
+function base64UrlDecode(base64Url) {
+	const padding = "=".repeat((4 - base64Url.length % 4) % 4);
+	const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/") + padding;
+	const binaryString = atob(base64);
+	const bytes = new Uint8Array(binaryString.length);
+	for (let i = 0; i < binaryString.length; i++) bytes[i] = binaryString.charCodeAt(i);
+	return bytes;
+}
+
+//#endregion
+export { base64Decode, base64Encode, base64UrlDecode, base64UrlEncode };