abel-ghost-sdk 0.0.1

package/dist/generated/AbelReaderSDK.js

@@ -0,0 +1,511 @@
+import { getArc56ReturnValue, getABIStructFromABITuple } from '@algorandfoundation/algokit-utils/types/app-arc56';
+import { AppClient as _AppClient, } from '@algorandfoundation/algokit-utils/types/app-client';
+import { AppFactory as _AppFactory } from '@algorandfoundation/algokit-utils/types/app-factory';
+export const APP_SPEC = { "name": "AbelReader", "structs": { "AssetTinyLabels": [{ "name": "name", "type": "string" }, { "name": "unitName", "type": "string" }, { "name": "decimals", "type": "uint8" }, { "name": "labels", "type": "string[]" }] }, "methods": [{ "name": "getAssetsTiny", "args": [{ "type": "uint64[]", "name": "assetIds" }, { "type": "uint64", "name": "abelAppId" }], "returns": { "type": "(string,string,uint8,string[])", "struct": "AssetTinyLabels" }, "actions": { "create": ["NoOp"], "call": ["NoOp"] }, "readonly": true, "events": [], "recommendations": {} }], "arcs": [22, 28], "networks": {}, "state": { "schema": { "global": { "ints": 0, "bytes": 0 }, "local": { "ints": 0, "bytes": 0 } }, "keys": { "global": {}, "local": {}, "box": {} }, "maps": { "global": {}, "local": {}, "box": {} } }, "bareActions": { "create": [], "call": [] }, "sourceInfo": { "approval": { "sourceInfo": [{ "pc": [170], "errorMessage": "Bytes has valid prefix" }, { "pc": [23], "errorMessage": "OnCompletion must be NoOp" }, { "pc": [185, 192, 195], "errorMessage": "asset exists" }, { "pc": [79], "errorMessage": "index access is out of bounds" }, { "pc": [38], "errorMessage": "invalid array length header" }, { "pc": [50], "errorMessage": "invalid number of bytes for arc4.dynamic_array<asset>" }, { "pc": [58, 175], "errorMessage": "invalid number of bytes for arc4.uint64" }, { "pc": [201], "errorMessage": "overflow" }], "pcOffsetMethod": "none" }, "clear": { "sourceInfo": [], "pcOffsetMethod": "none" } }, "source": { "approval": "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", "clear": "I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBAYWxnb3JhbmRmb3VuZGF0aW9uL2FsZ29yYW5kLXR5cGVzY3JpcHQvYmFzZS1jb250cmFjdC5kLnRzOjpCYXNlQ29udHJhY3QuY2xlYXJTdGF0ZVByb2dyYW0oKSAtPiB1aW50NjQ6Cm1haW46CiAgICBwdXNoaW50IDEgLy8gMQogICAgcmV0dXJuCg==" }, "byteCode": { "approval": "CyADCAABgATVqzNmNhoAjgEAAQAxGRREQgAAI0cDgAA2GgFHAiNZSU4CIguBAghMFRJENhoCSRUiEkQXI0lLAwxBAN9LA1cCAEsBIgtKIlhFC1tJRQZxC0UBQAAYgA0ABwAJAAALAAAAAAAAsEkkCEUBQv/IsYAEl/QKirIaSwiyGoAEAAJwdrIaI7IZSwGyGIEGshAjsgGztD5JVwQATFcABIAEFR98dRJESRUiEkQXSwVJcQRMRQpESXEDTEUJRHEBRBZJkyIORFcHAUUJQABEgAIAAEsHSRUWVwYCTFBJFYEHCEsISRUWVwYCTFBLARZXBgKAAgAHTFBLARVPAwhMSwxQTBZXBgJQTwJQTFBMULBC/1eACAABAAIAAnB2Qv+zgBEVH3x1AAcACQAACwAAAAAAALAkQw==", "clear": "C4EBQw==" }, "events": [], "templateVariables": {} };
+class BinaryStateValue {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    asByteArray() {
+        return this.value;
+    }
+    asString() {
+        return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined;
+    }
+}
+/**
+ * Converts the ABI tuple representation of a AssetTinyLabels to the struct representation
+ */
+export function AssetTinyLabelsFromTuple(abiTuple) {
+    return getABIStructFromABITuple(abiTuple, APP_SPEC.structs.AssetTinyLabels, APP_SPEC.structs);
+}
+/**
+ * Exposes methods for constructing `AppClient` params objects for ABI calls to the AbelReader smart contract
+ */
+export class AbelReaderParamsFactory {
+    /**
+     * Gets available create ABI call param factories
+     */
+    static get create() {
+        return {
+            _resolveByMethod(params) {
+                switch (params.method) {
+                    case 'getAssetsTiny':
+                    case 'getAssetsTiny(uint64[],uint64)(string,string,uint8,string[])':
+                        return AbelReaderParamsFactory.create.getAssetsTiny(params);
+                }
+                throw new Error(`Unknown ' + verb + ' method`);
+            },
+            /**
+             * Constructs create ABI call params for the AbelReader smart contract using the getAssetsTiny(uint64[],uint64)(string,string,uint8,string[]) ABI method
+             *
+             * @param params Parameters for the call
+             * @returns An `AppClientMethodCallParams` object for the call
+             */
+            getAssetsTiny(params) {
+                return {
+                    ...params,
+                    method: 'getAssetsTiny(uint64[],uint64)(string,string,uint8,string[])',
+                    args: Array.isArray(params.args) ? params.args : [params.args.assetIds, params.args.abelAppId],
+                };
+            },
+        };
+    }
+    /**
+     * Constructs a no op call for the getAssetsTiny(uint64[],uint64)(string,string,uint8,string[]) ABI method
+     *
+     * @param params Parameters for the call
+     * @returns An `AppClientMethodCallParams` object for the call
+     */
+    static getAssetsTiny(params) {
+        return {
+            ...params,
+            method: 'getAssetsTiny(uint64[],uint64)(string,string,uint8,string[])',
+            args: Array.isArray(params.args) ? params.args : [params.args.assetIds, params.args.abelAppId],
+        };
+    }
+}
+/**
+ * A factory to create and deploy one or more instance of the AbelReader smart contract and to create one or more app clients to interact with those (or other) app instances
+ */
+class AbelReaderFactory {
+    /**
+     * The underlying `AppFactory` for when you want to have more flexibility
+     */
+    appFactory;
+    /**
+     * Creates a new instance of `AbelReaderFactory`
+     *
+     * @param params The parameters to initialise the app factory with
+     */
+    constructor(params) {
+        this.appFactory = new _AppFactory({
+            ...params,
+            appSpec: APP_SPEC,
+        });
+    }
+    /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */
+    get appName() {
+        return this.appFactory.appName;
+    }
+    /** The ARC-56 app spec being used */
+    get appSpec() {
+        return APP_SPEC;
+    }
+    /** A reference to the underlying `AlgorandClient` this app factory is using. */
+    get algorand() {
+        return this.appFactory.algorand;
+    }
+    /**
+     * Returns a new `AppClient` client for an app instance of the given ID.
+     *
+     * Automatically populates appName, defaultSender and source maps from the factory
+     * if not specified in the params.
+     * @param params The parameters to create the app client
+     * @returns The `AppClient`
+     */
+    getAppClientById(params) {
+        return new AbelReaderClient(this.appFactory.getAppClientById(params));
+    }
+    /**
+     * Returns a new `AppClient` client, resolving the app by creator address and name
+     * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note).
+     *
+     * Automatically populates appName, defaultSender and source maps from the factory
+     * if not specified in the params.
+     * @param params The parameters to create the app client
+     * @returns The `AppClient`
+     */
+    async getAppClientByCreatorAndName(params) {
+        return new AbelReaderClient(await this.appFactory.getAppClientByCreatorAndName(params));
+    }
+    /**
+     * Idempotently deploys the AbelReader smart contract.
+     *
+     * @param params The arguments for the contract calls and any additional parameters for the call
+     * @returns The deployment result
+     */
+    async deploy(params = {}) {
+        const result = await this.appFactory.deploy({
+            ...params,
+            createParams: params.createParams?.method ? AbelReaderParamsFactory.create._resolveByMethod(params.createParams) : params.createParams ? params.createParams : undefined,
+        });
+        return { result: result.result, appClient: new AbelReaderClient(result.appClient) };
+    }
+    /**
+     * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation.
+     */
+    params = {
+        /**
+         * Gets available create methods
+         */
+        create: {
+            /**
+             * Creates a new instance of the AbelReader smart contract using the getAssetsTiny(uint64[],uint64)(string,string,uint8,string[]) ABI method.
+             *
+             * @param params The params for the smart contract call
+             * @returns The create params
+             */
+            getAssetsTiny: (params) => {
+                return this.appFactory.params.create(AbelReaderParamsFactory.create.getAssetsTiny(params));
+            },
+        },
+    };
+    /**
+     * Create transactions for the current app
+     */
+    createTransaction = {
+        /**
+         * Gets available create methods
+         */
+        create: {
+            /**
+             * Creates a new instance of the AbelReader smart contract using the getAssetsTiny(uint64[],uint64)(string,string,uint8,string[]) ABI method.
+             *
+             * @param params The params for the smart contract call
+             * @returns The create transaction
+             */
+            getAssetsTiny: (params) => {
+                return this.appFactory.createTransaction.create(AbelReaderParamsFactory.create.getAssetsTiny(params));
+            },
+        },
+    };
+    /**
+     * Send calls to the current app
+     */
+    send = {
+        /**
+         * Gets available create methods
+         */
+        create: {
+            /**
+             * Creates a new instance of the AbelReader smart contract using an ABI method call using the getAssetsTiny(uint64[],uint64)(string,string,uint8,string[]) ABI method.
+             *
+             * @param params The params for the smart contract call
+             * @returns The create result
+             */
+            getAssetsTiny: async (params) => {
+                const result = await this.appFactory.send.create(AbelReaderParamsFactory.create.getAssetsTiny(params));
+                return { result: { ...result.result, return: result.result.return }, appClient: new AbelReaderClient(result.appClient) };
+            },
+        },
+    };
+}
+/**
+ * A client to make calls to the AbelReader smart contract
+ */
+class AbelReaderClient {
+    /**
+     * The underlying `AppClient` for when you want to have more flexibility
+     */
+    appClient;
+    constructor(appClientOrParams) {
+        this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({
+            ...appClientOrParams,
+            appSpec: APP_SPEC,
+        });
+    }
+    /**
+     * Checks for decode errors on the given return value and maps the return value to the return type for the given method
+     * @returns The typed return value or undefined if there was no value
+     */
+    decodeReturnValue(method, returnValue) {
+        return returnValue !== undefined ? getArc56ReturnValue(returnValue, this.appClient.getABIMethod(method), APP_SPEC.structs) : undefined;
+    }
+    /**
+     * Returns a new `AbelReaderClient` client, resolving the app by creator address and name
+     * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note).
+     * @param params The parameters to create the app client
+     */
+    static async fromCreatorAndName(params) {
+        return new AbelReaderClient(await _AppClient.fromCreatorAndName({ ...params, appSpec: APP_SPEC }));
+    }
+    /**
+     * Returns an `AbelReaderClient` instance for the current network based on
+     * pre-determined network-specific app IDs specified in the ARC-56 app spec.
+     *
+     * If no IDs are in the app spec or the network isn't recognised, an error is thrown.
+     * @param params The parameters to create the app client
+     */
+    static async fromNetwork(params) {
+        return new AbelReaderClient(await _AppClient.fromNetwork({ ...params, appSpec: APP_SPEC }));
+    }
+    /** The ID of the app instance this client is linked to. */
+    get appId() {
+        return this.appClient.appId;
+    }
+    /** The app address of the app instance this client is linked to. */
+    get appAddress() {
+        return this.appClient.appAddress;
+    }
+    /** The name of the app. */
+    get appName() {
+        return this.appClient.appName;
+    }
+    /** The ARC-56 app spec being used */
+    get appSpec() {
+        return this.appClient.appSpec;
+    }
+    /** A reference to the underlying `AlgorandClient` this app client is using. */
+    get algorand() {
+        return this.appClient.algorand;
+    }
+    /**
+     * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation.
+     */
+    params = {
+        /**
+         * Makes a clear_state call to an existing instance of the AbelReader smart contract.
+         *
+         * @param params The params for the bare (raw) call
+         * @returns The clearState result
+         */
+        clearState: (params) => {
+            return this.appClient.params.bare.clearState(params);
+        },
+        /**
+         * Makes a call to the AbelReader smart contract using the `getAssetsTiny(uint64[],uint64)(string,string,uint8,string[])` ABI method.
+         *
+         * This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.
+         *
+         * @param params The params for the smart contract call
+         * @returns The call params
+         */
+        getAssetsTiny: (params) => {
+            return this.appClient.params.call(AbelReaderParamsFactory.getAssetsTiny(params));
+        },
+    };
+    /**
+     * Create transactions for the current app
+     */
+    createTransaction = {
+        /**
+         * Makes a clear_state call to an existing instance of the AbelReader smart contract.
+         *
+         * @param params The params for the bare (raw) call
+         * @returns The clearState result
+         */
+        clearState: (params) => {
+            return this.appClient.createTransaction.bare.clearState(params);
+        },
+        /**
+         * Makes a call to the AbelReader smart contract using the `getAssetsTiny(uint64[],uint64)(string,string,uint8,string[])` ABI method.
+         *
+         * This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.
+         *
+         * @param params The params for the smart contract call
+         * @returns The call transaction
+         */
+        getAssetsTiny: (params) => {
+            return this.appClient.createTransaction.call(AbelReaderParamsFactory.getAssetsTiny(params));
+        },
+    };
+    /**
+     * Send calls to the current app
+     */
+    send = {
+        /**
+         * Makes a clear_state call to an existing instance of the AbelReader smart contract.
+         *
+         * @param params The params for the bare (raw) call
+         * @returns The clearState result
+         */
+        clearState: (params) => {
+            return this.appClient.send.bare.clearState(params);
+        },
+        /**
+         * Makes a call to the AbelReader smart contract using the `getAssetsTiny(uint64[],uint64)(string,string,uint8,string[])` ABI method.
+         *
+         * This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.
+         *
+         * @param params The params for the smart contract call
+         * @returns The call result
+         */
+        getAssetsTiny: async (params) => {
+            const result = await this.appClient.send.call(AbelReaderParamsFactory.getAssetsTiny(params));
+            return { ...result, return: result.return };
+        },
+    };
+    /**
+     * Clone this app client with different params
+     *
+     * @param params The params to use for the the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value.
+     * @returns A new app client with the altered params
+     */
+    clone(params) {
+        return new AbelReaderClient(this.appClient.clone(params));
+    }
+    /**
+     * Makes a readonly (simulated) call to the AbelReader smart contract using the `getAssetsTiny(uint64[],uint64)(string,string,uint8,string[])` ABI method.
+     *
+     * This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.
+     *
+     * @param params The params for the smart contract call
+     * @returns The call result
+     */
+    async getAssetsTiny(params) {
+        const result = await this.appClient.send.call(AbelReaderParamsFactory.getAssetsTiny(params));
+        return result.return;
+    }
+    /**
+     * Methods to access state for the current AbelReader app
+     */
+    state = {};
+    newGroup() {
+        const client = this;
+        const composer = this.algorand.newGroup();
+        let promiseChain = Promise.resolve();
+        const resultMappers = [];
+        return {
+            /**
+             * Add a getAssetsTiny(uint64[],uint64)(string,string,uint8,string[]) method call against the AbelReader contract
+             */
+            getAssetsTiny(params) {
+                promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getAssetsTiny(params)));
+                resultMappers.push((v) => client.decodeReturnValue('getAssetsTiny(uint64[],uint64)(string,string,uint8,string[])', v));
+                return this;
+            },
+            /**
+             * Add a clear state call to the AbelReader contract
+             */
+            clearState(params) {
+                promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params)));
+                return this;
+            },
+            addTransaction(txn, signer) {
+                promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer));
+                return this;
+            },
+            async composer() {
+                await promiseChain;
+                return composer;
+            },
+            async simulate(options) {
+                await promiseChain;
+                const result = await (!options ? composer.simulate() : composer.simulate(options));
+                return {
+                    ...result,
+                    returns: result.returns?.map((val, i) => resultMappers[i] !== undefined ? resultMappers[i](val) : val.returnValue)
+                };
+            },
+            async send(params) {
+                await promiseChain;
+                const result = await composer.send(params);
+                return {
+                    ...result,
+                    returns: result.returns?.map((val, i) => resultMappers[i] !== undefined ? resultMappers[i](val) : val.returnValue)
+                };
+            }
+        };
+    }
+}
+/* BEGIN GHOST SDK CODE */
+import { getABIDecodedValue } from '@algorandfoundation/algokit-utils/types/app-arc56';
+import { makeEmptyTransactionSigner } from 'algosdk';
+const emptySigner = makeEmptyTransactionSigner();
+class GhostBase {
+    static factory = AbelReaderFactory;
+    static client = AbelReaderClient;
+    algorand;
+    readerAccount = 'A7NMWS3NT3IUDMLVO26ULGXGIIOUQ3ND2TXSER6EBGRZNOBOUIQXHIBGDE'; // non-mainnet fee sink
+    ghostAppId;
+    factory;
+    client;
+    cacheParamsTimeout = 75; // ms
+    constructor({ algorand, readerAccount, ghostAppId, }) {
+        this.algorand = algorand;
+        if (readerAccount)
+            this.readerAccount = readerAccount;
+        this.factory = this.algorand.client.getTypedAppFactory(AbelReaderFactory, {
+            defaultSender: this.readerAccount,
+        });
+        this.ghostAppId = ghostAppId;
+        this.client = this.factory.getAppClientById({ appId: ghostAppId ?? 13n });
+    }
+    async getAndCacheSuggestedParams() {
+        const suggestedParams = await this.algorand.getSuggestedParams();
+        if (this.cacheParamsTimeout) {
+            this.algorand.setSuggestedParamsCache(suggestedParams, new Date(Date.now() + this.cacheParamsTimeout));
+        }
+        return suggestedParams;
+    }
+    async execute({ signature, txnBuilder, methodArgsOrArgsArray, extraMethodCallArgs, extraSimulateArgs, }) {
+        await this.getAndCacheSuggestedParams();
+        const methodName = signature.slice(0, signature.indexOf('('));
+        let builder = this.client.newGroup();
+        if (this.ghostAppId) {
+            // deployed variant, we can call directly
+            const argsArray = Array.isArray(methodArgsOrArgsArray) ? methodArgsOrArgsArray : [methodArgsOrArgsArray];
+            for (let i = 0; i < argsArray.length; i++) {
+                const args = argsArray[i];
+                const extra = Array.isArray(extraMethodCallArgs) ? extraMethodCallArgs[i] : extraMethodCallArgs;
+                builder = txnBuilder(builder, { args, signer: emptySigner, ...extra });
+            }
+        }
+        else {
+            // ghost variant
+            // Avoiding .createTransaction because it compiles on the fly (why?). build app args and convert to app create
+            let throwawayBuilder = this.client.newGroup();
+            const argsArray = Array.isArray(methodArgsOrArgsArray) ? methodArgsOrArgsArray : [methodArgsOrArgsArray];
+            for (let i = 0; i < argsArray.length; i++) {
+                const args = argsArray[i];
+                const extra = Array.isArray(extraMethodCallArgs) ? extraMethodCallArgs[i] : extraMethodCallArgs;
+                throwawayBuilder = txnBuilder(throwawayBuilder, { args, signer: emptySigner, ...extra });
+            }
+            const { transactions } = await (await throwawayBuilder.composer()).buildTransactions();
+            // convert to app creates, copy to new real builder
+            for (const txn of transactions) {
+                // @ts-ignore
+                txn.applicationCall = {
+                    ...txn.applicationCall,
+                    appIndex: 0,
+                    approvalProgram: Buffer.from(APP_SPEC.byteCode.approval, 'base64'),
+                    clearProgram: Buffer.from(APP_SPEC.byteCode.clear, 'base64'),
+                    numGlobalByteSlices: APP_SPEC.state.schema.global.bytes,
+                    numGlobalInts: APP_SPEC.state.schema.global.ints,
+                    numLocalByteSlices: APP_SPEC.state.schema.local.bytes,
+                    numLocalInts: APP_SPEC.state.schema.local.ints,
+                    extraPages: 3,
+                };
+                builder = builder.addTransaction(txn, emptySigner);
+            }
+        }
+        const { confirmations } = await builder.simulate({
+            extraOpcodeBudget: 170000,
+            allowMoreLogging: true,
+            allowEmptySignatures: true,
+            allowUnnamedResources: true,
+            ...extraSimulateArgs,
+        });
+        const logs = confirmations.flatMap(({ logs }, i) => {
+            if (!logs)
+                throw new Error(`logs were not returned from simulate txn ${i}. this should never happen`);
+            return logs.slice(0, -1);
+        });
+        const specRetObj = this.client.appSpec.methods.find(({ name }) => name === methodName)?.returns;
+        if (!specRetObj)
+            throw new Error('Method not found in app spec');
+        const retTypeStr = specRetObj.struct ?? specRetObj.type;
+        const retData = [];
+        for (let i = 0; i < logs.length; i++) {
+            retData.push(getABIDecodedValue(new Uint8Array(logs[i]), retTypeStr, this.factory.appSpec.structs));
+        }
+        return retData;
+    }
+}
+export class AbelReaderSDK extends GhostBase {
+    constructor(args) {
+        super(args);
+    }
+    async getAssetsTiny({ methodArgsOrArgsArray, extraMethodCallArgs, extraSimulateArgs, }) {
+        return this.execute({
+            signature: 'getAssetsTiny(uint64[],uint64)(string,string,uint8,string[])',
+            txnBuilder: (builder, args) => builder.getAssetsTiny(args),
+            methodArgsOrArgsArray,
+            extraMethodCallArgs,
+            extraSimulateArgs,
+        });
+    }
+}
+/* END GHOST SDK CODE */