@actioncodes/protocol 1.0.0

package/dist/adapters/solana/solana.d.ts

@@ -0,0 +1,84 @@
+import { Transaction, TransactionInstruction, VersionedTransaction } from '@solana/web3.js';
+import { ProtocolMetaV1 } from '../../meta';
+import { BaseChainAdapter } from '../base';
+/**
+ * Solana transaction type union
+ */
+export type SolanaTransaction = Transaction | VersionedTransaction;
+/**
+ * Simple Solana adapter for protocol meta operations
+ * Supports both legacy and versioned transactions
+ */
+export declare class SolanaAdapter extends BaseChainAdapter<SolanaTransaction> {
+    private static readonly MEMO_PROGRAM_ID;
+    readonly chain = "solana";
+    /**
+     * Encode protocol meta as a Solana memo instruction
+     * @param meta - The protocol meta to encode
+     * @returns TransactionInstruction for the memo
+     */
+    encode(meta: ProtocolMetaV1): TransactionInstruction;
+    /**
+     * Decode protocol meta from Solana transaction (legacy or versioned)
+     * @param tx - The Solana transaction
+     * @returns Decoded ProtocolMetaV1 or null if not found
+     */
+    decode(tx: SolanaTransaction): ProtocolMetaV1 | null;
+    /**
+     * Validate transaction with protocol meta and authority list
+     * @param tx - The Solana transaction
+     * @param authorities - Array of valid protocol authority public keys (base58)
+     * @param expectedPrefix - Expected protocol prefix (default: 'DEFAULT')
+     * @returns True if transaction is valid
+     */
+    validate(tx: SolanaTransaction, authorities: string[], expectedPrefix?: string): boolean;
+    /**
+     * Check if the issuer has signed the transaction
+     * @param tx - The Solana transaction
+     * @param issuer - Issuer public key to check
+     * @returns True if issuer has signed
+     */
+    hasIssuerSignature(tx: SolanaTransaction, issuer: string): boolean;
+    /**
+     * Decode protocol meta from legacy Solana transaction
+     */
+    private decodeLegacyTransaction;
+    /**
+     * Decode protocol meta from versioned Solana transaction
+     */
+    private decodeVersionedTransaction;
+    /**
+     * Decode protocol meta from MessageV0
+     */
+    private decodeMessageV0;
+    /**
+     * Check if the issuer has signed a legacy transaction
+     */
+    private hasIssuerSignatureLegacy;
+    /**
+     * Check if the issuer has signed a versioned transaction
+     */
+    private hasIssuerSignatureVersioned;
+    /**
+     * Validate Solana transaction integrity with additional checks
+     * @param tx - The Solana transaction
+     * @param meta - Decoded protocol meta
+     * @returns True if transaction integrity is valid
+     */
+    protected validateTransactionIntegrity(tx: SolanaTransaction, meta: ProtocolMetaV1): boolean;
+    /**
+     * Decode protocol meta from base64 string (for backward compatibility)
+     * @param base64String - Base64 encoded transaction
+     * @returns Decoded ProtocolMetaV1 or null
+     */
+    decodeFromBase64(base64String: string): ProtocolMetaV1 | null;
+    /**
+     * Validate base64 transaction (for backward compatibility)
+     * @param base64String - Base64 encoded transaction
+     * @param authorities - Array of valid protocol authority public keys (base58)
+     * @param expectedPrefix - Expected protocol prefix (default: 'DEFAULT')
+     * @returns True if transaction is valid
+     */
+    validateFromBase64(base64String: string, authorities: string[], expectedPrefix?: string): boolean;
+}
+//# sourceMappingURL=solana.d.ts.map

