bulk-keychain-wasm 0.1.2 → 0.1.4

package/bulk_keychain_wasm.d.ts

@@ -37,6 +37,64 @@ export class WasmKeypair {
     readonly pubkey: string;
 }
 
+/**
+ * Prepared message for external wallet signing
+ *
+ * This contains everything needed to sign with an external wallet
+ * and then finalize into a SignedTransaction.
+ */
+export class WasmPreparedMessage {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Finalize with a signature (base58 string)
+     *
+     * Call this after your wallet signs the messageBytes.
+     */
+    finalize(signature: string): any;
+    /**
+     * Finalize with signature bytes (Uint8Array)
+     */
+    finalizeBytes(signature: Uint8Array): any;
+    /**
+     * Get the account public key (base58)
+     */
+    readonly account: string;
+    /**
+     * Get the action JSON
+     */
+    readonly action: any;
+    /**
+     * Get message as base58 string
+     */
+    readonly messageBase58: string;
+    /**
+     * Get message as base64 string
+     */
+    readonly messageBase64: string;
+    /**
+     * Get the raw message bytes to sign (Uint8Array)
+     */
+    readonly messageBytes: Uint8Array;
+    /**
+     * Get message as hex string
+     */
+    readonly messageHex: string;
+    /**
+     * Get the nonce
+     */
+    readonly nonce: number;
+    /**
+     * Get the pre-computed order ID
+     */
+    readonly orderId: string;
+    /**
+     * Get the signer public key (base58)
+     */
+    readonly signer: string;
+}
+
 /**
  * WASM wrapper for Signer
  */
@@ -106,11 +164,74 @@ export function computeOrderId(wincode_bytes: Uint8Array): string;
  */
 export function currentTimestamp(): number;
 
+/**
+ * Finalize a prepared message with a signature
+ *
+ * Alternative to calling prepared.finalize() - useful if you have
+ * the prepared message as a plain object.
+ */
+export function finalizeTransaction(prepared: any, signature: string): any;
+
 /**
  * Initialize the WASM module
  */
 export function init(): void;
 
+/**
+ * Prepare agent wallet creation for external signing
+ *
+ * @param agentPubkey - The agent wallet public key to authorize
+ * @param delete - Whether to delete (true) or add (false) the agent
+ * @param options - { account: string, signer?: string, nonce?: number }
+ */
+export function prepareAgentWallet(agent_pubkey: string, _delete: boolean, options: any): WasmPreparedMessage;
+
+/**
+ * Prepare multiple orders - each becomes its own transaction (parallel)
+ *
+ * @param orders - Array of orders to prepare
+ * @param options - { account: string, signer?: string, nonce?: number }
+ * @returns Array of PreparedMessage
+ */
+export function prepareAll(orders: any, options: any): WasmPreparedMessage[];
+
+/**
+ * Prepare faucet request for external signing
+ *
+ * @param options - { account: string, signer?: string, nonce?: number }
+ */
+export function prepareFaucet(options: any): WasmPreparedMessage;
+
+/**
+ * Prepare multiple orders as ONE atomic transaction
+ *
+ * Use for bracket orders (entry + stop loss + take profit).
+ *
+ * @param orders - Array of orders for the atomic transaction
+ * @param options - { account: string, signer?: string, nonce?: number }
+ * @returns Single PreparedMessage containing all orders
+ */
+export function prepareGroup(orders: any, options: any): WasmPreparedMessage;
+
+/**
+ * Prepare a single order for external wallet signing
+ *
+ * Use this when you don't have access to the private key and need
+ * to sign with an external wallet (like Phantom, Privy, etc).
+ *
+ * @param order - The order to prepare
+ * @param options - { account: string, signer?: string, nonce?: number }
+ * @returns PreparedMessage with messageBytes to sign
+ *
+ * @example
+ * ```typescript
+ * const prepared = prepareOrder(order, { account: myPubkey });
+ * const signature = await wallet.signMessage(prepared.messageBytes);
+ * const signed = prepared.finalize(signature);
+ * ```
+ */
+export function prepareOrder(order: any, options: any): WasmPreparedMessage;
+
 /**
  * Generate a random hash (for client order IDs)
  */
