stakeordie/griptape.js

Griptape is a framework for developing dApps on Secret Network.

griptape.js's Issues

Complete SNIP-20 contract definition

Complete the implementation of the contract definition for the SNIP-20 spec.

References:

• https://github.com/SecretFoundation/SNIPs/blob/master/SNIP-20.md

`queries` and `messages` objects are not optional in a contract definition

When trying to define an empty contract definition, you get an error in TypeScript, e.g.

const def = {};

Expected result

queries and/or messages should be optional.

Add support for SNIP-721 contract definition

Add support for SNIP-741 contract definition.

Add Viewing Keys API Keplr wrapper

Add a wrapped version of the Viewing Keys API to enable users to create viewing keys using Keplr and pass them into the current Viewing Keys API:

import { keplrViewingKeyManager as vks } from '@stakeordie/griptape.js';

const sefi = ...
const key = ...
vks.add(sefi, key);

Add Bank module

Add `shutdown` function

This function should do:

• Remove the "connected" local storage key
• Emit a new event called "shutdown" and add its proper listener called onShutdown

Add returning types for snip-721 contract

Add contract code hash to improve performance

Update docs for 0.6.0

Write a draft for all the different APIs and deploy them to https://docs.griptapejs.com.

Viewing Key API `add` method has wrong TypeScript for the first parameter

When using Griptape.js in TypeScript, add method in ViewingKeyManager class has the wrong type for contracts, therefore you get a type error in TypeScript.

Steps to reproduce the behavior:

1. Create a contract instance.
2. Use ViewingKeyManager instance to add a viewing for that contract instance.

Expected behavior
There should be no error.

Screenshots

Not error is being thrown when adding an `undefined` viewing key

When using the viewingKeyManager.add and as the second argument you pass undefined, you don't get any error,
and a viewing key gets added without key.

To Reproduce

1. import viewingKeyManager from @stakeordie/griptape.js
2. Define a simple contract to add a viewing key for
3. Use the viewingKeyManager.add method and pass undefined as the second parameter
4. Check localStorage

Expected behavior

It should throw an error due to the fact that you are adding an undefined viewing key.

Add Slashing module

Rename `Callback` type on `src/events/index.ts`

• Change Callback to EventCallback
• Create a new type for returned callback from an Event Handler named CleanListenerCallback
• Change all returned references to return the CleanListenerCallback

export type CleanListenerCallback = () => void;

Please update the documentation

Please update the documentation bro.. please.

i got some error during run time.
https://github.com/stakeordie/griptape-docs/tree/main/docs/tutorial

Deprecate `createContract` function

Deprecate create contract function by adding the proper JSDoc.

Add event `unsubscribe` method

Add a method to unsubscribe from an event, something like:

const unsubscribe = onAccountAvailable(
  () => console.log('Account available!'));
unsubscribe(); // remove the last callback

Update contracts definitions

Add Supply module

Fix `deposit` message in `snip20Def`

Add a function to get balance

The signature of the function should be like this:

export async function getBalance(): Promise<string>;

`onAccountChange` doesn't refresh the account address

When calling getAddress on the onAccountChange it doesn't refresh the account and therefore, cannot query or execute any message for a contract.

Create Permits definitions for snip20 and snip721

Add Tendermint RPC module

Add entropy as part of the context in the Contracts API

Some messages require and entropy as describe in some of the SNIP-20 specification.

Let's remove the responsibility of the user of the Contracts API to provide that piece of data by adding entropy as part of the Contracts API context. So the final interface for the context will be:

export interface Context {
  address?: string;
  key?: string;
  padding?: string;
  height?: number;
  entropy: string;
}

Remove SNIP-20 specific code for preventing query/message execution

When executing a contract, there is some SNIP-20 specific code that handles and warns the user if they are not providing either an address or key for a specific query as follows:

griptape.js/src/contracts/index.ts

Lines 104 to 114 in a0d0f94

	const hasAddress = getValue(result, 'address');
	if (hasOwnDeepProperty(result, 'address') && !hasAddress) {
	warn(func, result, 'No address available');
	return;
	}
	const hasKey = getValue(result, 'key');
	if (hasOwnDeepProperty(result, 'key') && !hasKey) {
	warn(func, result, 'No key available');
	return;
	}

We should remove this and maybe provide and API to handle specific scenarios in which we want to prevent the execution of a query.

Refactor common types between modules

create common types between modules in types.ts file and remove them from specific modules

Add returning types for snip-20 contract

Add permits

Feature Request

Server Side querying of public universal data. Example: n/900 minted.

