@seams/wallet 0.15.6 → 0.18.0

package/dist/esm/core/signingEngine/uiConfirm/ui/transaction-display/tree.js

@@ -185,27 +185,7 @@ function buildActionNode(action, idx) {
 				type: "file"
 			}];
 			break;
-		default: {
-			let raw = "";
-			try {
-				raw = JSON.stringify(action, null, 2);
-			} catch {
-				raw = String(action);
-			}
-			actionNodes = [{
-				id: `a${idx}-action`,
-				label: `Action: ${action.type || "Unknown"}`,
-				open: false,
-				type: "file"
-			}, {
-				id: `a${idx}-raw`,
-				label: "Raw Data",
-				type: "file",
-				open: false,
-				content: raw
-			}];
-			break;
-		}
+		default: return assertNeverAction(action);
 	}
 	return {
 		id: `action-${idx}`,
@@ -218,6 +198,9 @@ function buildActionNode(action, idx) {
 		children: actionNodes
 	};
 }
+function assertNeverAction(action) {
+	throw new Error(`Unsupported NEAR action: ${String(action)}`);
+}
 function buildTransactionNode(tx, tIdx, totalTransactions) {
 	const actionFolders = tx.actions.map((action, idx) => buildActionNode(action, idx));
 	return {

package/dist/esm/core/types/actionBuilders.js

@@ -1,4 +1,5 @@
 import { ActionType } from "../../shared-ts/src/near/actions.js";
+import { toYoctoNear } from "./amounts.js";
 //#region src/core/types/actionBuilders.ts
 /**
 * Action builders.
@@ -25,11 +26,24 @@ function functionCall(args) {
 		...args.deposit !== void 0 ? { deposit: args.deposit } : {}
 	};
 }
-/** Transfer NEAR. `amount` is in yoctoNEAR. */
+/**
+* Transfer NEAR. Write a literal `amount` with its unit, `'1 NEAR'` or
+* `'1000 yoctoNEAR'`. Build a computed amount with `parseNear` (decimal NEAR)
+* or `yoctoNear` (already in yoctoNEAR). A string without a unit does not
+* compile.
+*
+* @example
+* transfer('1 NEAR');
+* transfer('0.5 NEAR');
+* transfer(parseNear(amountInput)); // a decimal NEAR string from elsewhere
+* transfer(yoctoNear(balance)); // already in yoctoNEAR
+*
+* @throws {AmountError} for a negative, non-numeric or over-precise amount.
+*/
 function transfer(amount) {
 	return {
 		type: ActionType.Transfer,
-		amount
+		amount: toYoctoNear(amount)
 	};
 }
 function createAccount() {

package/dist/esm/core/types/amounts.js

@@ -0,0 +1,83 @@
+//#region src/core/types/amounts.ts
+var AmountError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "AmountError";
+	}
+};
+const DECIMAL_AMOUNT = /^(\d+)(?:\.(\d+))?$/;
+/**
+* Convert a decimal amount to integer base units: `amount * 10^decimals`.
+* Use it for a token whose decimals are not 18 or 24, such as an ERC-20.
+*
+* @example
+* parseUnits('1.5', 6); // 1500000n
+*
+* @throws {AmountError} `invalid_format` for anything other than digits with
+* an optional fraction (no sign, unit or exponent), and `too_many_decimals`
+* for more fractional digits than `decimals`.
+*/
+function parseUnits(amount, decimals) {
+	if (!Number.isSafeInteger(decimals) || decimals < 0) throw new RangeError(`decimals must be a non-negative integer, got ${decimals}`);
+	const match = DECIMAL_AMOUNT.exec(amount);
+	if (!match) throw new AmountError("invalid_format", `Invalid amount ${JSON.stringify(amount)}: expected a decimal such as '1' or '0.5'`);
+	const [, whole, fraction = ""] = match;
+	if (fraction.length > decimals) throw new AmountError("too_many_decimals", `Invalid amount ${JSON.stringify(amount)}: at most ${decimals} decimal places`);
+	return BigInt(whole + fraction.padEnd(decimals, "0"));
+}
+/**
+* Convert a decimal NEAR amount to yoctoNEAR.
+*
+* @example
+* parseNear('1'); // '1000000000000000000000000'
+* parseNear('0.5'); // '500000000000000000000000'
+*
+* @throws {AmountError} as `parseUnits`, with at most 24 decimal places.
+*/
+function parseNear(amount) {
+	return parseUnits(amount, 24).toString();
+}
+/**
+* Take an amount that is already in yoctoNEAR.
+*
+* @example
+* yoctoNear('1000000000000000000000000'); // 1 NEAR
+*
+* @throws {AmountError} unless `amount` is a non-negative integer.
+*/
+function yoctoNear(amount) {
+	return parseUnits(typeof amount === "bigint" ? amount.toString() : amount, 0).toString();
+}
+const YOCTO_NEAR_SUFFIX = " yoctoNEAR";
+const NEAR_SUFFIX = " NEAR";
+/**
+* Resolve a `NearAmount` to yoctoNEAR with the same exact parsers.
+*
+* @throws {AmountError} for a negative, non-numeric or over-precise amount,
+* or for spacing other than one space before the unit.
+*/
+function toYoctoNear(amount) {
+	if (amount.endsWith(YOCTO_NEAR_SUFFIX)) return yoctoNear(amount.slice(0, -10));
+	if (amount.endsWith(NEAR_SUFFIX)) return parseNear(amount.slice(0, -5));
+	return yoctoNear(amount);
+}
+/**
+* Convert a decimal amount of an EVM chain's native coin to wei
+* (1 coin = 10^18 wei). "Ether" names the 10^18 denomination, so this is
+* correct for any chain whose native coin has 18 decimals: ETH on Ethereum
+* and Base, POL on Polygon, and so on.
+*
+* @example
+* parseEther('1'); // 1000000000000000000n
+* parseEther('0.5'); // 500000000000000000n
+*
+* @throws {AmountError} as `parseUnits`, with at most 18 decimal places.
+*/
+function parseEther(amount) {
+	return parseUnits(amount, 18);
+}
+//#endregion
+export { AmountError, parseEther, parseNear, parseUnits, toYoctoNear, yoctoNear };
+
+//# sourceMappingURL=amounts.js.map

package/dist/esm/core/types/linkDevice.js

@@ -2,11 +2,11 @@ import { parseVerifiedEmailAddress } from "../../shared-ts/src/utils/domainIds.j
 import "./sdkSentEvents.js";
 //#region src/core/types/linkDevice.ts
 var DeviceLinkingError = class extends Error {
+	name = "DeviceLinkingError";
 	constructor(message, code, phase) {
 		super(message);
 		this.code = code;
 		this.phase = phase;
-		this.name = "DeviceLinkingError";
 	}
 };
 let DeviceLinkingErrorCode = /* @__PURE__ */ function(DeviceLinkingErrorCode) {

package/dist/esm/core/ui/locale.js

@@ -0,0 +1,10 @@
+//#region src/core/ui/locale.ts
+/** Normalize a language tag at a configuration or request boundary. */
+function normalizeWalletLocale(value) {
+	if (typeof value !== "string") return "en";
+	return value.trim().toLowerCase().split(/[-_]/, 1)[0] === "ja" ? "ja" : "en";
+}
+//#endregion
+export { normalizeWalletLocale };
+
+//# sourceMappingURL=locale.js.map