@jamscript/client 0.1.0-rc.1 → 0.1.0-rc.2

package/README.md

@@ -8,10 +8,10 @@ and using JamScript Ownership authentication.
 
 ## Install
 
-The first public release is planned as an RC:
+The current prerelease is:
 
 ```bash
-npm install @jamscript/client@0.1.0-rc.1
+npm install @jamscript/client@0.1.0-rc.2
 ```
 
 The package is network-neutral. Deployment and transport configuration are
@@ -102,6 +102,66 @@ proof-verified responses from the configured provider.
 primitives. The package does not depend on `matrix-js-sdk`; applications own
 their Matrix transport and device lifecycle.
 
+## Ownership signers
+
+Ownership adapters never hold private keys. They delegate signing to the
+external wallet or provider and return the canonical JamScript authorization
+proof expected by SignedActionV2.
+
+### EVM
+
+EVM wallets are called through EIP-1193 `eth_signTypedData_v4`. The typed data
+uses the JamScript `networkDomain` as its EIP-712 salt; the wallet's selected
+EVM chain does not select the JamScript network.
+
+```ts
+import { EvmOwnershipSigner } from "@jamscript/client";
+
+const signer = new EvmOwnershipSigner(window.ethereum, accountAddress);
+```
+
+The adapter does not use `personal_sign`, implement EIP-712 hashing, recover
+secp256k1 keys, or normalize signatures. Those responsibilities remain with
+the wallet and JamScript runtime.
+
+### Polkadot
+
+Pass the AccountId32 obtained from the official SS58 decoder, the explicit
+injected-account key scheme, and the extension signer:
+
+```ts
+import {
+  PolkadotOwnershipSigner,
+  decodePolkadotAccountId,
+} from "@jamscript/client";
+
+const signer = new PolkadotOwnershipSigner({
+  accountId: decodePolkadotAccountId(account.address),
+  address: account.address,
+  scheme: account.type,
+  signer: injector.signer,
+});
+```
+
+SS58 is only a display/transport format. Ownership stores AccountId32. The
+adapter prefixes the raw extension signature with JamScript's scheme byte for
+ed25519, sr25519, or ecdsa; applications do not construct that envelope.
+
+### Solana
+
+Solana Wallet Standard accounts map to generic Ed25519 Ownership. Only the
+`solana:signMessage` feature is used; JamScript does not submit a Solana
+transaction or require a Solana RPC endpoint.
+
+```ts
+import { SolanaOwnershipSigner } from "@jamscript/client";
+
+const signer = new SolanaOwnershipSigner(account, wallet.features);
+```
+
+The full Wallet Standard discovery package belongs in the browser application.
+The client core depends only on the small official sign-message feature types.
+
 ## Runtime support
 
 The package is ESM-only and is intended for modern browsers, Vite-based
@@ -109,14 +169,14 @@ applications, and current Node.js consumers. Runtime source does not import
 Node built-ins, and cryptographic/network dependencies remain external npm
 dependencies so the application bundler can tree-shake them.
 
-The first RC targets the JamScript CLI/runtime v0.1.0-rc.5 generation, Ownership
+This RC targets the JamScript CLI/runtime v0.1.0-rc.5 generation, Ownership
 v1, SignedActionV1, SignedActionV2, and the current MiniJAM Stage-1 deployment
 target. MiniJAM is a supported deployment target, not the package boundary.
 
 ## Package status
 