Export all functions from the `src/events/index.ts` file in the `src/index.ts` file

Add to src/index.ts the export for the src/events/index.ts file:

export * from './events/index.ts';

Also export everything for all other modules in the src/events in the src/events/index.ts file, like:

export * from './accounts';

So we can do this:

import {
  Callback
} from '@stakeordie/griptape.js';

Add Staking module

Add Governance module

Lazy initialize Keplr

Change `fees` type of `ContractMessageRequest`

Change the type of fees property to be number and calculate the fees based on the following function:

const gasPriceUscrt = 0.25;
export function getFeeForExecute(gas: number): StdFee {
  return {
    amount: [
      { amount: String(Math.floor(gas * gasPriceUscrt) + 1), denom: "uscrt" },
    ],
    gas: String(gas),
  };
}

So then, you can do:

const stkd = {
  messages: {
    stake() {
      const handleMsg = { stake: { } };
      const fees = 650000;
      return { handleMsg, fees };
    }
  }
}

Change names for multi message functions

• Change message to buildMessage
• Change multiMessage to executeMultiMessage

Add Distribution module

Adjust `transferAmount` parameter

When calling contracts, adjust transferAmount to receive an Object rather than an array:

doTx() {
  const transferAmount = { amount: '...', denom: '...' };
  return { transferAmount };
}

Add package exports for namespacing

As an API grows, I find valuable to being able to use only specific parts of the API by using nodejs subpath exports.

This means, the API should be imported in a submodule fashion:

import { refContract } from '@stakeordie/griptape.js/contracts';
import { snip20def } from '@stakeordie/griptape.js/contracts/definitions'

Add contracts registry to the Contracts API

This feature request is for adding to the Contracts API a contract registry. The purpose of the contract registry is to hold all the instances of a particular contract, such that you are able to get that contract through an API rather that accessing to the itself.

Here's and example of how that API will look:

import {
  snip20Def,
  createContract,
  getContract
} from '@stakeordie/griptape.js';

const stkd = createContract(...);

const list = getSnip20s(); // [ { symbol: '...', address: '...' } ]

list.forEach(({ symbol: id, address: at }) => {
  const spec = { id, at, definition: snip20Def };
  createContract(spec);
})

getContract('sefi').getBalance();
getContract('stkd').getBalance();

getContract('stkd') === stkd // true

Add sync mode to contracts API

Adjust `entropy` and `padding` in Contract Context

• padding make it 32 length
• entropy make it 32 length and encode it to base64

Create base class for Secret Network modules

JSON to TypeScript: https://jsonformatter.org/json-to-typescript
Secret API: https://secretapi.io/#/

This base class should handle the following:

class BlockchainModule {
  client: AxiosInstance;

  constructor(baseURL: string) {
    this.client = axios.create({ baseURL });
  }
}

Add Mint module

Add jsDoc

Pretty self-explanatory.

Add support for multi transactions

Add support for multi transactions based on the multiExecute API on secretjs.

The API might look like this:

const sefi = createContract(...);
multiMessage([
  message(sefi.send),
  message(sefi.transfer, arg1, arg2)
])

Decrypt error message when executing a message

Add `createContractClient`

Basically is a renaming of the deprecated createContract function.

Handling contract responses

When calling a contract, sometimes the respond contains valuable information that could be used for example, to improve UI/UX. The issue here is that the current secretjs implementation, returns a data property as an array of integers (bytes). One way to handle and properly decode these set of integer could be as follows:

const decoder = new TextDecoder('utf-8');
const raw = await sefi.createViewingKey();
const decoded = decoder.decode(raw.data);
if (decoded) {
  const res = JSON.parse(decoded);
  viewingKeyManager.add(sefi, res.create_viewing_key.key);
}

That being said, there should be a way of:

1. Get the raw response as a javascript object
2. Get just the response of the data property
3. Being able to handle empty responses

In order to do that, I propose the following API:

interface ContractResponse {
  get: () => object;
  getRaw: () => object;
  isEmpty: () => boolean;
}

Add support for utility functions for contract management

secretjs has methods for getting contracts and instantiated them like, mostly those on SigningCosmWasm:

interface SigningCosmWasmClient {
  instantiate(
    codeId: number,
    initMsg: object,
    label: string,
    memo?: string,
    transferAmount?: readonly Coin[],
    fee?: StdFee,
    contractCodeHash?: string,
  ): Promise<InstantiateResult>;
}

Lets expose those features to be able to manage contracts (upload code, instantiate and get them from the blockchain)

Add Auth module