@@ -131,9 +252,16 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly __wbg_wasmkeypair_free: (a: number, b: number) => void;
+    readonly __wbg_wasmpreparedmessage_free: (a: number, b: number) => void;
     readonly __wbg_wasmsigner_free: (a: number, b: number) => void;
     readonly computeOrderId: (a: number, b: number) => [number, number];
     readonly currentTimestamp: () => number;
+    readonly finalizeTransaction: (a: any, b: number, c: number) => [number, number, number];
+    readonly prepareAgentWallet: (a: number, b: number, c: number, d: any) => [number, number, number];
+    readonly prepareAll: (a: any, b: any) => [number, number, number, number];
+    readonly prepareFaucet: (a: any) => [number, number, number];
+    readonly prepareGroup: (a: any, b: any) => [number, number, number];
+    readonly prepareOrder: (a: any, b: any) => [number, number, number];
     readonly randomHash: () => [number, number];
     readonly validateHash: (a: number, b: number) => number;
     readonly validatePubkey: (a: number, b: number) => number;
@@ -144,6 +272,17 @@ export interface InitOutput {
     readonly wasmkeypair_secretKey: (a: number) => [number, number];
     readonly wasmkeypair_toBase58: (a: number) => [number, number];
     readonly wasmkeypair_toBytes: (a: number) => [number, number];
+    readonly wasmpreparedmessage_account: (a: number) => [number, number];
+    readonly wasmpreparedmessage_action: (a: number) => any;
+    readonly wasmpreparedmessage_finalize: (a: number, b: number, c: number) => any;
+    readonly wasmpreparedmessage_finalizeBytes: (a: number, b: number, c: number) => any;
+    readonly wasmpreparedmessage_messageBase58: (a: number) => [number, number];
+    readonly wasmpreparedmessage_messageBase64: (a: number) => [number, number];
+    readonly wasmpreparedmessage_messageBytes: (a: number) => [number, number];
+    readonly wasmpreparedmessage_messageHex: (a: number) => [number, number];
+    readonly wasmpreparedmessage_nonce: (a: number) => number;
+    readonly wasmpreparedmessage_orderId: (a: number) => [number, number];
+    readonly wasmpreparedmessage_signer: (a: number) => [number, number];
     readonly wasmsigner_fromBase58: (a: number, b: number) => [number, number, number];
     readonly wasmsigner_new: (a: number) => number;
     readonly wasmsigner_pubkey: (a: number) => [number, number];
@@ -164,6 +303,7 @@ export interface InitOutput {
     readonly __wbindgen_externrefs: WebAssembly.Table;
     readonly __wbindgen_free: (a: number, b: number, c: number) => void;
     readonly __externref_table_dealloc: (a: number) => void;
+    readonly __externref_drop_slice: (a: number, b: number) => void;
     readonly __wbindgen_start: () => void;
 }
 

package/bulk_keychain_wasm.js

@@ -113,6 +113,179 @@ export class WasmKeypair {
 }
 if (Symbol.dispose) WasmKeypair.prototype[Symbol.dispose] = WasmKeypair.prototype.free;
 
+/**
+ * Prepared message for external wallet signing
+ *
+ * This contains everything needed to sign with an external wallet
+ * and then finalize into a SignedTransaction.
+ */
+export class WasmPreparedMessage {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmPreparedMessage.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmPreparedMessageFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmPreparedMessageFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmpreparedmessage_free(ptr, 0);
+    }
+    /**
+     * Get the account public key (base58)
+     * @returns {string}
+     */
+    get account() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmpreparedmessage_account(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Get the action JSON
+     * @returns {any}
+     */
+    get action() {
+        const ret = wasm.wasmpreparedmessage_action(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Finalize with a signature (base58 string)
+     *
+     * Call this after your wallet signs the messageBytes.
+     * @param {string} signature
+     * @returns {any}
+     */
+    finalize(signature) {
+        const ptr0 = passStringToWasm0(signature, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmpreparedmessage_finalize(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Finalize with signature bytes (Uint8Array)
+     * @param {Uint8Array} signature
+     * @returns {any}
+     */
+    finalizeBytes(signature) {
+        const ptr0 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmpreparedmessage_finalizeBytes(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Get message as base58 string
+     * @returns {string}
+     */
+    get messageBase58() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmpreparedmessage_messageBase58(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Get message as base64 string
+     * @returns {string}
+     */
+    get messageBase64() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmpreparedmessage_messageBase64(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Get the raw message bytes to sign (Uint8Array)
+     * @returns {Uint8Array}
+     */
+    get messageBytes() {
+        const ret = wasm.wasmpreparedmessage_messageBytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Get message as hex string
+     * @returns {string}
+     */
+    get messageHex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmpreparedmessage_messageHex(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Get the nonce
+     * @returns {number}
+     */
+    get nonce() {
+        const ret = wasm.wasmpreparedmessage_nonce(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get the pre-computed order ID
+     * @returns {string}
+     */
+    get orderId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmpreparedmessage_orderId(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Get the signer public key (base58)
+     * @returns {string}
+     */
+    get signer() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmpreparedmessage_signer(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) WasmPreparedMessage.prototype[Symbol.dispose] = WasmPreparedMessage.prototype.free;
+
 /**
  * WASM wrapper for Signer
  */
@@ -332,6 +505,25 @@ export function currentTimestamp() {
     return ret;
 }
 
+/**
+ * Finalize a prepared message with a signature
+ *
+ * Alternative to calling prepared.finalize() - useful if you have
+ * the prepared message as a plain object.
+ * @param {any} prepared
+ * @param {string} signature
+ * @returns {any}
+ */
+export function finalizeTransaction(prepared, signature) {
+    const ptr0 = passStringToWasm0(signature, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.finalizeTransaction(prepared, ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Initialize the WASM module
  */
@@ -339,6 +531,110 @@ export function init() {
     wasm.init();
 }
 
+/**
+ * Prepare agent wallet creation for external signing
+ *
+ * @param agentPubkey - The agent wallet public key to authorize
+ * @param delete - Whether to delete (true) or add (false) the agent
+ * @param options - { account: string, signer?: string, nonce?: number }
+ * @param {string} agent_pubkey
+ * @param {boolean} _delete
+ * @param {any} options
+ * @returns {WasmPreparedMessage}
+ */
+export function prepareAgentWallet(agent_pubkey, _delete, options) {
+    const ptr0 = passStringToWasm0(agent_pubkey, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.prepareAgentWallet(ptr0, len0, _delete, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmPreparedMessage.__wrap(ret[0]);
+}
+
+/**
+ * Prepare multiple orders - each becomes its own transaction (parallel)
+ *
+ * @param orders - Array of orders to prepare
+ * @param options - { account: string, signer?: string, nonce?: number }
+ * @returns Array of PreparedMessage
+ * @param {any} orders
+ * @param {any} options
+ * @returns {WasmPreparedMessage[]}
+ */
+export function prepareAll(orders, options) {
+    const ret = wasm.prepareAll(orders, options);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
+}
+
+/**
+ * Prepare faucet request for external signing
+ *
+ * @param options - { account: string, signer?: string, nonce?: number }
+ * @param {any} options
+ * @returns {WasmPreparedMessage}
+ */
+export function prepareFaucet(options) {
+    const ret = wasm.prepareFaucet(options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmPreparedMessage.__wrap(ret[0]);
+}
+
+/**
+ * Prepare multiple orders as ONE atomic transaction
+ *
+ * Use for bracket orders (entry + stop loss + take profit).
+ *
+ * @param orders - Array of orders for the atomic transaction
+ * @param options - { account: string, signer?: string, nonce?: number }
+ * @returns Single PreparedMessage containing all orders
+ * @param {any} orders
+ * @param {any} options
+ * @returns {WasmPreparedMessage}
+ */
+export function prepareGroup(orders, options) {
+    const ret = wasm.prepareGroup(orders, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmPreparedMessage.__wrap(ret[0]);
+}
+
+/**
+ * Prepare a single order for external wallet signing
+ *
+ * Use this when you don't have access to the private key and need
+ * to sign with an external wallet (like Phantom, Privy, etc).
+ *
+ * @param order - The order to prepare
+ * @param options - { account: string, signer?: string, nonce?: number }
+ * @returns PreparedMessage with messageBytes to sign
+ *
+ * @example
+ * ```typescript
+ * const prepared = prepareOrder(order, { account: myPubkey });
+ * const signature = await wallet.signMessage(prepared.messageBytes);
+ * const signed = prepared.finalize(signature);
+ * ```
+ * @param {any} order
+ * @param {any} options
+ * @returns {WasmPreparedMessage}
+ */
+export function prepareOrder(order, options) {
+    const ret = wasm.prepareOrder(order, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmPreparedMessage.__wrap(ret[0]);
+}
+
 /**
  * Generate a random hash (for client order IDs)
  * @returns {string}
@@ -387,6 +683,10 @@ function __wbg_get_imports() {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return ret;
         },
+        __wbg_Number_04624de7d0e8332d: function(arg0) {
+            const ret = Number(arg0);
+            return ret;
+        },
         __wbg_String_8f0eb39a4a4c2f66: function(arg0, arg1) {
             const ret = String(arg1);
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -394,6 +694,12 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
+        __wbg___wbindgen_bigint_get_as_i64_8fcf4ce7f1ca72a2: function(arg0, arg1) {
+            const v = arg1;
+            const ret = typeof(v) === 'bigint' ? v : undefined;
+            getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
         __wbg___wbindgen_boolean_get_bbbb1c18aa2f5e25: function(arg0) {
             const v = arg0;
             const ret = typeof(v) === 'boolean' ? v : undefined;
@@ -410,6 +716,10 @@ function __wbg_get_imports() {
             const ret = arg0 in arg1;
             return ret;
         },
+        __wbg___wbindgen_is_bigint_31b12575b56f32fc: function(arg0) {
+            const ret = typeof(arg0) === 'bigint';
+            return ret;
+        },
         __wbg___wbindgen_is_function_0095a73b8b156f76: function(arg0) {
             const ret = typeof(arg0) === 'function';
             return ret;
@@ -427,6 +737,10 @@ function __wbg_get_imports() {
             const ret = arg0 === undefined;
             return ret;
         },
+        __wbg___wbindgen_jsval_eq_11888390b0186270: function(arg0, arg1) {
+            const ret = arg0 === arg1;
+            return ret;
+        },
         __wbg___wbindgen_jsval_loose_eq_9dd77d8cd6671811: function(arg0, arg1) {
             const ret = arg0 == arg1;
             return ret;
@@ -464,6 +778,10 @@ function __wbg_get_imports() {
             const ret = arg0.done;
             return ret;
         },
+        __wbg_entries_58c7934c745daac7: function(arg0) {
+            const ret = Object.entries(arg0);
+            return ret;
+        },
         __wbg_error_7534b8e9a36f1ab4: function(arg0, arg1) {
             let deferred0_0;
             let deferred0_1;
@@ -500,6 +818,16 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_instanceof_Map_53af74335dec57f4: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Map;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_Uint8Array_9b9075935c74707c: function(arg0) {
             let result;
             try {
@@ -514,6 +842,10 @@ function __wbg_get_imports() {
             const ret = Array.isArray(arg0);
             return ret;
         },
+        __wbg_isSafeInteger_bfbc7332a9768d2a: function(arg0) {
+            const ret = Number.isSafeInteger(arg0);
+            return ret;
+        },
         __wbg_iterator_6ff6560ca1568e55: function() {
             const ret = Symbol.iterator;
             return ret;
@@ -629,6 +961,10 @@ function __wbg_get_imports() {
             const ret = arg0.versions;
             return ret;
         },
+        __wbg_wasmpreparedmessage_new: function(arg0) {
+            const ret = WasmPreparedMessage.__wrap(arg0);
+            return ret;
+        },
         __wbindgen_cast_0000000000000001: function(arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
@@ -673,6 +1009,9 @@ function __wbg_get_imports() {
 const WasmKeypairFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmkeypair_free(ptr >>> 0, 1));
+const WasmPreparedMessageFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpreparedmessage_free(ptr >>> 0, 1));
 const WasmSignerFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmsigner_free(ptr >>> 0, 1));
@@ -754,6 +1093,17 @@ function debugString(val) {
     return className;
 }
 
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);

package/package.json

@@ -2,7 +2,7 @@
   "name": "bulk-keychain-wasm",
   "type": "module",
   "description": "WASM bindings for BULK txn signing",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "repository": {
     "type": "git",
     "url": "https://github.com/bulk-trade/bulk-keychain"