-This is the first public release candidate. The client has an independent
-version cycle from the JamScript CLI, backend, and network releases.
+This is a public release candidate. The client has an independent version
+cycle from the JamScript CLI, backend, and network releases.
 
 Detailed protocol and integration documentation is available in the
 [JamScript repository](https://github.com/ArcheLabs/JamScript/tree/main/docs).

package/dist/index.d.ts

@@ -8,3 +8,6 @@ export * from "./runtime.js";
 export * from "./signer.js";
 export * from "./state-provider.js";
 export * from "./matrix.js";
+export * from "./signers/evm.js";
+export * from "./signers/polkadot.js";
+export * from "./signers/solana.js";

package/dist/index.js

@@ -8,3 +8,6 @@ export * from "./runtime.js";
 export * from "./signer.js";
 export * from "./state-provider.js";
 export * from "./matrix.js";
+export * from "./signers/evm.js";
+export * from "./signers/polkadot.js";
+export * from "./signers/solana.js";

package/dist/signers/evm.d.ts

@@ -0,0 +1,38 @@
+import { type Ownership } from "../crypto.js";
+import type { JamScriptOwnershipSignRequest, OwnershipSigner } from "../signer.js";
+export type Eip1193Provider = {
+    request(args: {
+        method: string;
+        params?: readonly unknown[] | object;
+    }): Promise<unknown>;
+};
+export type EvmTypedData = {
+    types: {
+        EIP712Domain: readonly {
+            name: string;
+            type: string;
+        }[];
+        JamScriptAction: readonly {
+            name: string;
+            type: string;
+        }[];
+    };
+    primaryType: "JamScriptAction";
+    domain: {
+        name: "JamScript";
+        version: "1";
+        salt: string;
+    };
+    message: {
+        commitment: string;
+    };
+};
+export declare function createEvmTypedData(request: JamScriptOwnershipSignRequest): EvmTypedData;
+export declare class EvmOwnershipSigner implements OwnershipSigner {
+    private readonly provider;
+    private readonly address;
+    private readonly ownership;
+    constructor(provider: Eip1193Provider, address: string);
+    getController(): Promise<Ownership>;
+    signJamScriptAction(request: JamScriptOwnershipSignRequest): Promise<Uint8Array>;
+}

package/dist/signers/evm.js

@@ -0,0 +1,82 @@
+import { actionCommitmentV2, OWNERSHIP_KIND, parseHex, toHex } from "../crypto.js";
+const EIP712_DOMAIN_TYPES = [
+    { name: "name", type: "string" },
+    { name: "version", type: "string" },
+    { name: "salt", type: "bytes32" },
+];
+const JAMSCRIPT_ACTION_TYPES = [
+    { name: "commitment", type: "bytes32" },
+];
+export function createEvmTypedData(request) {
+    return {
+        types: {
+            EIP712Domain: EIP712_DOMAIN_TYPES,
+            JamScriptAction: JAMSCRIPT_ACTION_TYPES,
+        },
+        primaryType: "JamScriptAction",
+        domain: {
+            name: "JamScript",
+            version: "1",
+            salt: toHex(request.networkDomain),
+        },
+        message: {
+            commitment: toHex(actionCommitmentV2(request)),
+        },
+    };
+}
+export class EvmOwnershipSigner {
+    provider;
+    address;
+    ownership;
+    constructor(provider, address) {
+        this.provider = provider;
+        this.address = address;
+        let publicKey;
+        try {
+            publicKey = parseHex(address, 20);
+        }
+        catch (cause) {
+            throw new Error("EVM_ACCOUNT_INVALID", { cause });
+        }
+        this.ownership = { version: 1, kind: OWNERSHIP_KIND.SECP256K1_KECCAK20, public: publicKey };
+    }
+    async getController() {
+        return { ...this.ownership, public: this.ownership.public.slice() };
+    }
+    async signJamScriptAction(request) {
+        const typedData = createEvmTypedData(request);
+        let result;
+        try {
+            result = await this.provider.request({
+                method: "eth_signTypedData_v4",
+                params: [this.address, JSON.stringify(typedData)],
+            });
+        }
+        catch (cause) {
+            if (isUnsupportedTypedDataError(cause)) {
+                throw new Error("EVM_TYPED_DATA_UNSUPPORTED", { cause });
+            }
+            throw cause;
+        }
+        if (typeof result !== "string")
+            throw new Error("EVM_SIGNATURE_INVALID");
+        const signature = parseSignature(result);
+        if (![0, 1, 27, 28].includes(signature[64]))
+            throw new Error("EVM_SIGNATURE_INVALID");
+        return signature;
+    }
+}
+function parseSignature(value) {
+    try {
+        return parseHex(value, 65);
+    }
+    catch (cause) {
+        throw new Error("EVM_SIGNATURE_INVALID", { cause });
+    }
+}
+function isUnsupportedTypedDataError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const value = error;
+    return value.code === -32601 || value.code === 4200 || (typeof value.message === "string" && /not supported|unsupported/i.test(value.message));
+}

package/dist/signers/polkadot.d.ts

@@ -0,0 +1,25 @@
+import { type Ownership } from "../crypto.js";
+import type { JamScriptOwnershipSignRequest, OwnershipSigner } from "../signer.js";
+export type PolkadotSignatureScheme = "ed25519" | "sr25519" | "ecdsa";
+export type PolkadotInjectedSigner = {
+    signRaw(input: {
+        address: string;
+        data: string;
+        type: "bytes";
+    }): Promise<{
+        signature: string;
+    }>;
+};
+export declare function decodePolkadotAccountId(address: string): Uint8Array;
+export declare class PolkadotOwnershipSigner implements OwnershipSigner {
+    private readonly options;
+    private readonly ownership;
+    constructor(options: {
+        accountId: Uint8Array;
+        address: string;
+        scheme: PolkadotSignatureScheme;
+        signer: PolkadotInjectedSigner;
+    });
+    getController(): Promise<Ownership>;
+    signJamScriptAction(request: JamScriptOwnershipSignRequest): Promise<Uint8Array>;
+}

package/dist/signers/polkadot.js

