DFINITY Foundation's vote on proposal 132091

Governance
1

The DFINITY Foundation is voting REJECT on proposal 132091. The vote is not to be understood as a statement against the existence of a ckLTC canister implementing a twin token for Litecoin in general, but instead is rather due to the lack of detail provided in the proposal. The Foundation considers this proposal insufficient for building consensus on this integration in the community and thus rejects this proposal.

10 Likes
2
4

Proposal 132147 doesn’t seem like an improvement over proposal 132091.

I know LTC is not an ERC20 token, but this thread linked below provides an example of the type of detail that you might want to consider putting into the proposal. The first attempt at ckOCT didn’t pass, but that was because there wasn’t a lot of clarity offered on what to look for in the proposal. It was the first time the community attempted to create a ckERC20 token, so it took extra effort. However, the discussion clearly shows the support and interest that DFINITY and others in the community have for people who want to take action to launch these ck tokens.

Please note in the case of ckERC20 tokens, it is not a Governance Motion proposal that is submitted, but instead it is a System Canister Management proposal. This type of proposal can be submitted by the community for any ERC20 token to create the ckERC20 twin.

I don’t know the status of being able to do the same for LTC, but surely it will require much more discussion and a stronger case for DFINITY to commit resources to making it happen. They have to prioritize ckLTC among other tokens such as ckSOL, etc.

Good luck on this new version of your proposal @Henry_Suso, but if it doesn’t pass again then I hope this feedback helps for the next attempt.

4 Likes
7

We have ckPEPE

You think there’s not enough use for ckLTC?

CkLTC has a higher tx rate than btc

8

Here,

import Nat “mo:base/Nat”;
import Principal “mo:base/Principal”;
import Iter “mo:base/Iter”;
import HashMap “mo:base/HashMap”;

// Define a type for the ledger entry
type Balance = Nat;

// Define a type for the ckLTC Ledger
actor ckLTC {

// Ledger to store account balances
var ledger = HashMap.HashMap<Principal, Balance>();

// Total supply of ckLTC tokens
var totalSupply: Balance = 0n;

// Event types
type TransferEvent = {
    from: Principal;
    to: Principal;
    amount: Balance;
};

// List to keep track of transfer events
var events: [TransferEvent] = [];

// Function to mint ckLTC tokens to a specified account
public func mint(to: Principal, amount: Balance) : async () {
    if (amount > 0n) {
        let currentBalance = ledger.get(to).optNat(0n);
        ledger.put(to, currentBalance + amount);
        totalSupply += amount;

        // Log the minting event
        events := events # [{from = Principal.fromText("aaaaa-aa"); to = to; amount = amount}];
    }
};

// Function to burn ckLTC tokens from a specified account
public func burn(from: Principal, amount: Balance) : async () {
let currentBalance = ledger.get(from).optNat(0n);
if (currentBalance >= amount && amount > 0n) {
ledger.put(from, currentBalance - amount);
totalSupply -= amount;

        // Log the burning event
        events := events # [{from = from; to = Principal.fromText("aaaaa-aa"); amount = amount}];
    } else {
        throw Error.reject("Insufficient balance or invalid amount.");
    }
};

// Function to transfer ckLTC tokens from one account to another
public func transfer(from: Principal, to: Principal, amount: Balance) : async () {
    let fromBalance = ledger.get(from).optNat(0n);
    if (fromBalance >= amount && amount > 0n) {
        ledger.put(from, fromBalance - amount);
        let toBalance = ledger.get(to).optNat(0n);
        ledger.put(to, toBalance + amount);

        // Log the transfer event
        events := events # [{from = from; to = to; amount = amount}];
    } else {
        throw Error.reject("Insufficient balance or invalid amount.");
    }
};

// Function to check the balance of a specified account
public query func balanceOf(account: Principal) : async Balance {
    return ledger.get(account).optNat(0n);
};

// Function to get the total supply of ckLTC tokens
public query func getTotalSupply() : async Balance {
    return totalSupply;
};

// Function to get the list of transfer events
public query func getTransferEvents() : async [TransferEvent] {
    return events;
};
9

I probably should have provided more details in my above post.

The hesitation is not in terms of whether there should be ckLTC. There should be many ck-tokens, and LTC is certainly one of the more well-established chains. So having ckLTC eventually seems a laudable goal.

The integration of new tokens – except for ERC20 tokens on Ethereum, which is by now a pretty lean process – is a big effort. As LTC is its own, independent chain, it would likely benefit a lot from a direct integration similarly to BTC/ckBTC. Yet, such a direct integration on the protocol level is a major engineering effort that, if taken on, would significantly delay other features that would also bring ICP forward.

As the proposal does not detail how the integration with LTC is supposed to be achieved or what the benefits of the integration is compared to other work currently on the roadmap (e.g., ckSOL), I think that neither the original proposal nor the subsequent one offer sufficient detail for the community to make an informed decision.

4 Likes