package/dist/adapters/solana/solana.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solana.d.ts","sourceRoot":"","sources":["../../../src/adapters/solana/solana.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,WAAW,EACX,sBAAsB,EACtB,oBAAoB,EAEvB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,cAAc,EAAsB,MAAM,YAAY,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAE3C;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,oBAAoB,CAAC;AAEnE;;;GAGG;AACH,qBAAa,aAAc,SAAQ,gBAAgB,CAAC,iBAAiB,CAAC;IAClE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAmB;IAE1D,QAAQ,CAAC,KAAK,YAAY;IAE1B;;;;OAIG;IACH,MAAM,CAAC,IAAI,EAAE,cAAc,GAAG,sBAAsB;IAKpD;;;;OAIG;IACH,MAAM,CAAC,EAAE,EAAE,iBAAiB,GAAG,cAAc,GAAG,IAAI;IAWpD;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,EAAE,EAAE,cAAc,GAAE,MAAkB,GAAG,OAAO;IAInG;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO;IAWlE;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAqB/B;;OAEG;IACH,OAAO,CAAC,0BAA0B;IAUlC;;OAEG;IACH,OAAO,CAAC,eAAe;IAuBvB;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAMhC;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAenC;;;;;OAKG;IACH,SAAS,CAAC,4BAA4B,CAAC,EAAE,EAAE,iBAAiB,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO;IAqB5F;;;;OAIG;IACH,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAgB7D;;;;;;OAMG;IACH,kBAAkB,CAAC,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,EAAE,cAAc,GAAE,MAAkB,GAAG,OAAO;CAe/G"}