@@ -0,0 +1,71 @@
+import { OWNERSHIP_KIND } from "../crypto.js";
+import { decodeAddress } from "@polkadot/util-crypto";
+export function decodePolkadotAccountId(address) {
+    try {
+        const accountId = decodeAddress(address);
+        if (accountId.length !== 32)
+            throw new Error("decoded account is not AccountId32");
+        return Uint8Array.from(accountId);
+    }
+    catch (cause) {
+        throw new Error("POLKADOT_ACCOUNT_INVALID", { cause });
+    }
+}
+const SCHEME_BYTES = {
+    ed25519: 0,
+    sr25519: 1,
+    ecdsa: 2,
+};
+const SIGNATURE_LENGTHS = {
+    ed25519: 64,
+    sr25519: 64,
+    ecdsa: 65,
+};
+export class PolkadotOwnershipSigner {
+    options;
+    ownership;
+    constructor(options) {
+        this.options = options;
+        if (options.accountId.length !== 32)
+            throw new Error("POLKADOT_ACCOUNT_INVALID");
+        if (!Object.hasOwn(SCHEME_BYTES, options.scheme))
+            throw new Error("POLKADOT_SCHEME_UNSUPPORTED");
+        if (options.address.length === 0)
+            throw new Error("POLKADOT_ACCOUNT_INVALID");
+        this.ownership = {
+            version: 1,
+            kind: OWNERSHIP_KIND.MULTICRYPTO_ACCOUNT32,
+            public: options.accountId.slice(),
+        };
+    }
+    async getController() {
+        return { ...this.ownership, public: this.ownership.public.slice() };
+    }
+    async signJamScriptAction(request) {
+        const result = await this.options.signer.signRaw({
+            address: this.options.address,
+            data: bytesToHex(request.message),
+            type: "bytes",
+        });
+        let signature;
+        try {
+            signature = hexToBytes(result.signature);
+        }
+        catch (cause) {
+            throw new Error("POLKADOT_SIGNATURE_INVALID", { cause });
+        }
+        if (signature.length !== SIGNATURE_LENGTHS[this.options.scheme]) {
+            throw new Error("POLKADOT_SIGNATURE_INVALID");
+        }
+        return Uint8Array.of(SCHEME_BYTES[this.options.scheme], ...signature);
+    }
+}
+function bytesToHex(bytes) {
+    return "0x" + Array.from(bytes, (value) => value.toString(16).padStart(2, "0")).join("");
+}
+function hexToBytes(value) {
+    const hex = value.startsWith("0x") ? value.slice(2) : value;
+    if (hex.length % 2 !== 0 || !/^[0-9a-f]+$/i.test(hex))
+        throw new Error("invalid signature hex");
+    return Uint8Array.from(hex.match(/../g) ?? [], (pair) => Number.parseInt(pair, 16));
+}

package/dist/signers/solana.d.ts

@@ -0,0 +1,12 @@
+import type { SolanaSignMessageFeature } from "@solana/wallet-standard-features";
+import type { WalletAccount } from "@wallet-standard/base";
+import { type Ownership } from "../crypto.js";
+import type { JamScriptOwnershipSignRequest, OwnershipSigner } from "../signer.js";
+export declare class SolanaOwnershipSigner implements OwnershipSigner {
+    private readonly account;
+    private readonly signMessage;
+    private readonly ownership;
+    constructor(account: WalletAccount, signMessage: SolanaSignMessageFeature);
+    getController(): Promise<Ownership>;
+    signJamScriptAction(request: JamScriptOwnershipSignRequest): Promise<Uint8Array>;
+}

package/dist/signers/solana.js

@@ -0,0 +1,35 @@
+import { SolanaSignMessage } from "@solana/wallet-standard-features";
+import { OWNERSHIP_KIND } from "../crypto.js";
+export class SolanaOwnershipSigner {
+    account;
+    signMessage;
+    ownership;
+    constructor(account, signMessage) {
+        this.account = account;
+        this.signMessage = signMessage;
+        if (account.publicKey.length !== 32)
+            throw new Error("SOLANA_PUBLIC_KEY_INVALID");
+        this.ownership = {
+            version: 1,
+            kind: OWNERSHIP_KIND.ED25519_KEY,
+            public: Uint8Array.from(account.publicKey),
+        };
+    }
+    async getController() {
+        return { ...this.ownership, public: this.ownership.public.slice() };
+    }
+    async signJamScriptAction(request) {
+        const feature = this.signMessage?.[SolanaSignMessage];
+        if (!feature || typeof feature.signMessage !== "function") {
+            throw new Error("SOLANA_SIGN_MESSAGE_UNSUPPORTED");
+        }
+        const [output] = await feature.signMessage({ account: this.account, message: request.message });
+        if (!output || !sameBytes(output.signedMessage, request.message) || output.signature.length !== 64 || (output.signatureType !== undefined && output.signatureType !== "ed25519")) {
+            throw new Error("SOLANA_SIGNATURE_INVALID");
+        }
+        return Uint8Array.from(output.signature);
+    }
+}
+function sameBytes(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jamscript/client",
-  "version": "0.1.0-rc.1",
+  "version": "0.1.0-rc.2",
   "description": "TypeScript client for JamScript services, managed state and Ownership.",
   "private": false,
   "type": "module",
@@ -27,7 +27,9 @@
   "dependencies": {
     "@polkadot-api/substrate-bindings": "^0.21.0",
     "@polkadot/util": "^14.0.1",
-    "@polkadot/util-crypto": "^14.0.1"
+    "@polkadot/util-crypto": "^14.0.1",
+    "@wallet-standard/base": "^1.1.1",
+    "@solana/wallet-standard-features": "^1.5.0"
   },
   "devDependencies": {
     "typescript": "^5.9.2"