@cartridge/controller-wasm 0.1.0

package/.gitignore

@@ -0,0 +1 @@
+*

package/account_wasm.d.ts

@@ -0,0 +1,163 @@
+/* tslint:disable */
+/* eslint-disable */
+export enum ErrorCode {
+  StarknetFailedToReceiveTransaction = 1,
+  StarknetContractNotFound = 20,
+  StarknetBlockNotFound = 24,
+  StarknetInvalidTransactionIndex = 27,
+  StarknetClassHashNotFound = 28,
+  StarknetTransactionHashNotFound = 29,
+  StarknetPageSizeTooBig = 31,
+  StarknetNoBlocks = 32,
+  StarknetInvalidContinuationToken = 33,
+  StarknetTooManyKeysInFilter = 34,
+  StarknetContractError = 40,
+  StarknetTransactionExecutionError = 41,
+  StarknetClassAlreadyDeclared = 51,
+  StarknetInvalidTransactionNonce = 52,
+  StarknetInsufficientMaxFee = 53,
+  StarknetInsufficientAccountBalance = 54,
+  StarknetValidationFailure = 55,
+  StarknetCompilationFailed = 56,
+  StarknetContractClassSizeIsTooLarge = 57,
+  StarknetNonAccount = 58,
+  StarknetDuplicateTx = 59,
+  StarknetCompiledClassHashMismatch = 60,
+  StarknetUnsupportedTxVersion = 61,
+  StarknetUnsupportedContractClassVersion = 62,
+  StarknetUnexpectedError = 63,
+  StarknetNoTraceAvailable = 10,
+  SignError = 101,
+  StorageError = 102,
+  AccountFactoryError = 103,
+  PaymasterExecutionTimeNotReached = 104,
+  PaymasterExecutionTimePassed = 105,
+  PaymasterInvalidCaller = 106,
+  PaymasterRateLimitExceeded = 107,
+  PaymasterNotSupported = 108,
+  PaymasterHttp = 109,
+  PaymasterExcecution = 110,
+  PaymasterSerialization = 111,
+  CartridgeControllerNotDeployed = 112,
+  InsufficientBalance = 113,
+  OriginError = 114,
+  EncodingError = 115,
+  SerdeWasmBindgenError = 116,
+  CairoSerdeError = 117,
+  CairoShortStringToFeltError = 118,
+  DeviceCreateCredential = 119,
+  DeviceGetAssertion = 120,
+  DeviceBadAssertion = 121,
+  DeviceChannel = 122,
+  DeviceOrigin = 123,
+  AccountSigning = 124,
+  AccountProvider = 125,
+  AccountClassHashCalculation = 126,
+  AccountClassCompression = 127,
+  AccountFeeOutOfRange = 128,
+  ProviderRateLimited = 129,
+  ProviderArrayLengthMismatch = 130,
+  ProviderOther = 131,
+  SessionAlreadyRegistered = 132,
+  UrlParseError = 133,
+  Base64DecodeError = 134,
+  CoseError = 135,
+  PolicyChainIdMismatch = 136,
+}
+export interface JsCall {
+    contractAddress: JsFelt;
+    entrypoint: string;
+    calldata: JsFelt[];
+}
+
+export type JsPriceUnit = "WEI" | "FRI";
+
+export interface JsEstimateFeeDetails {
+    nonce: JsFelt;
+}
+
+export interface JsFeeEstimate {
+    gas_consumed: JsFelt;
+    gas_price: JsFelt;
+    overall_fee: JsFelt;
+    unit: JsPriceUnit;
+    data_gas_consumed: JsFelt;
+    data_gas_price: JsFelt;
+}
+
+export interface Owner {
+    signer?: Signer;
+    account?: JsFelt;
+}
+
+export interface CallPolicy {
+    target: JsFelt;
+    method: JsFelt;
+    authorized?: boolean;
+}
+
+export interface TypedDataPolicy {
+    scope_hash: JsFelt;
+    authorized?: boolean;
+}
+
+export type Policy = CallPolicy | TypedDataPolicy;
+
+export interface WebauthnSigner {
+    rpId: string;
+    credentialId: string;
+    publicKey: string;
+}
+
+export interface StarknetSigner {
+    privateKey: JsFelt;
+}
+
+export interface Eip191Signer {
+    address: string;
+}
+
+export interface Signer {
+    webauthn?: WebauthnSigner;
+    starknet?: StarknetSigner;
+    eip191?: Eip191Signer;
+}
+
+export type JsFelt = Felt;
+
+export type Felts = JsFelt[];
+
+export type JsFeeSource = "PAYMASTER" | "CREDITS";
+
+export interface AuthorizedSession {
+    session: Session;
+    authorization: JsFelt[] | null;
+    isRegistered: boolean;
+    expiresAt: number;
+    allowedPoliciesRoot: JsFelt;
+    metadataHash: JsFelt;
+    sessionKeyGuid: JsFelt;
+    guardianKeyGuid: JsFelt;
+}
+
+export interface Session {
+    policies: Policy[];
+    expiresAt: number;
+    metadataHash: JsFelt;
+    sessionKeyGuid: JsFelt;
+    guardianKeyGuid: JsFelt;
+}
+
+export interface Credentials {
+    authorization: JsFelt[];
+    privateKey: JsFelt;
+}
+
+export class JsControllerError {
+  private constructor();
+  free(): void;
+  code: ErrorCode;
+  message: string;
+  get data(): string | undefined;
+  set data(value: string | null | undefined);
+}