package/dist/adapters/solana/solana.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaAdapter = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const spl_memo_1 = require("@solana/spl-memo");
+const meta_1 = require("../../meta");
+const base_1 = require("../base");
+/**
+ * Simple Solana adapter for protocol meta operations
+ * Supports both legacy and versioned transactions
+ */
+class SolanaAdapter extends base_1.BaseChainAdapter {
+    constructor() {
+        super(...arguments);
+        this.chain = 'solana';
+    }
+    /**
+     * Encode protocol meta as a Solana memo instruction
+     * @param meta - The protocol meta to encode
+     * @returns TransactionInstruction for the memo
+     */
+    encode(meta) {
+        const metaString = meta_1.ProtocolMetaParser.serialize(meta);
+        return (0, spl_memo_1.createMemoInstruction)(metaString);
+    }
+    /**
+     * Decode protocol meta from Solana transaction (legacy or versioned)
+     * @param tx - The Solana transaction
+     * @returns Decoded ProtocolMetaV1 or null if not found
+     */
+    decode(tx) {
+        // Check if it's a versioned transaction
+        if ('message' in tx && tx.message) {
+            return this.decodeVersionedTransaction(tx);
+        }
+        else if ('instructions' in tx && Array.isArray(tx.instructions)) {
+            return this.decodeLegacyTransaction(tx);
+        }
+        else {
+            return null;
+        }
+    }
+    /**
+     * Validate transaction with protocol meta and authority list
+     * @param tx - The Solana transaction
+     * @param authorities - Array of valid protocol authority public keys (base58)
+     * @param expectedPrefix - Expected protocol prefix (default: 'DEFAULT')
+     * @returns True if transaction is valid
+     */
+    validate(tx, authorities, expectedPrefix = 'DEFAULT') {
+        return this.detectTampering(tx, authorities, expectedPrefix);
+    }
+    /**
+     * Check if the issuer has signed the transaction
+     * @param tx - The Solana transaction
+     * @param issuer - Issuer public key to check
+     * @returns True if issuer has signed
+     */
+    hasIssuerSignature(tx, issuer) {
+        // Check if it's a versioned transaction
+        if ('message' in tx && tx.message) {
+            return this.hasIssuerSignatureVersioned(tx, issuer);
+        }
+        else if ('signatures' in tx && Array.isArray(tx.signatures)) {
+            return this.hasIssuerSignatureLegacy(tx, issuer);
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * Decode protocol meta from legacy Solana transaction
+     */
+    decodeLegacyTransaction(transaction) {
+        for (const instruction of transaction.instructions) {
+            if (instruction.programId.equals(SolanaAdapter.MEMO_PROGRAM_ID)) {
+                const memoData = instruction.data;
+                if (memoData && memoData.length > 0) {
+                    try {
+                        const memoString = new TextDecoder().decode(memoData);
+                        const meta = meta_1.ProtocolMetaParser.parse(memoString);
+                        if (meta && meta.version !== '1') {
+                            return null;
+                        }
+                        return meta;
+                    }
+                    catch {
+                        return null;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Decode protocol meta from versioned Solana transaction
+     */
+    decodeVersionedTransaction(transaction) {
+        const message = transaction.message;
+        if (message instanceof web3_js_1.MessageV0) {
+            return this.decodeMessageV0(message);
+        }
+        else {
+            return null;
+        }
+    }
+    /**
+     * Decode protocol meta from MessageV0
+     */
+    decodeMessageV0(message) {
+        for (const instruction of message.compiledInstructions) {
+            const programId = message.staticAccountKeys[instruction.programIdIndex];
+            if (programId.equals(SolanaAdapter.MEMO_PROGRAM_ID)) {
+                const memoData = instruction.data;
+                if (memoData && memoData.length > 0) {
+                    try {
+                        const memoString = new TextDecoder().decode(memoData);
+                        const meta = meta_1.ProtocolMetaParser.parse(memoString);
+                        if (meta && meta.version !== '1') {
+                            return null;
+                        }
+                        return meta;
+                    }
+                    catch {
+                        return null;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Check if the issuer has signed a legacy transaction
+     */
+    hasIssuerSignatureLegacy(transaction, issuer) {
+        return transaction.signatures.some(sig => sig.publicKey.toBase58() === issuer);
+    }
+    /**
+     * Check if the issuer has signed a versioned transaction
+     */
+    hasIssuerSignatureVersioned(transaction, issuer) {
+        const message = transaction.message;
+        if (message instanceof web3_js_1.MessageV0) {
+            // Check static account keys
+            for (const key of message.staticAccountKeys) {
+                if (key.toBase58() === issuer) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Validate Solana transaction integrity with additional checks
+     * @param tx - The Solana transaction
+     * @param meta - Decoded protocol meta
+     * @returns True if transaction integrity is valid
+     */
+    validateTransactionIntegrity(tx, meta) {
+        // Additional Solana-specific validation can be added here
+        // For example, checking transaction signatures, recent blockhash, etc.
+        // Verify that the memo instruction contains the expected protocol meta
+        const decodedMeta = this.decode(tx);
+        if (!decodedMeta) {
+            return false;
+        }
+        // Cross-check the decoded meta with the provided meta
+        return (decodedMeta.version === meta.version &&
+            decodedMeta.prefix === meta.prefix &&
+            decodedMeta.initiator === meta.initiator &&
+            decodedMeta.id === meta.id &&
+            decodedMeta.iss === meta.iss &&
+            decodedMeta.params === meta.params);
+    }
+    /**
+     * Decode protocol meta from base64 string (for backward compatibility)
+     * @param base64String - Base64 encoded transaction
+     * @returns Decoded ProtocolMetaV1 or null
+     */
+    decodeFromBase64(base64String) {
+        try {
+            const buffer = Uint8Array.from(atob(base64String), c => c.charCodeAt(0));
+            // Try legacy first, then versioned
+            try {
+                const transaction = web3_js_1.Transaction.from(buffer);
+                return this.decode(transaction);
+            }
+            catch {
+                const transaction = web3_js_1.VersionedTransaction.deserialize(buffer);
+                return this.decode(transaction);
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Validate base64 transaction (for backward compatibility)
+     * @param base64String - Base64 encoded transaction
+     * @param authorities - Array of valid protocol authority public keys (base58)
+     * @param expectedPrefix - Expected protocol prefix (default: 'DEFAULT')
+     * @returns True if transaction is valid
+     */
+    validateFromBase64(base64String, authorities, expectedPrefix = 'DEFAULT') {
+        try {
+            const buffer = Uint8Array.from(atob(base64String), c => c.charCodeAt(0));
+            // Try legacy first, then versioned
+            try {
+                const transaction = web3_js_1.Transaction.from(buffer);
+                return this.validate(transaction, authorities, expectedPrefix);
+            }
+            catch {
+                const transaction = web3_js_1.VersionedTransaction.deserialize(buffer);
+                return this.validate(transaction, authorities, expectedPrefix);
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.SolanaAdapter = SolanaAdapter;
+SolanaAdapter.MEMO_PROGRAM_ID = spl_memo_1.MEMO_PROGRAM_ID;

package/dist/codegen.d.ts

@@ -0,0 +1,73 @@
+export declare class CodeGenerator {
+    static TIME_WINDOW_MS: number;
+    static CODE_DIGITS: number;
+    static MIN_PREFIX_LENGTH: number;
+    static MAX_PREFIX_LENGTH: number;
+    /**
+     * Validate prefix format
+     * @param prefix - The prefix to validate
+     * @returns True if prefix is valid, false otherwise
+     */
+    static validatePrefix(prefix: string): boolean;
+    /**
+     * Normalize prefix - convert "DEFAULT" to empty string, validate others
+     * @param prefix - The prefix to normalize
+     * @returns Normalized prefix
+     * @throws Error if prefix is invalid
+     */
+    static normalizePrefix(prefix: string): string;
+    /**
+     * Generate a deterministic 8-digit code based on public key, prefix, and timestamp
+     * @param pubkey - Solana wallet public key (base58)
+     * @param signature - User's signature string
+     * @param prefix - Optional namespace prefix (default: "DEFAULT")
+     * @param timestamp - UNIX timestamp in milliseconds (defaults to now)
+     * @returns Object containing code, issuedAt, and expiresAt timestamps
+     */
+    static generateCode(pubkey: string, signature: string, prefix?: string, timestamp?: number): {
+        code: string;
+        issuedAt: number;
+        expiresAt: number;
+    };
+    /**
+     * Derive the full SHA-256 hash for storage or encryption key generation
+     * @param pubkey - Solana wallet public key (base58)
+     * @param prefix - Optional namespace prefix (default: "DEFAULT")
+     * @param timestamp - UNIX timestamp in milliseconds (defaults to now)
+     * @returns Full SHA-256 hash string
+     */
+    static deriveCodeHash(pubkey: string, prefix?: string, timestamp?: number): string;
+    /**
+     * Generate the message that should be signed for code verification
+     * @param code - The generated 8-digit code
+     * @param timestamp - UNIX timestamp in milliseconds
+     * @returns Message string in format "actioncodes:<code>:<timestamp>"
+     */
+    static generateCodeSignatureMessage(code: string, timestamp: number): string;
+    /**
+     * Get the expected code for a given public key and timestamp
+     * @param pubkey - Solana wallet public key (base58)
+     * @param timestamp - UNIX timestamp in milliseconds
+     * @param signature - User's signature string
+     * @param prefix - Optional namespace prefix (default: "DEFAULT")
+     * @returns 8-digit numeric string
+     */
+    static getExpectedCode(pubkey: string, timestamp: number, signature: string, prefix?: string): string;
+    /**
+     * Validate if a code matches the expected code for a given public key and timestamp
+     * @param code - The code to validate
+     * @param pubkey - Solana wallet public key (base58)
+     * @param timestamp - UNIX timestamp in milliseconds
+     * @param signature - User's signature string
+     * @param prefix - Optional namespace prefix (default: "DEFAULT")
+     * @returns True if code matches expected code and timestamp is valid
+     */
+    static validateCode(code: string, pubkey: string, timestamp: number, signature: string, prefix?: string): boolean;
+    /**
+     * Check if a timestamp falls within a valid time window
+     * @param timestamp - UNIX timestamp in milliseconds
+     * @returns True if timestamp is valid
+     */
+    static isValidTimestamp(timestamp: number): boolean;
+}
+//# sourceMappingURL=codegen.d.ts.map

package/dist/codegen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../src/codegen.ts"],"names":[],"mappings":"AAGA,qBAAa,aAAa;IACtB,MAAM,CAAC,cAAc,SAAY;IACjC,MAAM,CAAC,WAAW,SAAe;IACjC,MAAM,CAAC,iBAAiB,SAAqB;IAC7C,MAAM,CAAC,iBAAiB,SAAqB;IAE7C;;;;OAIG;IACH,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAM9C;;;;;OAKG;IACH,MAAM,CAAC,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAQ9C;;;;;;;OAOG;IACH,MAAM,CAAC,YAAY,CACf,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,MAAkB,EAC1B,SAAS,GAAE,MAAmB,GAC/B;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE;IAmBxD;;;;;;OAMG;IACH,MAAM,CAAC,cAAc,CACjB,MAAM,EAAE,MAAM,EACd,MAAM,GAAE,MAAkB,EAC1B,SAAS,CAAC,EAAE,MAAM,GACnB,MAAM;IAQT;;;;;OAKG;IACH,MAAM,CAAC,4BAA4B,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM;IAI5E;;;;;;;OAOG;IACH,MAAM,CAAC,eAAe,CAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,MAAkB,GAC3B,MAAM;IAIT;;;;;;;;OAQG;IACH,MAAM,CAAC,YAAY,CACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,MAAkB,GAC3B,OAAO;IAOV;;;;OAIG;IACH,MAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;CAGtD"}

package/dist/codegen.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeGenerator = void 0;
+const js_sha256_1 = require("js-sha256");
+const constants_1 = require("./constants");
+class CodeGenerator {
+    /**
+     * Validate prefix format
+     * @param prefix - The prefix to validate
+     * @returns True if prefix is valid, false otherwise
+     */
+    static validatePrefix(prefix) {
+        if (prefix === "DEFAULT")
+            return true;
+        if (prefix.length < this.MIN_PREFIX_LENGTH || prefix.length > this.MAX_PREFIX_LENGTH)
+            return false;
+        return /^[A-Za-z]+$/.test(prefix);
+    }
+    /**
+     * Normalize prefix - convert "DEFAULT" to empty string, validate others
+     * @param prefix - The prefix to normalize
+     * @returns Normalized prefix
+     * @throws Error if prefix is invalid
+     */
+    static normalizePrefix(prefix) {
+        if (prefix === "DEFAULT")
+            return "";
+        if (!this.validatePrefix(prefix)) {
+            throw new Error(`Invalid prefix: ${prefix}. Must be 3-12 letters or "DEFAULT"`);
+        }
+        return prefix.toUpperCase();
+    }
+    /**
+     * Generate a deterministic 8-digit code based on public key, prefix, and timestamp
+     * @param pubkey - Solana wallet public key (base58)
+     * @param signature - User's signature string
+     * @param prefix - Optional namespace prefix (default: "DEFAULT")
+     * @param timestamp - UNIX timestamp in milliseconds (defaults to now)
+     * @returns Object containing code, issuedAt, and expiresAt timestamps
+     */
+    static generateCode(pubkey, signature, prefix = "DEFAULT", timestamp = Date.now()) {
+        const normalizedPrefix = this.normalizePrefix(prefix);
+        const input = `${normalizedPrefix}:${pubkey}:${timestamp}:${signature}`;
+        const hash = (0, js_sha256_1.sha256)(input);
+        const raw = parseInt(hash.slice(0, 16), 16);
+        const mod = 10 ** this.CODE_DIGITS;
+        const code = raw % mod;
+        const issuedAt = timestamp;
+        const expiresAt = issuedAt + this.TIME_WINDOW_MS;
+        return {
+            code: code.toString().padStart(this.CODE_DIGITS, "0"),
+            issuedAt,
+            expiresAt
+        };
+    }
+    /**
+     * Derive the full SHA-256 hash for storage or encryption key generation
+     * @param pubkey - Solana wallet public key (base58)
+     * @param prefix - Optional namespace prefix (default: "DEFAULT")
+     * @param timestamp - UNIX timestamp in milliseconds (defaults to now)
+     * @returns Full SHA-256 hash string
+     */
+    static deriveCodeHash(pubkey, prefix = "DEFAULT", timestamp) {
+        const normalizedPrefix = this.normalizePrefix(prefix);
+        const ts = timestamp ?? Date.now();
+        const input = `${normalizedPrefix}:${pubkey}:${ts}`;
+        const hash = (0, js_sha256_1.sha256)(input);
+        return hash;
+    }
+    /**
+     * Generate the message that should be signed for code verification
+     * @param code - The generated 8-digit code
+     * @param timestamp - UNIX timestamp in milliseconds
+     * @returns Message string in format "actioncodes:<code>:<timestamp>"
+     */
+    static generateCodeSignatureMessage(code, timestamp) {
+        return `${constants_1.PROTOCOL_PREFIX}:${code}:${timestamp}`;
+    }
+    /**
+     * Get the expected code for a given public key and timestamp
+     * @param pubkey - Solana wallet public key (base58)
+     * @param timestamp - UNIX timestamp in milliseconds
+     * @param signature - User's signature string
+     * @param prefix - Optional namespace prefix (default: "DEFAULT")
+     * @returns 8-digit numeric string
+     */
+    static getExpectedCode(pubkey, timestamp, signature, prefix = "DEFAULT") {
+        return this.generateCode(pubkey, signature, prefix, timestamp).code;
+    }
+    /**
+     * Validate if a code matches the expected code for a given public key and timestamp
+     * @param code - The code to validate
+     * @param pubkey - Solana wallet public key (base58)
+     * @param timestamp - UNIX timestamp in milliseconds
+     * @param signature - User's signature string
+     * @param prefix - Optional namespace prefix (default: "DEFAULT")
+     * @returns True if code matches expected code and timestamp is valid
+     */
+    static validateCode(code, pubkey, timestamp, signature, prefix = "DEFAULT") {
+        const expectedCode = this.getExpectedCode(pubkey, timestamp, signature, prefix);
+        const now = Date.now();
+        const isTimeValid = timestamp >= 0 && timestamp <= now && now <= timestamp + this.TIME_WINDOW_MS;
+        return code === expectedCode && isTimeValid;
+    }
+    /**
+     * Check if a timestamp falls within a valid time window
+     * @param timestamp - UNIX timestamp in milliseconds
+     * @returns True if timestamp is valid
+     */
+    static isValidTimestamp(timestamp) {
+        return timestamp >= 0 && timestamp <= Date.now() + this.TIME_WINDOW_MS;
+    }
+}
+exports.CodeGenerator = CodeGenerator;
+CodeGenerator.TIME_WINDOW_MS = constants_1.CODE_TTL;
+CodeGenerator.CODE_DIGITS = constants_1.CODE_LENGTH;
+CodeGenerator.MIN_PREFIX_LENGTH = constants_1.MIN_PREFIX_LENGTH;
+CodeGenerator.MAX_PREFIX_LENGTH = constants_1.MAX_PREFIX_LENGTH;

package/dist/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const PROTOCOL_VERSION = "1";
+export declare const PROTOCOL_PREFIX = "actioncodes";
+export declare const CODE_LENGTH = 8;
+export declare const CODE_TTL: number;
+export declare const PROTOCOL_CODE_PREFIX = "DEFAULT";
+export declare const MIN_PREFIX_LENGTH = 3;
+export declare const MAX_PREFIX_LENGTH = 12;
+export declare const SUPPORTED_CHAINS: readonly ["solana"];
+export type SupportedChain = (typeof SUPPORTED_CHAINS)[number];
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,MAAM,CAAC;AACpC,eAAO,MAAM,eAAe,gBAAgB,CAAC;AAC7C,eAAO,MAAM,WAAW,IAAI,CAAC;AAC7B,eAAO,MAAM,QAAQ,QAAgB,CAAC;AACtC,eAAO,MAAM,oBAAoB,YAAY,CAAC;AAC9C,eAAO,MAAM,iBAAiB,IAAI,CAAC;AACnC,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,gBAAgB,qBAAsB,CAAC;AACpD,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/constants.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_CHAINS = exports.MAX_PREFIX_LENGTH = exports.MIN_PREFIX_LENGTH = exports.PROTOCOL_CODE_PREFIX = exports.CODE_TTL = exports.CODE_LENGTH = exports.PROTOCOL_PREFIX = exports.PROTOCOL_VERSION = void 0;
+exports.PROTOCOL_VERSION = "1";
+exports.PROTOCOL_PREFIX = "actioncodes";
+exports.CODE_LENGTH = 8;
+exports.CODE_TTL = 1000 * 60 * 2; // 2 minutes
+exports.PROTOCOL_CODE_PREFIX = "DEFAULT";
+exports.MIN_PREFIX_LENGTH = 3;
+exports.MAX_PREFIX_LENGTH = 12;
+exports.SUPPORTED_CHAINS = ["solana"];

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './adapters/solana';
+export * from './adapters/base';
+export * from './codegen';
+export * from './constants';
+export * from './meta';
+export * from './actioncode';
+export * from './protocol';
+export type { SolanaTransaction } from './adapters/solana';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAG3B,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./adapters/solana"), exports);
+__exportStar(require("./adapters/base"), exports);
+__exportStar(require("./codegen"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./meta"), exports);
+__exportStar(require("./actioncode"), exports);
+__exportStar(require("./protocol"), exports);

package/dist/meta.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Protocol meta structure for code verification
+ */
+export interface ProtocolMetaV1 {
+    version: string;
+    prefix: string;
+    initiator: string;
+    id: string;
+    iss?: string;
+    params?: string;
+}
+/**
+ * Protocol meta parser for structured memo/message parsing
+ */
+export declare class ProtocolMetaParser {
+    private static readonly PROTOCOL_REGEX;
+    /**
+     * Parse protocol meta from string
+     * @param metaString - The protocol meta string to parse
+     * @returns Parsed ProtocolMeta object or null if invalid
+     */
+    static parse(metaString: string): ProtocolMetaV1 | null;
+    /**
+     * Serialize ProtocolMeta to string
+     * @param meta - The protocol meta to serialize
+     * @returns Serialized protocol meta string
+     */
+    static serialize(meta: ProtocolMetaV1): string;
+    /**
+     * Create protocol meta from code and parameters
+     * @param initiator - The initiator public key
+     * @param iss - The issuer (protocol authority)
+     * @param prefix - The prefix (default: "DEFAULT")
+     * @param params - Optional parameters
+     * @param timestamp - Optional timestamp
+     * @returns ProtocolMeta object
+     */
+    static fromInitiator(initiator: string, iss: string, prefix?: string, params?: string, timestamp?: number): ProtocolMetaV1;
+    /**
+     * Validate if a code matches the protocol meta
+     * @param meta - The protocol meta to validate against
+     * @param timestamp - Optional timestamp for validation (if not provided, uses current time)
+     * @returns True if the meta is valid
+     */
+    static validateCode(meta: ProtocolMetaV1, timestamp?: number): boolean;
+    /**
+     * Validate if a code matches the protocol meta by parsing from string
+     * @param metaString - The protocol meta string to validate against
+     * @param timestamp - Optional timestamp for validation (if not provided, uses current time)
+     * @returns True if the code matches the meta
+     */
+    static validateMetaFromString(metaString: string, timestamp?: number): boolean;
+}
+//# sourceMappingURL=meta.d.ts.map

package/dist/meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta.d.ts","sourceRoot":"","sources":["../src/meta.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAqF;IAE3H;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAuBvD;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM;IAU9C;;;;;;;;OAQG;IACH,MAAM,CAAC,aAAa,CAClB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,EACX,MAAM,GAAE,MAAkB,EAC1B,MAAM,CAAC,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,MAAM,GACjB,cAAc;IAajB;;;;;OAKG;IACH,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;IAKtE;;;;;OAKG;IACH,MAAM,CAAC,sBAAsB,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;CAO/E"}