package/account_wasm.js

@@ -0,0 +1,259 @@
+
+let imports = {};
+imports['__wbindgen_placeholder__'] = module.exports;
+let wasm;
+const { TextDecoder, TextEncoder } = require(`util`);
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+let cachedDataViewMemory0 = null;
+
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let cachedTextEncoder = new TextEncoder('utf-8');
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+/**
+ * @enum {1 | 20 | 24 | 27 | 28 | 29 | 31 | 32 | 33 | 34 | 40 | 41 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 10 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136}
+ */
+module.exports.ErrorCode = Object.freeze({
+    StarknetFailedToReceiveTransaction: 1, "1": "StarknetFailedToReceiveTransaction",
+    StarknetContractNotFound: 20, "20": "StarknetContractNotFound",
+    StarknetBlockNotFound: 24, "24": "StarknetBlockNotFound",
+    StarknetInvalidTransactionIndex: 27, "27": "StarknetInvalidTransactionIndex",
+    StarknetClassHashNotFound: 28, "28": "StarknetClassHashNotFound",
+    StarknetTransactionHashNotFound: 29, "29": "StarknetTransactionHashNotFound",
+    StarknetPageSizeTooBig: 31, "31": "StarknetPageSizeTooBig",
+    StarknetNoBlocks: 32, "32": "StarknetNoBlocks",
+    StarknetInvalidContinuationToken: 33, "33": "StarknetInvalidContinuationToken",
+    StarknetTooManyKeysInFilter: 34, "34": "StarknetTooManyKeysInFilter",
+    StarknetContractError: 40, "40": "StarknetContractError",
+    StarknetTransactionExecutionError: 41, "41": "StarknetTransactionExecutionError",
+    StarknetClassAlreadyDeclared: 51, "51": "StarknetClassAlreadyDeclared",
+    StarknetInvalidTransactionNonce: 52, "52": "StarknetInvalidTransactionNonce",
+    StarknetInsufficientMaxFee: 53, "53": "StarknetInsufficientMaxFee",
+    StarknetInsufficientAccountBalance: 54, "54": "StarknetInsufficientAccountBalance",
+    StarknetValidationFailure: 55, "55": "StarknetValidationFailure",
+    StarknetCompilationFailed: 56, "56": "StarknetCompilationFailed",
+    StarknetContractClassSizeIsTooLarge: 57, "57": "StarknetContractClassSizeIsTooLarge",
+    StarknetNonAccount: 58, "58": "StarknetNonAccount",
+    StarknetDuplicateTx: 59, "59": "StarknetDuplicateTx",
+    StarknetCompiledClassHashMismatch: 60, "60": "StarknetCompiledClassHashMismatch",
+    StarknetUnsupportedTxVersion: 61, "61": "StarknetUnsupportedTxVersion",
+    StarknetUnsupportedContractClassVersion: 62, "62": "StarknetUnsupportedContractClassVersion",
+    StarknetUnexpectedError: 63, "63": "StarknetUnexpectedError",
+    StarknetNoTraceAvailable: 10, "10": "StarknetNoTraceAvailable",
+    SignError: 101, "101": "SignError",
+    StorageError: 102, "102": "StorageError",
+    AccountFactoryError: 103, "103": "AccountFactoryError",
+    PaymasterExecutionTimeNotReached: 104, "104": "PaymasterExecutionTimeNotReached",
+    PaymasterExecutionTimePassed: 105, "105": "PaymasterExecutionTimePassed",
+    PaymasterInvalidCaller: 106, "106": "PaymasterInvalidCaller",
+    PaymasterRateLimitExceeded: 107, "107": "PaymasterRateLimitExceeded",
+    PaymasterNotSupported: 108, "108": "PaymasterNotSupported",
+    PaymasterHttp: 109, "109": "PaymasterHttp",
+    PaymasterExcecution: 110, "110": "PaymasterExcecution",
+    PaymasterSerialization: 111, "111": "PaymasterSerialization",
+    CartridgeControllerNotDeployed: 112, "112": "CartridgeControllerNotDeployed",
+    InsufficientBalance: 113, "113": "InsufficientBalance",
+    OriginError: 114, "114": "OriginError",
+    EncodingError: 115, "115": "EncodingError",
+    SerdeWasmBindgenError: 116, "116": "SerdeWasmBindgenError",
+    CairoSerdeError: 117, "117": "CairoSerdeError",
+    CairoShortStringToFeltError: 118, "118": "CairoShortStringToFeltError",
+    DeviceCreateCredential: 119, "119": "DeviceCreateCredential",
+    DeviceGetAssertion: 120, "120": "DeviceGetAssertion",
+    DeviceBadAssertion: 121, "121": "DeviceBadAssertion",
+    DeviceChannel: 122, "122": "DeviceChannel",
+    DeviceOrigin: 123, "123": "DeviceOrigin",
+    AccountSigning: 124, "124": "AccountSigning",
+    AccountProvider: 125, "125": "AccountProvider",
+    AccountClassHashCalculation: 126, "126": "AccountClassHashCalculation",
+    AccountClassCompression: 127, "127": "AccountClassCompression",
+    AccountFeeOutOfRange: 128, "128": "AccountFeeOutOfRange",
+    ProviderRateLimited: 129, "129": "ProviderRateLimited",
+    ProviderArrayLengthMismatch: 130, "130": "ProviderArrayLengthMismatch",
+    ProviderOther: 131, "131": "ProviderOther",
+    SessionAlreadyRegistered: 132, "132": "SessionAlreadyRegistered",
+    UrlParseError: 133, "133": "UrlParseError",
+    Base64DecodeError: 134, "134": "Base64DecodeError",
+    CoseError: 135, "135": "CoseError",
+    PolicyChainIdMismatch: 136, "136": "PolicyChainIdMismatch",
+});
+
+const JsControllerErrorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jscontrollererror_free(ptr >>> 0, 1));
+
+class JsControllerError {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsControllerErrorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jscontrollererror_free(ptr, 0);
+    }
+    /**
+     * @returns {ErrorCode}
+     */
+    get code() {
+        const ret = wasm.__wbg_get_jscontrollererror_code(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {ErrorCode} arg0
+     */
+    set code(arg0) {
+        wasm.__wbg_set_jscontrollererror_code(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {string}
+     */
+    get message() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.__wbg_get_jscontrollererror_message(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_0(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @param {string} arg0
+     */
+    set message(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_jscontrollererror_message(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get data() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.__wbg_get_jscontrollererror_data(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            let v1;
+            if (r0 !== 0) {
+                v1 = getStringFromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export_0(r0, r1 * 1, 1);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @param {string | null} [arg0]
+     */
+    set data(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_jscontrollererror_data(this.__wbg_ptr, ptr0, len0);
+    }
+}
+module.exports.JsControllerError = JsControllerError;
+
+module.exports.__wbindgen_throw = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+const path = require('path').join(__dirname, 'account_wasm_bg.wasm');
+const bytes = require('fs').readFileSync(path);
+
+const wasmModule = new WebAssembly.Module(bytes);
+const wasmInstance = new WebAssembly.Instance(wasmModule, imports);
+wasm = wasmInstance.exports;
+module.exports.__wasm = wasm;
+

package/account_wasm_bg.wasm.d.ts

@@ -0,0 +1,14 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_jscontrollererror_free: (a: number, b: number) => void;
+export const __wbg_get_jscontrollererror_code: (a: number) => number;
+export const __wbg_set_jscontrollererror_code: (a: number, b: number) => void;
+export const __wbg_get_jscontrollererror_message: (a: number, b: number) => void;
+export const __wbg_set_jscontrollererror_message: (a: number, b: number, c: number) => void;
+export const __wbg_get_jscontrollererror_data: (a: number, b: number) => void;
+export const __wbg_set_jscontrollererror_data: (a: number, b: number, c: number) => void;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
+export const __wbindgen_export_0: (a: number, b: number, c: number) => void;
+export const __wbindgen_export_1: (a: number, b: number) => number;
+export const __wbindgen_export_2: (a: number, b: number, c: number, d: number) => number;

package/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@cartridge/controller-wasm",
+  "version": "0.1.0",
+  "files": "[\"*.js\", \"*.wasm\", \"*.d.ts\"]",
+  "main": "account_wasm.js",
+  "types": "account_wasm.d.ts",
+  "repository": "https://github.com/cartridge-gg/controller-rs",
+  "license": "MIT"
+}

package/snippets/account-wasm-35da9c7350cbc3ae/src/wasm-mutex.js

@@ -0,0 +1,13 @@
+function releaseStub() {}
+
+export class Mutex {
+  lastPromise = Promise.resolve();
+
+  async obtain() {
+    let release = releaseStub;
+    const lastPromise = this.lastPromise;
+    this.lastPromise = new Promise((resolve) => (release = resolve));
+    await lastPromise;
+    return release;
+  }
+}